util/nmem.c

   1 /*
   2  * Copyright (c) 1995-1998, Index Data.
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: nmem.c,v $
   7  * Revision 1.10  1998-07-20 12:35:57  adam
   8  * Added more memory diagnostics (when NMEM_DEBUG is 1).
   9  *
  10  * Revision 1.9  1998/07/07 15:49:01  adam
  11  * Reduced chunk size.
  12  *
  13  * Revision 1.8  1998/07/03 14:21:27  adam
  14  * Added critical sections for pthreads-library. Thanks to Ian Ibbotson,
  15  * Fretwell Downing Informatics.
  16  *
  17  * Revision 1.7  1998/02/11 11:53:36  adam
  18  * Changed code so that it compiles as C++.
  19  *
  20  * Revision 1.6  1997/10/31 12:20:09  adam
  21  * Improved memory debugging for xmalloc/nmem.c. References to NMEM
  22  * instead of ODR in n ESPEC-1 handling in source d1_espec.c.
  23  * Bug fix: missing fclose in data1_read_espec1.
  24  *
  25  * Revision 1.5  1997/10/06 09:09:52  adam
  26  * Function mmem_exit releases memory used by the freelists.
  27  *
  28  * Revision 1.4  1997/09/29 07:12:50  adam
  29  * NMEM thread safe. NMEM must be initialized before use (sigh) -
  30  * routine nmem_init/nmem_exit implemented.
  31  *
  32  * Revision 1.3  1997/07/21 12:47:38  adam
  33  * Moved definition of nmem_control and nmem_block.
  34  *
  35  * Revision 1.2  1995/12/13 13:44:37  quinn
  36  * Modified Data1-system to use nmem
  37  *
  38  * Revision 1.1  1995/11/13  09:27:52  quinn
  39  * Fiddling with the variant stuff.
  40  *
  41  *
  42  */
  43
  44 /*
  45  * This is a simple and fairly wasteful little module for nibble memory
  46  * allocation. Evemtually we'll put in something better.
  47  */
  48
  49 #include <xmalloc.h>
  50 #include <nmem.h>
  51 #include <log.h>
  52 #ifdef WINDOWS
  53 #include <windows.h>
  54 #elif _REENTRANT
  55 #include <pthread.h>
  56 #endif
  57
  58 #define NMEM_CHUNK (4*1024)
  59
  60 #ifdef WINDOWS
  61 static CRITICAL_SECTION critical_section;
  62 #define NMEM_ENTER EnterCriticalSection(&critical_section)
  63 #define NMEM_LEAVE LeaveCriticalSection(&critical_section)
  64 #elif _REENTRANT
  65 static pthread_mutex_t nmem_mutex;
  66 #define NMEM_ENTER pthread_mutex_lock(&nmem_mutex);
  67 #define NMEM_LEAVE pthread_mutex_unlock(&nmem_mutex);
  68 #else
  69 #define NMEM_ENTER
  70 #define NMEM_LEAVE
  71 #endif
  72
  73 static nmem_block *freelist = NULL;        /* "global" freelists */
  74 static nmem_control *cfreelist = NULL;
  75 static int nmem_active_no = 0;
  76
  77 static void free_block(nmem_block *p)
  78 {
  79     p->next = freelist;
  80     freelist = p;
  81 #if NMEM_DEBUG
  82     logf (LOG_DEBUG, "nmem free_block p=%p", p);
  83 #endif
  84 }
  85
  86 /*
  87  * acquire a block with a minimum of size free bytes.
  88  */
  89 static nmem_block *get_block(int size)
  90 {
  91     nmem_block *r, *l;
  92
  93 #if NMEM_DEBUG
  94     logf (LOG_DEBUG, "nmem get_block size=%d", size);
  95 #endif
  96     for (r = freelist, l = 0; r; l = r, r = r->next)
  97         if (r->size >= size)
  98             break;
  99     if (r)
 100     {
 101 #if NMEM_DEBUG
 102         logf (LOG_DEBUG, "nmem get_block found free block p=%p", r);
 103 #endif
 104         if (l)
 105             l->next = r->next;
 106         else
 107             freelist = r->next;
 108     }
 109     else
 110     {
 111         int get = NMEM_CHUNK;
 112
 113         if (get < size)
 114             get = size;
 115 #if NMEM_DEBUG
 116         logf (LOG_DEBUG, "nmem get_block alloc new block size=%d", get);
 117 #endif
 118         r = (nmem_block *)xmalloc(sizeof(*r));
 119         r->buf = (char *)xmalloc(r->size = get);
 120     }
 121     r->top = 0;
 122     return r;
 123 }
 124
 125 void nmem_reset(NMEM n)
 126 {
 127     nmem_block *t;
 128
 129 #if NMEM_DEBUG
 130     logf (LOG_DEBUG, "nmem_reset p=%p", n);
 131 #endif
 132     if (!n)
 133         return;
 134     NMEM_ENTER;
 135     while (n->blocks)
 136     {
 137         t = n->blocks;
 138         n->blocks = n->blocks->next;
 139         free_block(t);
 140     }
 141     NMEM_LEAVE;
 142     n->total = 0;
 143 }
 144
 145 #if NMEM_DEBUG
 146 void *nmem_malloc_f (const char *file, int line, NMEM n, int size)
 147 #else
 148 void *nmem_malloc(NMEM n, int size)
 149 #endif
 150 {
 151     struct nmem_block *p;
 152     char *r;
 153
 154 #if NMEM_DEBUG
 155     logf (LOG_DEBUG, "%s:%d: nmem_malloc p=%p size=%d", file, line,
 156                      n, size);
 157 #endif
 158     if (!n)
 159         return xmalloc(size);
 160     NMEM_ENTER;
 161     p = n->blocks;
 162     if (!p || p->size - p->top < size)
 163     {
 164         p = get_block(size);
 165         p->next = n->blocks;
 166         n->blocks = p;
 167     }
 168     r = p->buf + p->top;
 169     /* align size */
 170     p->top += (size + (sizeof(long) - 1)) & ~(sizeof(long) - 1);
 171     n->total += size;
 172     NMEM_LEAVE;
 173     return r;
 174 }
 175
 176 int nmem_total(NMEM n)
 177 {
 178     return n->total;
 179 }
 180
 181 #if NMEM_DEBUG
 182 NMEM nmem_create_f(const char *file, int line)
 183 #else
 184 NMEM nmem_create(void)
 185 #endif
 186 {
 187     NMEM r;
 188
 189     NMEM_ENTER;
 190     nmem_active_no++;
 191     r = cfreelist;
 192     if (r)
 193         cfreelist = cfreelist->next;
 194     else
 195         r = (nmem_control *)xmalloc(sizeof(*r));
 196     NMEM_LEAVE;
 197
 198 #if NMEM_DEBUG
 199     logf (LOG_DEBUG, "%s:%d: nmem_create %d p=%p", file, line,
 200                      nmem_active_no-1, r);
 201 #endif
 202     r->blocks = 0;
 203     r->total = 0;
 204     r->next = 0;
 205     return r;
 206 }
 207
 208 #if NMEM_DEBUG
 209 void nmem_destroy_f(const char *file, int line, NMEM n)
 210 #else
 211 void nmem_destroy(NMEM n)
 212 #endif
 213 {
 214     if (!n)
 215         return;
 216     nmem_reset(n);
 217     NMEM_ENTER;
 218     nmem_active_no--;
 219     n->next = cfreelist;
 220     cfreelist = n;
 221     NMEM_LEAVE;
 222 #if NMEM_DEBUG
 223     logf (LOG_DEBUG, "%s:%d: nmem_destroy %d p=%p", file, line,
 224                      nmem_active_no, n);
 225 #endif
 226 }
 227
 228 void nmem_init (void)
 229 {
 230 #ifdef WINDOWS
 231     InitializeCriticalSection(&critical_section);
 232 #endif
 233     nmem_active_no = 0;
 234     freelist = NULL;
 235     cfreelist = NULL;
 236 }
 237
 238 void nmem_exit (void)
 239 {
 240     while (freelist)
 241     {
 242         struct nmem_block *fl = freelist;
 243         freelist = freelist->next;
 244         xfree (fl->buf);
 245         xfree (fl);
 246     }
 247     while (cfreelist)
 248     {
 249         struct nmem_control *cfl = cfreelist;
 250         cfreelist = cfreelist->next;
 251         xfree (cfl);
 252     }
 253 #ifdef WINDOWS
 254     DeleteCriticalSection(&critical_section);
 255 #endif
 256 }
 257