Return to pool.c CVS log

Up to [local] / src / usr.bin / ctfconv

Annotation of src/usr.bin/ctfconv/pool.c, Revision 1.1

1.1     ! mpi         1: /*
        !             2:  * Copyright (c) 2017 Martin Pieuchot
        !             3:  *
        !             4:  * Permission to use, copy, modify, and distribute this software for any
        !             5:  * purpose with or without fee is hereby granted, provided that the above
        !             6:  * copyright notice and this permission notice appear in all copies.
        !             7:  *
        !             8:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
        !             9:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
        !            10:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
        !            11:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
        !            12:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
        !            13:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
        !            14:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
        !            15:  */
        !            16:
        !            17: #ifndef NOPOOL
        !            18:
        !            19: #include <sys/param.h>
        !            20: #include <sys/types.h>
        !            21: #include <sys/queue.h>
        !            22:
        !            23: #include <assert.h>
        !            24: #include <stdio.h>
        !            25: #include <stdlib.h>
        !            26: #include <string.h>
        !            27:
        !            28: #include "xmalloc.h"
        !            29: #include "pool.h"
        !            30:
        !            31: #define MAXIMUM(a, b)  (((a) > (b)) ? (a) : (b))
        !            32:
        !            33: struct pool_item {
        !            34:        SLIST_ENTRY(pool_item) pi_list;
        !            35: };
        !            36:
        !            37: SIMPLEQ_HEAD(, pool) pool_head = SIMPLEQ_HEAD_INITIALIZER(pool_head);
        !            38:
        !            39: void
        !            40: pool_init(struct pool *pp, const char *name, size_t nmemb, size_t size)
        !            41: {
        !            42:        size = MAXIMUM(size, sizeof(struct pool_item));
        !            43:
        !            44:        SLIST_INIT(&pp->pr_free);
        !            45:        pp->pr_name = name;
        !            46:        pp->pr_nmemb = nmemb;
        !            47:        pp->pr_size = size;
        !            48:        pp->pr_nitems = 0;
        !            49:        pp->pr_nfree = 0;
        !            50:
        !            51:        SIMPLEQ_INSERT_TAIL(&pool_head, pp, pr_list);
        !            52: }
        !            53:
        !            54: void *
        !            55: pool_get(struct pool *pp)
        !            56: {
        !            57:        struct pool_item *pi;
        !            58:
        !            59:        if (SLIST_EMPTY(&pp->pr_free)) {
        !            60:                char *p;
        !            61:                size_t i;
        !            62:
        !            63:                p = xreallocarray(NULL, pp->pr_nmemb, pp->pr_size);
        !            64:                for (i = 0; i < pp->pr_nmemb; i++) {
        !            65:                        pi = (struct pool_item *)p;
        !            66:                        SLIST_INSERT_HEAD(&pp->pr_free, pi, pi_list);
        !            67:                        p += pp->pr_size;
        !            68:                }
        !            69:                pp->pr_nitems += pp->pr_nmemb;
        !            70:                pp->pr_nfree += pp->pr_nmemb;
        !            71:        }
        !            72:
        !            73:        pi = SLIST_FIRST(&pp->pr_free);
        !            74:        SLIST_REMOVE_HEAD(&pp->pr_free, pi_list);
        !            75:        pp->pr_nfree--;
        !            76:
        !            77:        return pi;
        !            78: }
        !            79:
        !            80: void
        !            81: pool_put(struct pool *pp, void *p)
        !            82: {
        !            83:        struct pool_item *pi = (struct pool_item *)p;
        !            84:
        !            85:        if (pi == NULL)
        !            86:                return;
        !            87:
        !            88:        assert(pp->pr_nfree < pp->pr_nitems);
        !            89:
        !            90:        SLIST_INSERT_HEAD(&pp->pr_free, pi, pi_list);
        !            91:        pp->pr_nfree++;
        !            92: }
        !            93:
        !            94: void
        !            95: pool_dump(void)
        !            96: {
        !            97:        struct pool *pp;
        !            98:
        !            99:        SIMPLEQ_FOREACH(pp, &pool_head, pr_list)
        !           100:                printf("%s: %zd items, %zd free\n", pp->pr_name, pp->pr_nitems,
        !           101:                    pp->pr_nfree);
        !           102: }
        !           103: #endif /* NOPOOL */