util/nmem.c

   1 /*
   2  * Copyright (c) 1995-2000, Index Data.
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: nmem.c,v $
   7  * Revision 1.24  2000-05-11 14:37:55  adam
   8  * Minor changes.
   9  *
  10  * Revision 1.23  2000/05/09 10:55:05  adam
  11  * Public nmem_print_list (for debugging).
  12  *
  13  * Revision 1.22  2000/05/03 22:00:00  adam
  14  * Reference counter (if multiple modules are init/freeing nmem).
  15  *
  16  * Revision 1.21  2000/02/29 13:44:55  adam
  17  * Check for config.h (currently not generated).
  18  *
  19  * Revision 1.20  2000/01/06 14:59:13  adam
  20  * Added oid_init/oid_exit. Changed oid_exit.
  21  *
  22  * Revision 1.19  1999/11/30 13:47:12  adam
  23  * Improved installation. Moved header files to include/yaz.
  24  *
  25  * Revision 1.18  1999/08/27 09:40:32  adam
  26  * Renamed logf function to yaz_log. Removed VC++ project files.
  27  *
  28  * Revision 1.17  1999/07/13 13:28:25  adam
  29  * Better debugging for NMEM routines.
  30  *
  31  * Revision 1.16  1999/03/31 11:18:25  adam
  32  * Implemented odr_strdup. Added Reference ID to backend server API.
  33  *
  34  * Revision 1.15  1999/02/11 09:10:26  adam
  35  * Function nmem_init only mandatory on Windows.
  36  *
  37  * Revision 1.14  1999/02/02 13:57:40  adam
  38  * Uses preprocessor define WIN32 instead of WINDOWS to build code
  39  * for Microsoft WIN32.
  40  *
  41  * Revision 1.13  1998/10/19 15:24:21  adam
  42  * New nmem utility, nmem_transfer, that transfer blocks from one
  43  * NMEM to another.
  44  *
  45  * Revision 1.12  1998/10/13 16:00:18  adam
  46  * Implemented nmem_critical_{enter,leave}.
  47  *
  48  * Revision 1.11  1998/08/21 14:13:36  adam
  49  * Added GNU Configure script to build Makefiles.
  50  *
  51  * Revision 1.10  1998/07/20 12:35:57  adam
  52  * Added more memory diagnostics (when NMEM_DEBUG is 1).
  53  *
  54  * Revision 1.9  1998/07/07 15:49:01  adam
  55  * Reduced chunk size.
  56  *
  57  * Revision 1.8  1998/07/03 14:21:27  adam
  58  * Added critical sections for pthreads-library. Thanks to Ian Ibbotson,
  59  * Fretwell Downing Informatics.
  60  *
  61  * Revision 1.7  1998/02/11 11:53:36  adam
  62  * Changed code so that it compiles as C++.
  63  *
  64  * Revision 1.6  1997/10/31 12:20:09  adam
  65  * Improved memory debugging for xmalloc/nmem.c. References to NMEM
  66  * instead of ODR in n ESPEC-1 handling in source d1_espec.c.
  67  * Bug fix: missing fclose in data1_read_espec1.
  68  *
  69  * Revision 1.5  1997/10/06 09:09:52  adam
  70  * Function mmem_exit releases memory used by the freelists.
  71  *
  72  * Revision 1.4  1997/09/29 07:12:50  adam
  73  * NMEM thread safe. NMEM must be initialized before use (sigh) -
  74  * routine nmem_init/nmem_exit implemented.
  75  *
  76  * Revision 1.3  1997/07/21 12:47:38  adam
  77  * Moved definition of nmem_control and nmem_block.
  78  *
  79  * Revision 1.2  1995/12/13 13:44:37  quinn
  80  * Modified Data1-system to use nmem
  81  *
  82  * Revision 1.1  1995/11/13  09:27:52  quinn
  83  * Fiddling with the variant stuff.
  84  *
  85  *
  86  */
  87
  88 /*
  89  * This is a simple and fairly wasteful little module for nibble memory
  90  * allocation. Evemtually we'll put in something better.
  91  */
  92 #if HAVE_CONFIG_H
  93 #include <config.h>
  94 #endif
  95
  96 #include <assert.h>
  97 #include <string.h>
  98 #include <yaz/xmalloc.h>
  99 #include <yaz/nmem.h>
 100 #include <yaz/log.h>
 101 #ifdef WIN32
 102 #include <windows.h>
 103 #elif _REENTRANT
 104
 105 #if HAVE_PTHREAD_H
 106 #include <pthread.h>
 107 #elif HAVE_THREAD_H
 108 #include <thread.h>
 109 #endif
 110
 111 #endif
 112
 113 #define NMEM_CHUNK (4*1024)
 114
 115 #ifdef WIN32
 116 static CRITICAL_SECTION critical_section;
 117 #define NMEM_ENTER EnterCriticalSection(&critical_section)
 118 #define NMEM_LEAVE LeaveCriticalSection(&critical_section)
 119 #elif _REENTRANT
 120 static pthread_mutex_t nmem_mutex = PTHREAD_MUTEX_INITIALIZER;
 121 #define NMEM_ENTER pthread_mutex_lock(&nmem_mutex);
 122 #define NMEM_LEAVE pthread_mutex_unlock(&nmem_mutex);
 123 #else
 124 #define NMEM_ENTER
 125 #define NMEM_LEAVE
 126 #endif
 127
 128 static nmem_block *freelist = NULL;        /* "global" freelists */
 129 static nmem_control *cfreelist = NULL;
 130 static int nmem_active_no = 0;
 131 static int nmem_init_flag = 0;
 132
 133 #if NMEM_DEBUG
 134 struct nmem_debug_info {
 135     void *p;
 136     char file[40];
 137     int line;
 138     struct nmem_debug_info *next;
 139 };
 140
 141 struct nmem_debug_info *nmem_debug_list = 0;
 142 #endif
 143
 144 static void free_block(nmem_block *p)
 145 {
 146     p->next = freelist;
 147     freelist = p;
 148 #if NMEM_DEBUG
 149     yaz_log (LOG_DEBUG, "nmem free_block p=%p", p);
 150 #endif
 151 }
 152
 153 #if NMEM_DEBUG
 154 void nmem_print_list (void)
 155 {
 156     struct nmem_debug_info *p;
 157
 158     yaz_log (LOG_DEBUG, "nmem print list");
 159     NMEM_ENTER;
 160     for (p = nmem_debug_list; p; p = p->next)
 161         yaz_log (LOG_DEBUG, " %s:%d p=%p size=%d", p->file, p->line, p->p,
 162                  nmem_total(p->p));
 163     NMEM_LEAVE;
 164 }
 165 #endif
 166 /*
 167  * acquire a block with a minimum of size free bytes.
 168  */
 169 static nmem_block *get_block(int size)
 170 {
 171     nmem_block *r, *l;
 172
 173 #if NMEM_DEBUG
 174     yaz_log (LOG_DEBUG, "nmem get_block size=%d", size);
 175 #endif
 176     for (r = freelist, l = 0; r; l = r, r = r->next)
 177         if (r->size >= size)
 178             break;
 179     if (r)
 180     {
 181 #if NMEM_DEBUG
 182         yaz_log (LOG_DEBUG, "nmem get_block found free block p=%p", r);
 183 #endif
 184         if (l)
 185             l->next = r->next;
 186         else
 187             freelist = r->next;
 188     }
 189     else
 190     {
 191         int get = NMEM_CHUNK;
 192
 193         if (get < size)
 194             get = size;
 195 #if NMEM_DEBUG
 196         yaz_log (LOG_DEBUG, "nmem get_block alloc new block size=%d", get);
 197 #endif
 198         r = (nmem_block *)xmalloc(sizeof(*r));
 199         r->buf = (char *)xmalloc(r->size = get);
 200     }
 201     r->top = 0;
 202     return r;
 203 }
 204
 205 void nmem_reset(NMEM n)
 206 {
 207     nmem_block *t;
 208
 209 #if NMEM_DEBUG
 210     yaz_log (LOG_DEBUG, "nmem_reset p=%p", n);
 211 #endif
 212     if (!n)
 213         return;
 214     NMEM_ENTER;
 215     while (n->blocks)
 216     {
 217         t = n->blocks;
 218         n->blocks = n->blocks->next;
 219         free_block(t);
 220     }
 221     n->total = 0;
 222     NMEM_LEAVE;
 223 }
 224
 225 #if NMEM_DEBUG
 226 void *nmem_malloc_f (const char *file, int line, NMEM n, int size)
 227 #else
 228 void *nmem_malloc(NMEM n, int size)
 229 #endif
 230 {
 231     struct nmem_block *p;
 232     char *r;
 233
 234 #if NMEM_DEBUG
 235     yaz_log (LOG_DEBUG, "%s:%d: nmem_malloc p=%p size=%d", file, line,
 236                      n, size);
 237 #endif
 238     if (!n)
 239     {
 240         abort ();
 241         return xmalloc(size);
 242     }
 243 #ifdef WIN32
 244     assert (nmem_init_flag);
 245 #endif
 246     NMEM_ENTER;
 247     p = n->blocks;
 248     if (!p || p->size - p->top < size)
 249     {
 250         p = get_block(size);
 251         p->next = n->blocks;
 252         n->blocks = p;
 253     }
 254     r = p->buf + p->top;
 255     /* align size */
 256     p->top += (size + (sizeof(long) - 1)) & ~(sizeof(long) - 1);
 257     n->total += size;
 258     NMEM_LEAVE;
 259     return r;
 260 }
 261
 262 int nmem_total(NMEM n)
 263 {
 264     return n->total;
 265 }
 266
 267 #if NMEM_DEBUG
 268 NMEM nmem_create_f(const char *file, int line)
 269 #else
 270 NMEM nmem_create(void)
 271 #endif
 272 {
 273     NMEM r;
 274 #if NMEM_DEBUG
 275     struct nmem_debug_info *debug_p;
 276 #endif
 277
 278     NMEM_ENTER;
 279     nmem_active_no++;
 280     r = cfreelist;
 281     if (r)
 282         cfreelist = cfreelist->next;
 283     else
 284         r = (nmem_control *)xmalloc(sizeof(*r));
 285     NMEM_LEAVE;
 286
 287 #if NMEM_DEBUG
 288     yaz_log (LOG_DEBUG, "%s:%d: nmem_create %d p=%p", file, line,
 289                      nmem_active_no, r);
 290 #endif
 291     r->blocks = 0;
 292     r->total = 0;
 293     r->next = 0;
 294
 295 #if NMEM_DEBUG
 296     for (debug_p = nmem_debug_list; debug_p; debug_p = debug_p->next)
 297         if (debug_p->p == r)
 298         {
 299             yaz_log (LOG_FATAL, "multi used block in nmem");
 300             abort ();
 301         }
 302     debug_p = xmalloc (sizeof(*debug_p));
 303     strncpy (debug_p->file, file, sizeof(debug_p->file)-1);
 304     debug_p->file[sizeof(debug_p->file)-1] = '\0';
 305     debug_p->line = line;
 306     debug_p->p = r;
 307     debug_p->next = nmem_debug_list;
 308     nmem_debug_list = debug_p;
 309
 310     nmem_print_list();
 311 #endif
 312     return r;
 313 }
 314
 315 #if NMEM_DEBUG
 316 void nmem_destroy_f(const char *file, int line, NMEM n)
 317 #else
 318 void nmem_destroy(NMEM n)
 319 #endif
 320 {
 321 #if NMEM_DEBUG
 322     struct nmem_debug_info **debug_p;
 323     int ok = 0;
 324 #endif
 325     if (!n)
 326         return;
 327
 328 #if NMEM_DEBUG
 329     yaz_log (LOG_DEBUG, "%s:%d: nmem_destroy %d p=%p", file, line,
 330                      nmem_active_no-1, n);
 331     NMEM_ENTER;
 332     for (debug_p = &nmem_debug_list; *debug_p; debug_p = &(*debug_p)->next)
 333         if ((*debug_p)->p == n)
 334         {
 335             struct nmem_debug_info *debug_save = *debug_p;
 336             *debug_p = (*debug_p)->next;
 337             xfree (debug_save);
 338             ok = 1;
 339             break;
 340         }
 341     NMEM_LEAVE;
 342     nmem_print_list();
 343     if (!ok)
 344     {
 345         yaz_log (LOG_WARN, "%s:%d destroying unallocated nmem block p=%p",
 346                  file, line, n);
 347         return;
 348     }
 349 #endif
 350     nmem_reset(n);
 351     NMEM_ENTER;
 352     nmem_active_no--;
 353     n->next = cfreelist;
 354     cfreelist = n;
 355     NMEM_LEAVE;
 356 }
 357
 358 void nmem_transfer (NMEM dst, NMEM src)
 359 {
 360     nmem_block *t;
 361     while ((t=src->blocks))
 362     {
 363         src->blocks = t->next;
 364         t->next = dst->blocks;
 365         dst->blocks = t;
 366     }
 367     dst->total += src->total;
 368     src->total = 0;
 369 }
 370
 371 void nmem_critical_enter (void)
 372 {
 373     NMEM_ENTER;
 374 }
 375
 376 void nmem_critical_leave (void)
 377 {
 378     NMEM_LEAVE;
 379 }
 380
 381 void nmem_init (void)
 382 {
 383     if (++nmem_init_flag == 1)
 384     {
 385 #ifdef WIN32
 386         InitializeCriticalSection(&critical_section);
 387 #endif
 388         nmem_active_no = 0;
 389         freelist = NULL;
 390         cfreelist = NULL;
 391     }
 392 }
 393
 394 void nmem_exit (void)
 395 {
 396     if (--nmem_init_flag == 0)
 397     {
 398         while (freelist)
 399         {
 400             struct nmem_block *fl = freelist;
 401             freelist = freelist->next;
 402             xfree (fl->buf);
 403             xfree (fl);
 404         }
 405         while (cfreelist)
 406         {
 407             struct nmem_control *cfl = cfreelist;
 408             cfreelist = cfreelist->next;
 409             xfree (cfl);
 410         }
 411 #ifdef WIN32
 412         DeleteCriticalSection(&critical_section);
 413 #endif
 414     }
 415 }
 416