Added member request_format and output_format for backend fetch method.
[yaz-moved-to-github.git] / 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