3 #define POOL_DEF_EXTENT (32 * 1024)
7 size_t size; /* extent size */
8 size_t quantum; /* allocation quantum */
9 struct pool_extent *live; /* current extent for
11 struct pool_extent *free; /* unfreed extent list */
13 /* function to call if
17 /* statistical data */
18 unsigned long e_created; /* extents created */
19 unsigned long e_freed; /* extents detroyed */
20 int64 n_allocated; /* calls to alloc */
21 int64 n_freed; /* calls to free */
22 int64 b_allocated; /* cum. bytes allocated */
23 int64 b_freed; /* cum. bytes freed */
28 void *start; /* starting address */
29 size_t free; /* free bytecount */
30 size_t bound; /* bytes bound by padding,
31 * overhead and freed */
32 struct pool_extent *next;
40 #define MINALIGN offsetof(struct align_test, bar)
42 /* Temporarily cast a void* var into a char* var when adding an offset (to
43 * keep some compilers from complaining about the pointer arithmetic). */
44 #define PTR_ADD(b,o) ( (void*) ((char*)(b) + (o)) )
47 pool_create(size_t size, size_t quantum,
48 void (*bomb)(char *), int flags)
50 struct alloc_pool *pool;
52 if (!(pool = (struct alloc_pool*) malloc(sizeof (struct alloc_pool))))
54 memset(pool, 0, sizeof (struct alloc_pool));
56 pool->size = size /* round extent size to min alignment reqs */
57 ? (size + MINALIGN - 1) & ~(MINALIGN - 1)
59 if (pool->flags & POOL_INTERN) {
60 pool->size -= sizeof (struct pool_extent);
63 pool->quantum = quantum ? quantum : MINALIGN;
71 pool_destroy(alloc_pool_t p)
73 struct alloc_pool *pool = (struct alloc_pool *) p;
74 struct pool_extent *cur, *next;
82 if (!(pool->flags & POOL_APPEND))
85 for (cur = pool->free; cur; cur = next) {
88 if (!(pool->flags & POOL_APPEND))
95 pool_alloc(alloc_pool_t p, size_t len, char *bomb)
97 struct alloc_pool *pool = (struct alloc_pool *) p;
103 else if (pool->quantum > 1 && len % pool->quantum)
104 len += pool->quantum - len % pool->quantum;
106 if (len > pool->size)
109 if (!pool->live || len > pool->live->free) {
117 pool->live->next = pool->free;
118 pool->free = pool->live;
125 if (pool->flags & POOL_APPEND)
126 asize += sizeof (struct pool_extent);
128 if (!(start = (void *) malloc(asize)))
131 if (pool->flags & POOL_CLEAR)
132 memset(start, 0, pool->size);
134 if (pool->flags & POOL_APPEND)
135 pool->live = PTR_ADD(start, free);
136 else if (!(pool->live = (struct pool_extent *) malloc(sizeof (struct pool_extent))))
138 if (pool->flags & POOL_QALIGN && pool->quantum > 1
139 && (sqew = (size_t)PTR_ADD(start, free) % pool->quantum)) {
143 pool->live->start = start;
144 pool->live->free = free;
145 pool->live->bound = bound;
146 pool->live->next = NULL;
152 pool->b_allocated += len;
154 pool->live->free -= len;
156 return PTR_ADD(pool->live->start, pool->live->free);
165 pool_free(alloc_pool_t p, size_t len, void *addr)
167 struct alloc_pool *pool = (struct alloc_pool *) p;
168 struct pool_extent *cur;
169 struct pool_extent *prev;
176 else if (pool->quantum > 1 && len % pool->quantum)
177 len += pool->quantum - len % pool->quantum;
179 if (!addr && pool->live) {
180 pool->live->next = pool->free;
181 pool->free = pool->live;
186 pool->b_freed += len;
189 if (cur && addr >= cur->start
190 && addr < PTR_ADD(cur->start, pool->size)) {
191 if (addr == PTR_ADD(cur->start, cur->free)) {
192 if (pool->flags & POOL_CLEAR)
193 memset(addr, 0, len);
194 pool->b_freed += len;
197 if (cur->free + cur->bound >= pool->size) {
200 cur->free = pool->size;
202 if (pool->flags & POOL_QALIGN && pool->quantum > 1
203 && (sqew = (size_t)PTR_ADD(cur->start, cur->free) % pool->quantum)) {
210 for (prev = NULL, cur = pool->free; cur; prev = cur, cur = cur->next) {
211 if (addr >= cur->start
212 && addr < PTR_ADD(cur->start, pool->size))
219 prev->next = cur->next;
220 cur->next = pool->free;
225 if (cur->free + cur->bound >= pool->size) {
226 pool->free = cur->next;
229 if (!(pool->flags & POOL_APPEND))
236 #define FDPRINT(label, value) \
237 snprintf(buf, sizeof buf, label, value), \
238 write(fd, buf, strlen(buf))
240 #define FDEXTSTAT(ext) \
241 snprintf(buf, sizeof buf, " %12ld %5ld\n", \
243 (long) ext->bound), \
244 write(fd, buf, strlen(buf))
247 pool_stats(alloc_pool_t p, int fd, int summarize)
249 struct alloc_pool *pool = (struct alloc_pool *) p;
250 struct pool_extent *cur;
256 FDPRINT(" Extent size: %12ld\n", (long) pool->size);
257 FDPRINT(" Alloc quantum: %12ld\n", (long) pool->quantum);
258 FDPRINT(" Extents created: %12ld\n", pool->e_created);
259 FDPRINT(" Extents freed: %12ld\n", pool->e_freed);
260 FDPRINT(" Alloc count: %12.0f\n", (double) pool->n_allocated);
261 FDPRINT(" Free Count: %12.0f\n", (double) pool->n_freed);
262 FDPRINT(" Alloc bytes: %12.0f\n", (double) pool->b_allocated);
263 FDPRINT(" Free bytes: %12.0f\n", (double) pool->b_freed);
268 if (!pool->live && !pool->free)
274 FDEXTSTAT(pool->live);
275 strlcpy(buf, " FREE BOUND\n", sizeof buf);
276 write(fd, buf, strlen(buf));
278 for (cur = pool->free; cur; cur = cur->next)