Return to resource.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib

Annotation of embedaddon/bird2/lib/resource.h, revision 1.1

1.1     ! misho       1: /*
        !             2:  *     BIRD Resource Manager
        !             3:  *
        !             4:  *     (c) 1998--1999 Martin Mares <mj@ucw.cz>
        !             5:  *
        !             6:  *     Can be freely distributed and used under the terms of the GNU GPL.
        !             7:  */
        !             8: 
        !             9: #ifndef _BIRD_RESOURCE_H_
        !            10: #define _BIRD_RESOURCE_H_
        !            11: 
        !            12: #include "lib/lists.h"
        !            13: 
        !            14: /* Resource */
        !            15: 
        !            16: typedef struct resource {
        !            17:   node n;                              /* Inside resource pool */
        !            18:   struct resclass *class;              /* Resource class */
        !            19: } resource;
        !            20: 
        !            21: /* Resource class */
        !            22: 
        !            23: struct resclass {
        !            24:   char *name;                          /* Resource class name */
        !            25:   unsigned size;                       /* Standard size of single resource */
        !            26:   void (*free)(resource *);            /* Freeing function */
        !            27:   void (*dump)(resource *);            /* Dump to debug output */
        !            28:   resource *(*lookup)(resource *, unsigned long);      /* Look up address (only for debugging) */
        !            29:   size_t (*memsize)(resource *);       /* Return size of memory used by the resource, may be NULL */
        !            30: };
        !            31: 
        !            32: /* Estimate of system allocator overhead per item, for memory consumtion stats */
        !            33: #define ALLOC_OVERHEAD         8
        !            34: 
        !            35: /* Generic resource manipulation */
        !            36: 
        !            37: typedef struct pool pool;
        !            38: 
        !            39: void resource_init(void);
        !            40: pool *rp_new(pool *, const char *);    /* Create new pool */
        !            41: void rfree(void *);                    /* Free single resource */
        !            42: void rdump(void *);                    /* Dump to debug output */
        !            43: size_t rmemsize(void *res);            /* Return size of memory used by the resource */
        !            44: void rlookup(unsigned long);           /* Look up address (only for debugging) */
        !            45: void rmove(void *, pool *);            /* Move to a different pool */
        !            46: 
        !            47: void *ralloc(pool *, struct resclass *);
        !            48: 
        !            49: extern pool root_pool;
        !            50: 
        !            51: /* Normal memory blocks */
        !            52: 
        !            53: void *mb_alloc(pool *, unsigned size);
        !            54: void *mb_allocz(pool *, unsigned size);
        !            55: void *mb_realloc(void *m, unsigned size);
        !            56: void mb_free(void *);
        !            57: 
        !            58: /* Memory pools with linear allocation */
        !            59: 
        !            60: typedef struct linpool linpool;
        !            61: 
        !            62: typedef struct lp_state {
        !            63:   void *current, *large;
        !            64:   byte *ptr;
        !            65: } lp_state;
        !            66: 
        !            67: linpool *lp_new(pool *, unsigned blk);
        !            68: void *lp_alloc(linpool *, unsigned size);      /* Aligned */
        !            69: void *lp_allocu(linpool *, unsigned size);     /* Unaligned */
        !            70: void *lp_allocz(linpool *, unsigned size);     /* With clear */
        !            71: void lp_flush(linpool *);                      /* Free everything, but leave linpool */
        !            72: void lp_save(linpool *m, lp_state *p);         /* Save state */
        !            73: void lp_restore(linpool *m, lp_state *p);      /* Restore state */
        !            74: 
        !            75: extern const int lp_chunk_size;
        !            76: #define LP_GAS             1024
        !            77: #define LP_GOOD_SIZE(x)            (((x + LP_GAS - 1) & (~(LP_GAS - 1))) - lp_chunk_size)
        !            78: #define lp_new_default(p)   lp_new(p, LP_GOOD_SIZE(LP_GAS*4))
        !            79: 
        !            80: /* Slabs */
        !            81: 
        !            82: typedef struct slab slab;
        !            83: 
        !            84: slab *sl_new(pool *, unsigned size);
        !            85: void *sl_alloc(slab *);
        !            86: void sl_free(slab *, void *);
        !            87: 
        !            88: /*
        !            89:  * Low-level memory allocation functions, please don't use
        !            90:  * outside resource manager and possibly sysdep code.
        !            91:  */
        !            92: 
        !            93: void buffer_realloc(void **buf, unsigned *size, unsigned need, unsigned item_size);
        !            94: 
        !            95: 
        !            96: #ifdef HAVE_LIBDMALLOC
        !            97: /*
        !            98:  * The standard dmalloc macros tend to produce lots of namespace
        !            99:  * conflicts and we use only xmalloc, xrealloc and xfree, so we
        !           100:  * can define the stubs ourselves.
        !           101:  */
        !           102: #define DMALLOC_DISABLE
        !           103: #include <dmalloc.h>
        !           104: #define xmalloc(size) \
        !           105:   dmalloc_malloc(__FILE__, __LINE__, (size), DMALLOC_FUNC_MALLOC, 0, 1)
        !           106: #define xrealloc(ptr, size) \
        !           107:   dmalloc_realloc(__FILE__, __LINE__, (ptr), (size), DMALLOC_FUNC_REALLOC, 1)
        !           108: #define xfree(ptr) \
        !           109:   dmalloc_free(__FILE__, __LINE__, (ptr), DMALLOC_FUNC_FREE)
        !           110: 
        !           111: #else
        !           112: /*
        !           113:  * Unfortunately, several libraries we might want to link to define
        !           114:  * their own xmalloc and we don't want to interfere with them, hence
        !           115:  * the renaming.
        !           116:  */
        !           117: #define xmalloc bird_xmalloc
        !           118: #define xrealloc bird_xrealloc
        !           119: void *xmalloc(unsigned);
        !           120: void *xrealloc(void *, unsigned);
        !           121: #define xfree(x) free(x)
        !           122: #endif
        !           123: 
        !           124: #endif
        !           125: