No "copy" of source for thread/malloc libraries.
[yaz-moved-to-github.git] / util / nmem.c
1 /*
2  * Copyright (c) 1995-2001, Index Data.
3  * See the file LICENSE for details.
4  * Sebastian Hammer, Adam Dickmeiss
5  *
6  * $Id: nmem.c,v 1.34 2001-11-18 21:05:13 adam Exp $
7  */
8
9 /*
10  * This is a simple and fairly wasteful little module for nibble memory
11  * allocation. Evemtually we'll put in something better.
12  */
13 #if HAVE_CONFIG_H
14 #include <config.h>
15 #endif
16
17 #include <assert.h>
18 #include <string.h>
19 #include <yaz/xmalloc.h>
20 #include <yaz/nmem.h>
21 #include <yaz/log.h>
22 #include <yaz/oid.h>
23
24 #ifdef WIN32
25 #include <windows.h>
26 #endif
27
28 #if YAZ_POSIX_THREADS
29 #include <pthread.h>
30 #endif
31
32 #if YAZ_GNU_THREADS
33 #include <pth.h>
34 #endif
35
36 #define NMEM_CHUNK (4*1024)
37
38 #ifdef WIN32
39 static CRITICAL_SECTION critical_section;
40 #define NMEM_ENTER EnterCriticalSection(&critical_section)
41 #define NMEM_LEAVE LeaveCriticalSection(&critical_section)
42 struct nmem_mutex {
43     CRITICAL_SECTION m_handle;
44 };
45 #elif YAZ_POSIX_THREADS
46 static pthread_mutex_t nmem_mutex = PTHREAD_MUTEX_INITIALIZER;
47 #define NMEM_ENTER pthread_mutex_lock(&nmem_mutex);
48 #define NMEM_LEAVE pthread_mutex_unlock(&nmem_mutex);
49 struct nmem_mutex {
50     pthread_mutex_t m_handle;
51 };
52 #elif YAZ_GNU_THREADS
53 static pth_mutex_t nmem_mutex = PTH_MUTEX_INIT;
54 #define NMEM_ENTER pth_mutex_acquire(&nmem_mutex, 0, 0)
55 #define NMEM_LEAVE pth_mutex_release(&nmem_mutex)
56 struct nmem_mutex {
57     pth_mutex_t m_handle;
58 };
59 #else
60 #define NMEM_ENTER
61 #define NMEM_LEAVE
62 struct nmem_mutex {
63     int dummy;
64 };
65 #endif
66
67 YAZ_EXPORT void nmem_mutex_create(NMEM_MUTEX *p)
68 {
69     NMEM_ENTER;
70     if (!*p)
71     {
72         *p = (NMEM_MUTEX) malloc (sizeof(**p));
73 #ifdef WIN32
74         InitializeCriticalSection(&(*p)->m_handle);
75 #elif YAZ_POSIX_THREADS
76         pthread_mutex_init (&(*p)->m_handle, 0);
77 #elif YAZ_GNU_THREADS
78         pth_mutex_init (&(*p)->m_handle);
79 #endif
80     }
81     NMEM_LEAVE;
82 }
83
84 YAZ_EXPORT void nmem_mutex_enter(NMEM_MUTEX p)
85 {
86     if (p)
87     {
88 #ifdef WIN32
89         EnterCriticalSection(&p->m_handle);
90 #elif YAZ_POSIX_THREADS
91         pthread_mutex_lock(&p->m_handle);
92 #endif
93     }
94 }
95
96 YAZ_EXPORT void nmem_mutex_leave(NMEM_MUTEX p)
97 {
98     if (p)
99     {
100 #ifdef WIN32
101         LeaveCriticalSection(&p->m_handle);
102 #elif YAZ_POSIX_THREADS
103         pthread_mutex_unlock(&p->m_handle);
104 #endif
105     }
106 }
107
108 YAZ_EXPORT void nmem_mutex_destroy(NMEM_MUTEX *p)
109 {
110     NMEM_ENTER;
111     if (*p)
112     {
113 #ifdef WIN32
114         DeleteCriticalSection(&(*p)->m_handle);
115 #endif
116         free (*p);
117         *p = 0;
118     }
119     NMEM_LEAVE;
120 }
121
122 static nmem_block *freelist = NULL;        /* "global" freelists */
123 static nmem_control *cfreelist = NULL;
124 static int nmem_active_no = 0;
125 static int nmem_init_flag = 0;
126
127 #if NMEM_DEBUG
128 struct nmem_debug_info {
129     void *p;
130     char file[40];
131     int line;
132     struct nmem_debug_info *next;
133 };
134   
135 struct nmem_debug_info *nmem_debug_list = 0;  
136 #endif
137
138 static void free_block(nmem_block *p)
139 {  
140     p->next = freelist;
141     freelist = p;
142 #if NMEM_DEBUG
143     yaz_log (LOG_DEBUG, "nmem free_block p=%p", p);
144 #endif
145 }
146
147 #if NMEM_DEBUG
148 void nmem_print_list (void)
149 {
150     struct nmem_debug_info *p;
151
152     yaz_log (LOG_DEBUG, "nmem print list");
153     NMEM_ENTER;
154     for (p = nmem_debug_list; p; p = p->next)
155         yaz_log (LOG_DEBUG, " %s:%d p=%p size=%d", p->file, p->line, p->p,
156                  nmem_total(p->p));
157     NMEM_LEAVE;
158 }
159 #endif
160 /*
161  * acquire a block with a minimum of size free bytes.
162  */
163 static nmem_block *get_block(int size)
164 {
165     nmem_block *r, *l;
166
167 #if NMEM_DEBUG
168     yaz_log (LOG_DEBUG, "nmem get_block size=%d", size);
169 #endif
170     for (r = freelist, l = 0; r; l = r, r = r->next)
171         if (r->size >= size)
172             break;
173     if (r)
174     {
175 #if NMEM_DEBUG
176         yaz_log (LOG_DEBUG, "nmem get_block found free block p=%p", r);
177 #endif
178         if (l)
179             l->next = r->next;
180         else
181             freelist = r->next;
182     }
183     else
184     {
185         int get = NMEM_CHUNK;
186
187         if (get < size)
188             get = size;
189 #if NMEM_DEBUG
190         yaz_log (LOG_DEBUG, "nmem get_block alloc new block size=%d", get);
191 #endif
192         r = (nmem_block *)xmalloc(sizeof(*r));
193         r->buf = (char *)xmalloc(r->size = get);
194     }
195     r->top = 0;
196     return r;
197 }
198
199 void nmem_reset(NMEM n)
200 {
201     nmem_block *t;
202
203 #if NMEM_DEBUG
204     yaz_log (LOG_DEBUG, "nmem_reset p=%p", n);
205 #endif
206     if (!n)
207         return;
208     NMEM_ENTER;
209     while (n->blocks)
210     {
211         t = n->blocks;
212         n->blocks = n->blocks->next;
213         free_block(t);
214     }
215     n->total = 0;
216     NMEM_LEAVE;
217 }
218
219 #if NMEM_DEBUG
220 void *nmem_malloc_f (const char *file, int line, NMEM n, int size)
221 #else
222 void *nmem_malloc(NMEM n, int size)
223 #endif
224 {
225     struct nmem_block *p;
226     char *r;
227
228 #if NMEM_DEBUG
229     yaz_log (LOG_DEBUG, "%s:%d: nmem_malloc p=%p size=%d", file, line,
230                      n, size);
231 #endif
232     if (!n)
233     {
234         abort ();
235         return xmalloc(size);
236     }
237 #ifdef WIN32
238     assert (nmem_init_flag);
239 #endif
240     NMEM_ENTER;
241     p = n->blocks;
242     if (!p || p->size - p->top < size)
243     {
244         p = get_block(size);
245         p->next = n->blocks;
246         n->blocks = p;
247     }
248     r = p->buf + p->top;
249     /* align size */
250     p->top += (size + (sizeof(long) - 1)) & ~(sizeof(long) - 1);
251     n->total += size;
252     NMEM_LEAVE;
253     return r;
254 }
255
256 int nmem_total(NMEM n)
257 {
258     return n->total;
259 }
260
261 #if NMEM_DEBUG
262 NMEM nmem_create_f(const char *file, int line)
263 #else
264 NMEM nmem_create(void)
265 #endif
266 {
267     NMEM r;
268 #if NMEM_DEBUG
269     struct nmem_debug_info *debug_p;
270 #endif
271     
272     NMEM_ENTER;
273     nmem_active_no++;
274     r = cfreelist;
275     if (r)
276         cfreelist = cfreelist->next;
277     else
278         r = (nmem_control *)xmalloc(sizeof(*r));
279     NMEM_LEAVE;
280
281 #if NMEM_DEBUG
282     yaz_log (LOG_DEBUG, "%s:%d: nmem_create %d p=%p", file, line,
283                      nmem_active_no, r);
284 #endif
285     r->blocks = 0;
286     r->total = 0;
287     r->next = 0;
288
289 #if NMEM_DEBUG
290     for (debug_p = nmem_debug_list; debug_p; debug_p = debug_p->next)
291         if (debug_p->p == r)
292         {
293             yaz_log (LOG_FATAL, "multi used block in nmem");
294             abort ();
295         }
296     debug_p = xmalloc (sizeof(*debug_p));
297     strncpy (debug_p->file, file, sizeof(debug_p->file)-1);
298     debug_p->file[sizeof(debug_p->file)-1] = '\0';
299     debug_p->line = line;
300     debug_p->p = r;
301     debug_p->next = nmem_debug_list;
302     nmem_debug_list = debug_p;
303
304     nmem_print_list();
305 #endif
306     return r;
307 }
308
309 #if NMEM_DEBUG
310 void nmem_destroy_f(const char *file, int line, NMEM n)
311 #else
312 void nmem_destroy(NMEM n)
313 #endif
314 {
315 #if NMEM_DEBUG
316     struct nmem_debug_info **debug_p;
317     int ok = 0;
318 #endif
319     if (!n)
320         return;
321     
322 #if NMEM_DEBUG
323     yaz_log (LOG_DEBUG, "%s:%d: nmem_destroy %d p=%p", file, line,
324                      nmem_active_no-1, n);
325     NMEM_ENTER;
326     for (debug_p = &nmem_debug_list; *debug_p; debug_p = &(*debug_p)->next)
327         if ((*debug_p)->p == n)
328         {
329             struct nmem_debug_info *debug_save = *debug_p;
330             *debug_p = (*debug_p)->next;
331             xfree (debug_save);
332             ok = 1;
333             break;
334         }
335     NMEM_LEAVE;
336     nmem_print_list();
337     if (!ok)
338     {
339         yaz_log (LOG_WARN, "%s:%d destroying unallocated nmem block p=%p",
340                  file, line, n);
341         return;
342     }
343 #endif
344     nmem_reset(n);
345     NMEM_ENTER;
346     nmem_active_no--;
347     n->next = cfreelist;
348     cfreelist = n;
349     NMEM_LEAVE;
350 }
351
352 void nmem_transfer (NMEM dst, NMEM src)
353 {
354     nmem_block *t;
355     while ((t=src->blocks))
356     {
357         src->blocks = t->next;
358         t->next = dst->blocks;
359         dst->blocks = t;
360     }
361     dst->total += src->total;
362     src->total = 0;
363 }
364
365 void nmem_critical_enter (void)
366 {
367     NMEM_ENTER;
368 }
369
370 void nmem_critical_leave (void)
371 {
372     NMEM_LEAVE;
373 }
374
375 void nmem_init (void)
376 {
377     if (++nmem_init_flag == 1)
378     {
379 #ifdef WIN32
380         InitializeCriticalSection(&critical_section);
381 #elif YAZ_GNU_THREADS
382         yaz_log (LOG_LOG, "pth_init");
383         pth_init ();
384 #endif
385         nmem_active_no = 0;
386         freelist = NULL;
387         cfreelist = NULL;
388     }
389 }
390
391 void nmem_exit (void)
392 {
393     if (--nmem_init_flag == 0)
394     {
395         oid_exit();
396         while (freelist)
397         {
398             struct nmem_block *fl = freelist;
399             freelist = freelist->next;
400             xfree (fl->buf);
401             xfree (fl);
402         }
403         while (cfreelist)
404         {
405             struct nmem_control *cfl = cfreelist;
406             cfreelist = cfreelist->next;
407             xfree (cfl);
408         }
409 #ifdef WIN32
410         DeleteCriticalSection(&critical_section);
411 #endif
412     }
413 }
414
415
416 #ifdef WIN32
417 BOOL WINAPI DllMain (HINSTANCE hinstDLL,
418                      DWORD reason,
419                      LPVOID reserved)
420 {
421     switch (reason)
422     {
423     case DLL_PROCESS_ATTACH:
424         nmem_init ();
425         break;
426     case DLL_PROCESS_DETACH:
427         nmem_exit ();
428     }
429     return TRUE;
430 }
431 #endif