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

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: