25
|
1 /*
|
|
2 * This program is free software; you can redistribute it and/or modify
|
|
3 * it under the terms of the GNU General Public License as published by
|
|
4 * the Free Software Foundation; either version 2 of the License, or
|
|
5 * (at your option) any later version.
|
|
6 *
|
|
7 * This program is distributed in the hope that it will be useful,
|
|
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
10 * GNU General Public License for more details.
|
|
11 *
|
|
12 * You should have received a copy of the GNU General Public License
|
|
13 * along with this program; if not, write to the Free Software
|
|
14 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
15 *
|
|
16 * Jabber
|
|
17 * Copyright (C) 1998-1999 The Jabber Team http://jabber.org/
|
|
18 *
|
|
19 * 2/27/00:3am, random plans by jer
|
|
20 *
|
|
21 * ok based on gprof, we really need some innovation here... my thoughs are this:
|
|
22 *
|
|
23 * most things are strings, so have a string-based true-blue garbage collector
|
|
24 * one big global hash containing all the strings created by any pstrdup, returning const char *
|
|
25 * a refcount on each string block
|
|
26 * when a pool is freed, it moves down the refcount
|
|
27 * garbage collector collects pools on the free stack, and runs through the hash for unused strings
|
|
28 * j_strcmp can check for == (if they are both from a pstrdup)
|
|
29 *
|
|
30 * let's see... this would change:
|
|
31 * pstrdup: do a hash lookup, success=return, fail=pmalloc & hash put
|
|
32 * pool_free:
|
|
33 *
|
|
34 *
|
|
35 *
|
|
36 *
|
|
37 *
|
|
38 */
|
|
39
|
|
40 #include "libxode.h"
|
|
41
|
|
42 #ifdef POOL_DEBUG
|
|
43 int pool__total = 0;
|
|
44 int pool__ltotal = 0;
|
|
45 HASHTABLE pool__disturbed = NULL;
|
|
46 void *_pool__malloc(size_t size)
|
|
47 {
|
|
48 pool__total++;
|
|
49 return malloc(size);
|
|
50 }
|
|
51 void _pool__free(void *block)
|
|
52 {
|
|
53 pool__total--;
|
|
54 free(block);
|
|
55 }
|
|
56 #else
|
|
57 #define _pool__malloc malloc
|
|
58 #define _pool__free free
|
|
59 #endif
|
|
60
|
|
61
|
|
62 /* make an empty pool */
|
|
63 pool _pool_new(char *zone)
|
|
64 {
|
|
65 pool p;
|
|
66 while((p = _pool__malloc(sizeof(_pool))) == NULL) sleep(1);
|
|
67 p->cleanup = NULL;
|
|
68 p->heap = NULL;
|
|
69 p->size = 0;
|
|
70
|
|
71 #ifdef POOL_DEBUG
|
|
72 p->lsize = -1;
|
|
73 p->zone[0] = '\0';
|
|
74 strcat(p->zone,zone);
|
|
75 sprintf(p->name,"%X",p);
|
|
76
|
|
77 if(pool__disturbed == NULL)
|
|
78 pool__disturbed = ghash_create(POOL_DEBUG,(KEYHASHFUNC)str_hash_code,(KEYCOMPAREFUNC)j_strcmp);
|
|
79 ghash_put(pool__disturbed,p->name,p);
|
|
80 #endif
|
|
81
|
|
82 return p;
|
|
83 }
|
|
84
|
|
85 /* free a heap */
|
|
86 void _pool_heap_free(void *arg)
|
|
87 {
|
|
88 struct pheap *h = (struct pheap *)arg;
|
|
89
|
|
90 _pool__free(h->block);
|
|
91 _pool__free(h);
|
|
92 }
|
|
93
|
|
94 /* mem should always be freed last */
|
|
95 void _pool_cleanup_append(pool p, struct pfree *pf)
|
|
96 {
|
|
97 struct pfree *cur;
|
|
98
|
|
99 if(p->cleanup == NULL)
|
|
100 {
|
|
101 p->cleanup = pf;
|
|
102 return;
|
|
103 }
|
|
104
|
|
105 /* fast forward to end of list */
|
|
106 for(cur = p->cleanup; cur->next != NULL; cur = cur->next);
|
|
107
|
|
108 cur->next = pf;
|
|
109 }
|
|
110
|
|
111 /* create a cleanup tracker */
|
|
112 struct pfree *_pool_free(pool p, pool_cleaner f, void *arg)
|
|
113 {
|
|
114 struct pfree *ret;
|
|
115
|
|
116 /* make the storage for the tracker */
|
|
117 while((ret = _pool__malloc(sizeof(struct pfree))) == NULL) sleep(1);
|
|
118 ret->f = f;
|
|
119 ret->arg = arg;
|
|
120 ret->next = NULL;
|
|
121
|
|
122 return ret;
|
|
123 }
|
|
124
|
|
125 /* create a heap and make sure it get's cleaned up */
|
|
126 struct pheap *_pool_heap(pool p, int size)
|
|
127 {
|
|
128 struct pheap *ret;
|
|
129 struct pfree *clean;
|
|
130
|
|
131 /* make the return heap */
|
|
132 while((ret = _pool__malloc(sizeof(struct pheap))) == NULL) sleep(1);
|
|
133 while((ret->block = _pool__malloc(size)) == NULL) sleep(1);
|
|
134 ret->size = size;
|
|
135 p->size += size;
|
|
136 ret->used = 0;
|
|
137
|
|
138 /* append to the cleanup list */
|
|
139 clean = _pool_free(p, _pool_heap_free, (void *)ret);
|
|
140 clean->heap = ret; /* for future use in finding used mem for pstrdup */
|
|
141 _pool_cleanup_append(p, clean);
|
|
142
|
|
143 return ret;
|
|
144 }
|
|
145
|
|
146 pool _pool_new_heap(int size, char *zone)
|
|
147 {
|
|
148 pool p;
|
|
149 p = _pool_new(zone);
|
|
150 p->heap = _pool_heap(p,size);
|
|
151 return p;
|
|
152 }
|
|
153
|
|
154 void *pmalloc(pool p, int size)
|
|
155 {
|
|
156 void *block;
|
|
157
|
|
158 if(p == NULL)
|
|
159 {
|
|
160 fprintf(stderr,"Memory Leak! [pmalloc received NULL pool, unable to track allocation, exiting]\n");
|
|
161 abort();
|
|
162 }
|
|
163
|
|
164 /* if there is no heap for this pool or it's a big request, just raw, I like how we clean this :) */
|
|
165 if(p->heap == NULL || size > (p->heap->size / 2))
|
|
166 {
|
|
167 while((block = _pool__malloc(size)) == NULL) sleep(1);
|
|
168 p->size += size;
|
|
169 _pool_cleanup_append(p, _pool_free(p, _pool__free, block));
|
|
170 return block;
|
|
171 }
|
|
172
|
|
173 /* we have to preserve boundaries, long story :) */
|
|
174 if(size >= 4)
|
|
175 while(p->heap->used&7) p->heap->used++;
|
|
176
|
|
177 /* if we don't fit in the old heap, replace it */
|
|
178 if(size > (p->heap->size - p->heap->used))
|
|
179 p->heap = _pool_heap(p, p->heap->size);
|
|
180
|
|
181 /* the current heap has room */
|
|
182 block = (char *)p->heap->block + p->heap->used;
|
|
183 p->heap->used += size;
|
|
184 return block;
|
|
185 }
|
|
186
|
|
187 void *pmalloc_x(pool p, int size, char c)
|
|
188 {
|
|
189 void* result = pmalloc(p, size);
|
|
190 if (result != NULL)
|
|
191 memset(result, c, size);
|
|
192 return result;
|
|
193 }
|
|
194
|
|
195 /* easy safety utility (for creating blank mem for structs, etc) */
|
|
196 void *pmalloco(pool p, int size)
|
|
197 {
|
|
198 void *block = pmalloc(p, size);
|
|
199 memset(block, 0, size);
|
|
200 return block;
|
|
201 }
|
|
202
|
|
203 /* XXX efficient: move this to const char * and then loop throug the existing heaps to see if src is within a block in this pool */
|
|
204 char *pstrdup(pool p, const char *src)
|
|
205 {
|
|
206 char *ret;
|
|
207
|
|
208 if(src == NULL)
|
|
209 return NULL;
|
|
210
|
|
211 ret = pmalloc(p,strlen(src) + 1);
|
|
212 strcpy(ret,src);
|
|
213
|
|
214 return ret;
|
|
215 }
|
|
216
|
|
217 /* when move above, this one would actually return a new block */
|
|
218 char *pstrdupx(pool p, const char *src)
|
|
219 {
|
|
220 return pstrdup(p, src);
|
|
221 }
|
|
222
|
|
223 int pool_size(pool p)
|
|
224 {
|
|
225 if(p == NULL) return 0;
|
|
226
|
|
227 return p->size;
|
|
228 }
|
|
229
|
|
230 void pool_free(pool p)
|
|
231 {
|
|
232 struct pfree *cur, *stub;
|
|
233
|
|
234 if(p == NULL) return;
|
|
235
|
|
236 cur = p->cleanup;
|
|
237 while(cur != NULL)
|
|
238 {
|
|
239 (*cur->f)(cur->arg);
|
|
240 stub = cur->next;
|
|
241 _pool__free(cur);
|
|
242 cur = stub;
|
|
243 }
|
|
244
|
|
245 #ifdef POOL_DEBUG
|
|
246 ghash_remove(pool__disturbed,p->name);
|
|
247 #endif
|
|
248
|
|
249 _pool__free(p);
|
|
250
|
|
251 }
|
|
252
|
|
253 /* public cleanup utils, insert in a way that they are run FIFO, before mem frees */
|
|
254 void pool_cleanup(pool p, pool_cleaner f, void *arg)
|
|
255 {
|
|
256 struct pfree *clean;
|
|
257
|
|
258 clean = _pool_free(p, f, arg);
|
|
259 clean->next = p->cleanup;
|
|
260 p->cleanup = clean;
|
|
261 }
|
|
262
|
|
263 #ifdef POOL_DEBUG
|
|
264 void debug_log(char *zone, const char *msgfmt, ...);
|
|
265 int _pool_stat(void *arg, const void *key, void *data)
|
|
266 {
|
|
267 pool p = (pool)data;
|
|
268
|
|
269 if(p->lsize == -1)
|
|
270 debug_log("leak","%s: %X is a new pool",p->zone,p->name);
|
|
271 else if(p->size > p->lsize)
|
|
272 debug_log("leak","%s: %X grew %d",p->zone,p->name, p->size - p->lsize);
|
|
273 else if((int)arg)
|
|
274 debug_log("leak","%s: %X exists %d",p->zone,p->name, p->size);
|
|
275 p->lsize = p->size;
|
|
276 return 1;
|
|
277 }
|
|
278
|
|
279 void pool_stat(int full)
|
|
280 {
|
|
281 ghash_walk(pool__disturbed,_pool_stat,(void *)full);
|
|
282 if(pool__total != pool__ltotal)
|
|
283 debug_log("leak","%d\ttotal missed mallocs",pool__total);
|
|
284 pool__ltotal = pool__total;
|
|
285 return;
|
|
286 }
|
|
287 #else
|
|
288 void pool_stat(int full)
|
|
289 {
|
|
290 return;
|
|
291 }
|
|
292 #endif
|