7 Designed and implemented in April of 1972 by John Walker, based on the
8 Case Algol OPRO$ algorithm implemented in 1966.
10 Reimplemented in 1975 by John Walker for the Interdata 70.
11 Reimplemented in 1977 by John Walker for the Marinchip 9900.
12 Reimplemented in 1982 by Duff Kurland for the Intel 8080.
14 Portable C version implemented in September of 1990 by an older, wiser
15 instance of the original implementor.
17 Souped up and/or weighed down slightly shortly thereafter by Greg
20 AMIX edition, including the new compaction call-back option, prepared
21 by John Walker in July of 1992.
23 Bug in built-in test program fixed, ANSI compiler warnings eradicated,
24 buffer pool validator implemented, and guaranteed repeatable test
25 added by John Walker in October of 1995.
27 This program is in the public domain.
29 1. This is the book of the generations of Adam. In the day that God
30 created man, in the likeness of God made he him;
31 2. Male and female created he them; and blessed them, and called
32 their name Adam, in the day when they were created.
33 3. And Adam lived an hundred and thirty years, and begat a son in
34 his own likeness, and after his image; and called his name Seth:
35 4. And the days of Adam after he had begotten Seth were eight
36 hundred years: and he begat sons and daughters:
37 5. And all the days that Adam lived were nine hundred and thirty
39 6. And Seth lived an hundred and five years, and begat Enos:
40 7. And Seth lived after he begat Enos eight hundred and seven years,
41 and begat sons and daughters:
42 8. And all the days of Seth were nine hundred and twelve years: and
44 9. And Enos lived ninety years, and begat Cainan:
45 10. And Enos lived after he begat Cainan eight hundred and fifteen
46 years, and begat sons and daughters:
47 11. And all the days of Enos were nine hundred and five years: and
49 12. And Cainan lived seventy years and begat Mahalaleel:
50 13. And Cainan lived after he begat Mahalaleel eight hundred and
51 forty years, and begat sons and daughters:
52 14. And all the days of Cainan were nine hundred and ten years: and
54 15. And Mahalaleel lived sixty and five years, and begat Jared:
55 16. And Mahalaleel lived after he begat Jared eight hundred and
56 thirty years, and begat sons and daughters:
57 17. And all the days of Mahalaleel were eight hundred ninety and
58 five years: and he died.
59 18. And Jared lived an hundred sixty and two years, and he begat
61 19. And Jared lived after he begat Enoch eight hundred years, and
62 begat sons and daughters:
63 20. And all the days of Jared were nine hundred sixty and two years:
65 21. And Enoch lived sixty and five years, and begat Methuselah:
66 22. And Enoch walked with God after he begat Methuselah three
67 hundred years, and begat sons and daughters:
68 23. And all the days of Enoch were three hundred sixty and five
70 24. And Enoch walked with God: and he was not; for God took him.
71 25. And Methuselah lived an hundred eighty and seven years, and
73 26. And Methuselah lived after he begat Lamech seven hundred eighty
74 and two years, and begat sons and daughters:
75 27. And all the days of Methuselah were nine hundred sixty and nine
77 28. And Lamech lived an hundred eighty and two years, and begat a
79 29. And he called his name Noah, saying, This same shall comfort us
80 concerning our work and toil of our hands, because of the ground
81 which the LORD hath cursed.
82 30. And Lamech lived after he begat Noah five hundred ninety and
83 five years, and begat sons and daughters:
84 31. And all the days of Lamech were seven hundred seventy and seven
86 32. And Noah was five hundred years old: and Noah begat Shem, Ham,
89 And buffers begat buffers, and links begat links, and buffer pools
90 begat links to chains of buffer pools containing buffers, and lo the
91 buffers and links and pools of buffers and pools of links to chains of
92 pools of buffers were fruitful and they multiplied and the Operating
93 System looked down upon them and said that it was Good.
99 BGET is a comprehensive memory allocation package which is easily
100 configured to the needs of an application. BGET is efficient in
101 both the time needed to allocate and release buffers and in the
102 memory overhead required for buffer pool management. It
103 automatically consolidates contiguous space to minimise
104 fragmentation. BGET is configured by compile-time definitions,
105 Major options include:
107 * A built-in test program to exercise BGET and
108 demonstrate how the various functions are used.
110 * Allocation by either the "first fit" or "best fit"
113 * Wiping buffers at release time to catch code which
114 references previously released storage.
116 * Built-in routines to dump individual buffers or the
119 * Retrieval of allocation and pool size statistics.
121 * Quantisation of buffer sizes to a power of two to
122 satisfy hardware alignment constraints.
124 * Automatic pool compaction, growth, and shrinkage by
125 means of call-backs to user defined functions.
127 Applications of BGET can range from storage management in
128 ROM-based embedded programs to providing the framework upon which
129 a multitasking system incorporating garbage collection is
130 constructed. BGET incorporates extensive internal consistency
131 checking using the <assert.h> mechanism; all these checks can be
132 turned off by compiling with NDEBUG defined, yielding a version of
133 BGET with minimal size and maximum speed.
135 The basic algorithm underlying BGET has withstood the test of
136 time; more than 25 years have passed since the first
137 implementation of this code. And yet, it is substantially more
138 efficient than the native allocation schemes of many operating
139 systems: the Macintosh and Microsoft Windows to name two, on which
140 programs have obtained substantial speed-ups by layering BGET as
141 an application level memory manager atop the underlying system's.
143 BGET has been implemented on the largest mainframes and the lowest
144 of microprocessors. It has served as the core for multitasking
145 operating systems, multi-thread applications, embedded software in
146 data network switching processors, and a host of C programs. And
147 while it has accreted flexibility and additional options over the
148 years, it remains fast, memory efficient, portable, and easy to
149 integrate into your program.
152 BGET IMPLEMENTATION ASSUMPTIONS
153 ===============================
155 BGET is written in as portable a dialect of C as possible. The
156 only fundamental assumption about the underlying hardware
157 architecture is that memory is allocated is a linear array which
158 can be addressed as a vector of C "char" objects. On segmented
159 address space architectures, this generally means that BGET should
160 be used to allocate storage within a single segment (although some
161 compilers simulate linear address spaces on segmented
162 architectures). On segmented architectures, then, BGET buffer
163 pools may not be larger than a segment, but since BGET allows any
164 number of separate buffer pools, there is no limit on the total
165 storage which can be managed, only on the largest individual
166 object which can be allocated. Machines with a linear address
167 architecture, such as the VAX, 680x0, Sparc, MIPS, or the Intel
168 80386 and above in native mode, may use BGET without restriction.
171 GETTING STARTED WITH BGET
172 =========================
174 Although BGET can be configured in a multitude of fashions, there
175 are three basic ways of working with BGET. The functions
176 mentioned below are documented in the following section. Please
177 excuse the forward references which are made in the interest of
178 providing a roadmap to guide you to the BGET functions you're
181 Embedded Applications
182 ---------------------
184 Embedded applications typically have a fixed area of memory
185 dedicated to buffer allocation (often in a separate RAM address
186 space distinct from the ROM that contains the executable code).
187 To use BGET in such an environment, simply call bpool() with the
188 start address and length of the buffer pool area in RAM, then
189 allocate buffers with bget() and release them with brel().
190 Embedded applications with very limited RAM but abundant CPU speed
191 may benefit by configuring BGET for BestFit allocation (which is
192 usually not worth it in other environments).
197 If the C library malloc() function is too slow, not present in
198 your development environment (for example, an a native Windows or
199 Macintosh program), or otherwise unsuitable, you can replace it
200 with BGET. Initially define a buffer pool of an appropriate size
201 with bpool()--usually obtained by making a call to the operating
202 system's low-level memory allocator. Then allocate buffers with
203 bget(), bgetz(), and bgetr() (the last two permit the allocation
204 of buffers initialised to zero and [inefficient] re-allocation of
205 existing buffers for compatibility with C library functions).
206 Release buffers by calling brel(). If a buffer allocation request
207 fails, obtain more storage from the underlying operating system,
208 add it to the buffer pool by another call to bpool(), and continue
211 Automatic Storage Management
212 ----------------------------
214 You can use BGET as your application's native memory manager and
215 implement automatic storage pool expansion, contraction, and
216 optionally application-specific memory compaction by compiling
217 BGET with the BECtl variable defined, then calling bectl() and
218 supplying functions for storage compaction, acquisition, and
219 release, as well as a standard pool expansion increment. All of
220 these functions are optional (although it doesn't make much sense
221 to provide a release function without an acquisition function,
222 does it?). Once the call-back functions have been defined with
223 bectl(), you simply use bget() and brel() to allocate and release
224 storage as before. You can supply an initial buffer pool with
225 bpool() or rely on automatic allocation to acquire the entire
226 pool. When a call on bget() cannot be satisfied, BGET first
227 checks if a compaction function has been supplied. If so, it is
228 called (with the space required to satisfy the allocation request
229 and a sequence number to allow the compaction routine to be called
230 successively without looping). If the compaction function is able
231 to free any storage (it needn't know whether the storage it freed
232 was adequate) it should return a nonzero value, whereupon BGET
233 will retry the allocation request and, if it fails again, call the
234 compaction function again with the next-higher sequence number.
236 If the compaction function returns zero, indicating failure to
237 free space, or no compaction function is defined, BGET next tests
238 whether a non-NULL allocation function was supplied to bectl().
239 If so, that function is called with an argument indicating how
240 many bytes of additional space are required. This will be the
241 standard pool expansion increment supplied in the call to bectl()
242 unless the original bget() call requested a buffer larger than
243 this; buffers larger than the standard pool block can be managed
244 "off the books" by BGET in this mode. If the allocation function
245 succeeds in obtaining the storage, it returns a pointer to the new
246 block and BGET expands the buffer pool; if it fails, the
247 allocation request fails and returns NULL to the caller. If a
248 non-NULL release function is supplied, expansion blocks which
249 become totally empty are released to the global free pool by
250 passing their addresses to the release function.
252 Equipped with appropriate allocation, release, and compaction
253 functions, BGET can be used as part of very sophisticated memory
254 management strategies, including garbage collection. (Note,
255 however, that BGET is *not* a garbage collector by itself, and
256 that developing such a system requires much additional logic and
257 careful design of the application's memory allocation strategy.)
260 BGET FUNCTION DESCRIPTIONS
261 ==========================
263 Functions implemented in this file (some are enabled by certain of
264 the optional settings below):
266 void bpool(void *buffer, bufsize len);
268 Create a buffer pool of <len> bytes, using the storage starting at
269 <buffer>. You can call bpool() subsequently to contribute
270 additional storage to the overall buffer pool.
272 void *bget(bufsize size);
274 Allocate a buffer of <size> bytes. The address of the buffer is
275 returned, or NULL if insufficient memory was available to allocate
278 void *bgetz(bufsize size);
280 Allocate a buffer of <size> bytes and clear it to all zeroes. The
281 address of the buffer is returned, or NULL if insufficient memory
282 was available to allocate the buffer.
284 void *bgetr(void *buffer, bufsize newsize);
286 Reallocate a buffer previously allocated by bget(), changing its
287 size to <newsize> and preserving all existing data. NULL is
288 returned if insufficient memory is available to reallocate the
289 buffer, in which case the original buffer remains intact.
291 void brel(void *buf);
293 Return the buffer <buf>, previously allocated by bget(), to the
296 void bectl(int (*compact)(bufsize sizereq, int sequence),
297 void *(*acquire)(bufsize size),
298 void (*release)(void *buf),
301 Expansion control: specify functions through which the package may
302 compact storage (or take other appropriate action) when an
303 allocation request fails, and optionally automatically acquire
304 storage for expansion blocks when necessary, and release such
305 blocks when they become empty. If <compact> is non-NULL, whenever
306 a buffer allocation request fails, the <compact> function will be
307 called with arguments specifying the number of bytes (total buffer
308 size, including header overhead) required to satisfy the
309 allocation request, and a sequence number indicating the number of
310 consecutive calls on <compact> attempting to satisfy this
311 allocation request. The sequence number is 1 for the first call
312 on <compact> for a given allocation request, and increments on
313 subsequent calls, permitting the <compact> function to take
314 increasingly dire measures in an attempt to free up storage. If
315 the <compact> function returns a nonzero value, the allocation
316 attempt is re-tried. If <compact> returns 0 (as it must if it
317 isn't able to release any space or add storage to the buffer
318 pool), the allocation request fails, which can trigger automatic
319 pool expansion if the <acquire> argument is non-NULL. At the time
320 the <compact> function is called, the state of the buffer
321 allocator is identical to that at the moment the allocation
322 request was made; consequently, the <compact> function may call
323 brel(), bpool(), bstats(), and/or directly manipulate the buffer
324 pool in any manner which would be valid were the application in
325 control. This does not, however, relieve the <compact> function
326 of the need to ensure that whatever actions it takes do not change
327 things underneath the application that made the allocation
328 request. For example, a <compact> function that released a buffer
329 in the process of being reallocated with bgetr() would lead to
330 disaster. Implementing a safe and effective <compact> mechanism
331 requires careful design of an application's memory architecture,
332 and cannot generally be easily retrofitted into existing code.
334 If <acquire> is non-NULL, that function will be called whenever an
335 allocation request fails. If the <acquire> function succeeds in
336 allocating the requested space and returns a pointer to the new
337 area, allocation will proceed using the expanded buffer pool. If
338 <acquire> cannot obtain the requested space, it should return NULL
339 and the entire allocation process will fail. <pool_incr>
340 specifies the normal expansion block size. Providing an <acquire>
341 function will cause subsequent bget() requests for buffers too
342 large to be managed in the linked-block scheme (in other words,
343 larger than <pool_incr> minus the buffer overhead) to be satisfied
344 directly by calls to the <acquire> function. Automatic release of
345 empty pool blocks will occur only if all pool blocks in the system
346 are the size given by <pool_incr>.
348 void bstats(bufsize *curalloc, bufsize *totfree,
349 bufsize *maxfree, long *nget, long *nrel);
351 The amount of space currently allocated is stored into the
352 variable pointed to by <curalloc>. The total free space (sum of
353 all free blocks in the pool) is stored into the variable pointed
354 to by <totfree>, and the size of the largest single block in the
355 free space pool is stored into the variable pointed to by
356 <maxfree>. The variables pointed to by <nget> and <nrel> are
357 filled, respectively, with the number of successful (non-NULL
358 return) bget() calls and the number of brel() calls.
360 void bstatse(bufsize *pool_incr, long *npool,
361 long *npget, long *nprel,
362 long *ndget, long *ndrel);
364 Extended statistics: The expansion block size will be stored into
365 the variable pointed to by <pool_incr>, or the negative thereof if
366 automatic expansion block releases are disabled. The number of
367 currently active pool blocks will be stored into the variable
368 pointed to by <npool>. The variables pointed to by <npget> and
369 <nprel> will be filled with, respectively, the number of expansion
370 block acquisitions and releases which have occurred. The
371 variables pointed to by <ndget> and <ndrel> will be filled with
372 the number of bget() and brel() calls, respectively, managed
373 through blocks directly allocated by the acquisition and release
376 void bufdump(void *buf);
378 The buffer pointed to by <buf> is dumped on standard output.
380 void bpoold(void *pool, int dumpalloc, int dumpfree);
382 All buffers in the buffer pool <pool>, previously initialised by a
383 call on bpool(), are listed in ascending memory address order. If
384 <dumpalloc> is nonzero, the contents of allocated buffers are
385 dumped; if <dumpfree> is nonzero, the contents of free blocks are
388 int bpoolv(void *pool);
390 The named buffer pool, previously initialised by a call on
391 bpool(), is validated for bad pointers, overwritten data, etc. If
392 compiled with NDEBUG not defined, any error generates an assertion
393 failure. Otherwise 1 is returned if the pool is valid, 0 if an
401 /*#define TestProg 20000*/ /* Generate built-in test program
402 if defined. The value specifies
403 how many buffer allocation attempts
404 the test program should make. */
406 #define SizeQuant 4 /* Buffer allocation size quantum:
407 all buffers allocated are a
408 multiple of this size. This
409 MUST be a power of two. */
411 #define BufDump 1 /* Define this symbol to enable the
412 bpoold() function which dumps the
413 buffers in a buffer pool. */
415 #define BufValid 1 /* Define this symbol to enable the
416 bpoolv() function for validating
419 #define DumpData 1 /* Define this symbol to enable the
420 bufdump() function which allows
421 dumping the contents of an allocated
424 #define BufStats 1 /* Define this symbol to enable the
425 bstats() function which calculates
426 the total free space in the buffer
427 pool, the largest available
428 buffer, and the total space
429 currently allocated. */
431 #define FreeWipe 1 /* Wipe free buffers to a guaranteed
432 pattern of garbage to trip up
433 miscreants who attempt to use
434 pointers into released buffers. */
436 #define BestFit 1 /* Use a best fit algorithm when
437 searching for space for an
438 allocation request. This uses
439 memory more efficiently, but
440 allocation will be much slower. */
442 #define BECtl 1 /* Define this symbol to enable the
443 bectl() function for automatic
444 pool space control. */
448 int TuiPrintf(const char *format
, ... );
449 #define printf TuiPrintf
452 #define NDEBUG /* Exits in asserts confuse lint */
453 /* LINTLIBRARY */ /* Don't complain about def, no ref */
454 extern char *sprintf(); /* Sun includes don't define sprintf */
462 #ifdef BufDump /* BufDump implies DumpData */
472 /* Declare the interface, including the requested buffer size type,
477 #define MemSize int /* Type for size arguments to memxxx()
478 functions such as memcmp(). */
483 struct bfhead
*flink
; /* Forward link */
484 struct bfhead
*blink
; /* Backward link */
487 /* Header in allocated and free buffers */
490 bufsize prevfree
; /* Relative link back to previous
491 free buffer in memory or 0 if
492 previous buffer is allocated. */
493 bufsize bsize
; /* Buffer size: positive if free,
494 negative if allocated. */
496 #define BH(p) ((struct bhead *) (p))
498 /* Header in directly allocated buffers (by acqfcn) */
501 bufsize tsize
; /* Total size, including overhead */
502 struct bhead bh
; /* Common header */
504 #define BDH(p) ((struct bdhead *) (p))
506 /* Header in free buffers */
509 struct bhead bh
; /* Common allocated/free header */
510 struct qlinks ql
; /* Links on free list */
512 #define BFH(p) ((struct bfhead *) (p))
514 static struct bfhead freelist
= { /* List of free buffers */
516 {&freelist
, &freelist
}
521 static bufsize totalloc
= 0; /* Total space currently allocated */
522 static long numget
= 0, numrel
= 0; /* Number of bget() and brel() calls */
524 static long numpblk
= 0; /* Number of pool blocks */
525 static long numpget
= 0, numprel
= 0; /* Number of block gets and rels */
526 static long numdget
= 0, numdrel
= 0; /* Number of direct gets and rels */
528 #endif /* BufStats */
532 /* Automatic expansion block management functions */
534 static int (*compfcn
) _((bufsize sizereq
, int sequence
)) = NULL
;
535 static void *(*acqfcn
) _((bufsize size
)) = NULL
;
536 static void (*relfcn
) _((void *buf
)) = NULL
;
538 static bufsize exp_incr
= 0; /* Expansion block size */
539 static bufsize pool_len
= 0; /* 0: no bpool calls have been made
540 -1: not all pool blocks are
542 >0: (common) block size for all
543 bpool calls made so far
547 /* Minimum allocation quantum: */
549 #define QLSize (sizeof(struct qlinks))
550 #define SizeQ ((SizeQuant > QLSize) ? SizeQuant : QLSize)
552 #define V (void) /* To denote unwanted returned values */
554 /* End sentinel: value placed in bsize field of dummy block delimiting
555 end of pool block. The most negative number which will fit in a
556 bufsize, defined in a way that the compiler will accept. */
558 #define ESent ((bufsize) (-(((1L << (sizeof(bufsize) * 8 - 2)) - 1) * 2) - 2))
560 /* BGET -- Allocate a buffer. */
562 void *bget(requested_size
)
563 bufsize requested_size
;
565 bufsize size
= requested_size
;
577 if (size
< SizeQ
) { /* Need at least room for the */
578 size
= SizeQ
; /* queue links. */
582 size
= (size
+ (SizeQuant
- 1)) & (~(SizeQuant
- 1));
586 size
+= sizeof(struct bhead
); /* Add overhead in allocated buffer
590 /* If a compact function was provided in the call to bectl(), wrap
591 a loop around the allocation process to allow compaction to
592 intervene in case we don't find a suitable buffer in the chain. */
596 b
= freelist
.ql
.flink
;
602 /* Scan the free list searching for the first buffer big enough
603 to hold the requested size buffer. */
606 while (b
!= &freelist
) {
607 if (b
->bh
.bsize
>= size
) {
608 if ((best
== &freelist
) || (b
->bh
.bsize
< best
->bh
.bsize
)) {
612 b
= b
->ql
.flink
; /* Link to next buffer */
617 while (b
!= &freelist
) {
618 if ((bufsize
) b
->bh
.bsize
>= size
) {
620 /* Buffer is big enough to satisfy the request. Allocate it
621 to the caller. We must decide whether the buffer is large
622 enough to split into the part given to the caller and a
623 free buffer that remains on the free list, or whether the
624 entire buffer should be removed from the free list and
625 given to the caller in its entirety. We only split the
626 buffer if enough room remains for a header plus the minimum
627 quantum of allocation. */
629 if ((b
->bh
.bsize
- size
) > (SizeQ
+ (sizeof(struct bhead
)))) {
630 struct bhead
*ba
, *bn
;
632 ba
= BH(((char *) b
) + (b
->bh
.bsize
- size
));
633 bn
= BH(((char *) ba
) + size
);
634 assert(bn
->prevfree
== b
->bh
.bsize
);
635 /* Subtract size from length of free block. */
637 /* Link allocated buffer to the previous free buffer. */
638 ba
->prevfree
= b
->bh
.bsize
;
639 /* Plug negative size into user buffer. */
640 ba
->bsize
= -(bufsize
) size
;
641 /* Mark buffer after this one not preceded by free block. */
646 numget
++; /* Increment number of bget() calls */
648 buf
= (void *) ((((char *) ba
) + sizeof(struct bhead
)));
653 ba
= BH(((char *) b
) + b
->bh
.bsize
);
654 assert(ba
->prevfree
== b
->bh
.bsize
);
656 /* The buffer isn't big enough to split. Give the whole
657 shebang to the caller and remove it from the free list. */
659 assert(b
->ql
.blink
->ql
.flink
== b
);
660 assert(b
->ql
.flink
->ql
.blink
== b
);
661 b
->ql
.blink
->ql
.flink
= b
->ql
.flink
;
662 b
->ql
.flink
->ql
.blink
= b
->ql
.blink
;
665 totalloc
+= b
->bh
.bsize
;
666 numget
++; /* Increment number of bget() calls */
668 /* Negate size to mark buffer allocated. */
669 b
->bh
.bsize
= -(b
->bh
.bsize
);
671 /* Zero the back pointer in the next buffer in memory
672 to indicate that this buffer is allocated. */
675 /* Give user buffer starting at queue links. */
676 buf
= (void *) &(b
->ql
);
680 b
= b
->ql
.flink
; /* Link to next buffer */
684 /* We failed to find a buffer. If there's a compact function
685 defined, notify it of the size requested. If it returns
686 TRUE, try the allocation again. */
688 if ((compfcn
== NULL
) || (!(*compfcn
)(size
, ++compactseq
))) {
693 /* No buffer available with requested size free. */
695 /* Don't give up yet -- look in the reserve supply. */
697 if (acqfcn
!= NULL
) {
698 if (size
> exp_incr
- sizeof(struct bhead
)) {
700 /* Request is too large to fit in a single expansion
701 block. Try to satisy it by a direct buffer acquisition. */
705 size
+= sizeof(struct bdhead
) - sizeof(struct bhead
);
706 if ((bdh
= BDH((*acqfcn
)((bufsize
) size
))) != NULL
) {
708 /* Mark the buffer special by setting the size field
709 of its header to zero. */
711 bdh
->bh
.prevfree
= 0;
715 numget
++; /* Increment number of bget() calls */
716 numdget
++; /* Direct bget() call count */
718 buf
= (void *) (bdh
+ 1);
724 /* Try to obtain a new expansion block */
728 if ((newpool
= (*acqfcn
)((bufsize
) exp_incr
)) != NULL
) {
729 bpool(newpool
, exp_incr
);
730 buf
= bget(requested_size
); /* This can't, I say, can't
737 /* Still no buffer available */
744 /* BGETZ -- Allocate a buffer and clear its contents to zero. We clear
745 the entire contents of the buffer to zero, not just the
746 region requested by the caller. */
751 char *buf
= (char *) bget(size
);
757 b
= BH(buf
- sizeof(struct bhead
));
762 bd
= BDH(buf
- sizeof(struct bdhead
));
763 rsize
= bd
->tsize
- sizeof(struct bdhead
);
765 rsize
-= sizeof(struct bhead
);
767 assert(rsize
>= size
);
768 V
memset(buf
, 0, (MemSize
) rsize
);
770 return ((void *) buf
);
773 /* BGETR -- Reallocate a buffer. This is a minimal implementation,
774 simply in terms of brel() and bget(). It could be
775 enhanced to allow the buffer to grow into adjacent free
776 blocks and to avoid moving data unnecessarily. */
778 void *bgetr(buf
, size
)
783 bufsize osize
; /* Old size of buffer */
786 if ((nbuf
= bget(size
)) == NULL
) { /* Acquire new buffer */
792 b
= BH(((char *) buf
) - sizeof(struct bhead
));
796 /* Buffer acquired directly through acqfcn. */
799 bd
= BDH(((char *) buf
) - sizeof(struct bdhead
));
800 osize
= bd
->tsize
- sizeof(struct bdhead
);
803 osize
-= sizeof(struct bhead
);
805 V
memcpy((char *) nbuf
, (char *) buf
, /* Copy the data */
806 (MemSize
) ((size
< osize
) ? size
: osize
));
811 /* BREL -- Release a buffer. */
816 struct bfhead
*b
, *bn
;
818 b
= BFH(((char *) buf
) - sizeof(struct bhead
));
820 numrel
++; /* Increment number of brel() calls */
825 if (b
->bh
.bsize
== 0) { /* Directly-acquired buffer? */
828 bdh
= BDH(((char *) buf
) - sizeof(struct bdhead
));
829 assert(b
->bh
.prevfree
== 0);
831 totalloc
-= bdh
->tsize
;
832 assert(totalloc
>= 0);
833 numdrel
++; /* Number of direct releases */
834 #endif /* BufStats */
836 V
memset((char *) buf
, 0x55,
837 (MemSize
) (bdh
->tsize
- sizeof(struct bdhead
)));
838 #endif /* FreeWipe */
839 assert(relfcn
!= NULL
);
840 (*relfcn
)((void *) bdh
); /* Release it directly. */
845 /* Buffer size must be negative, indicating that the buffer is
848 if (b
->bh
.bsize
>= 0) {
851 assert(b
->bh
.bsize
< 0);
853 /* Back pointer in next buffer must be zero, indicating the
856 assert(BH((char *) b
- b
->bh
.bsize
)->prevfree
== 0);
859 totalloc
+= b
->bh
.bsize
;
860 assert(totalloc
>= 0);
863 /* If the back link is nonzero, the previous buffer is free. */
865 if (b
->bh
.prevfree
!= 0) {
867 /* The previous buffer is free. Consolidate this buffer with it
868 by adding the length of this buffer to the previous free
869 buffer. Note that we subtract the size in the buffer being
870 released, since it's negative to indicate that the buffer is
873 register bufsize size
= b
->bh
.bsize
;
875 /* Make the previous buffer the one we're working on. */
876 assert(BH((char *) b
- b
->bh
.prevfree
)->bsize
== b
->bh
.prevfree
);
877 b
= BFH(((char *) b
) - b
->bh
.prevfree
);
881 /* The previous buffer isn't allocated. Insert this buffer
882 on the free list as an isolated free block. */
884 assert(freelist
.ql
.blink
->ql
.flink
== &freelist
);
885 assert(freelist
.ql
.flink
->ql
.blink
== &freelist
);
886 b
->ql
.flink
= &freelist
;
887 b
->ql
.blink
= freelist
.ql
.blink
;
888 freelist
.ql
.blink
= b
;
889 b
->ql
.blink
->ql
.flink
= b
;
890 b
->bh
.bsize
= -b
->bh
.bsize
;
893 /* Now we look at the next buffer in memory, located by advancing from
894 the start of this buffer by its size, to see if that buffer is
895 free. If it is, we combine this buffer with the next one in
896 memory, dechaining the second buffer from the free list. */
898 bn
= BFH(((char *) b
) + b
->bh
.bsize
);
899 if (bn
->bh
.bsize
> 0) {
901 /* The buffer is free. Remove it from the free list and add
902 its size to that of our buffer. */
904 assert(BH((char *) bn
+ bn
->bh
.bsize
)->prevfree
== bn
->bh
.bsize
);
905 assert(bn
->ql
.blink
->ql
.flink
== bn
);
906 assert(bn
->ql
.flink
->ql
.blink
== bn
);
907 bn
->ql
.blink
->ql
.flink
= bn
->ql
.flink
;
908 bn
->ql
.flink
->ql
.blink
= bn
->ql
.blink
;
909 b
->bh
.bsize
+= bn
->bh
.bsize
;
911 /* Finally, advance to the buffer that follows the newly
912 consolidated free block. We must set its backpointer to the
913 head of the consolidated free block. We know the next block
914 must be an allocated block because the process of recombination
915 guarantees that two free blocks will never be contiguous in
918 bn
= BFH(((char *) b
) + b
->bh
.bsize
);
921 V
memset(((char *) b
) + sizeof(struct bfhead
), 0x55,
922 (MemSize
) (b
->bh
.bsize
- sizeof(struct bfhead
)));
924 assert(bn
->bh
.bsize
< 0);
926 /* The next buffer is allocated. Set the backpointer in it to point
927 to this buffer; the previous free buffer in memory. */
929 bn
->bh
.prevfree
= b
->bh
.bsize
;
933 /* If a block-release function is defined, and this free buffer
934 constitutes the entire block, release it. Note that pool_len
935 is defined in such a way that the test will fail unless all
936 pool blocks are the same size. */
938 if (relfcn
!= NULL
&&
939 ((bufsize
) b
->bh
.bsize
) == (pool_len
- sizeof(struct bhead
))) {
941 assert(b
->bh
.prevfree
== 0);
942 assert(BH((char *) b
+ b
->bh
.bsize
)->bsize
== ESent
);
943 assert(BH((char *) b
+ b
->bh
.bsize
)->prevfree
== b
->bh
.bsize
);
944 /* Unlink the buffer from the free list */
945 b
->ql
.blink
->ql
.flink
= b
->ql
.flink
;
946 b
->ql
.flink
->ql
.blink
= b
->ql
.blink
;
950 numprel
++; /* Nr of expansion block releases */
951 numpblk
--; /* Total number of blocks */
952 assert(numpblk
== numpget
- numprel
);
953 #endif /* BufStats */
960 /* BECTL -- Establish automatic pool expansion control */
962 void bectl(compact
, acquire
, release
, pool_incr
)
963 int (*compact
) _((bufsize sizereq
, int sequence
));
964 void *(*acquire
) _((bufsize size
));
965 void (*release
) _((void *buf
));
971 exp_incr
= pool_incr
;
975 /* BPOOL -- Add a region of memory to the buffer pool. */
981 struct bfhead
*b
= BFH(buf
);
985 len
&= ~(SizeQuant
- 1);
990 } else if (len
!= pool_len
) {
994 numpget
++; /* Number of block acquisitions */
995 numpblk
++; /* Number of blocks total */
996 assert(numpblk
== numpget
- numprel
);
997 #endif /* BufStats */
1000 /* Since the block is initially occupied by a single free buffer,
1001 it had better not be (much) larger than the largest buffer
1002 whose size we can store in bhead.bsize. */
1004 assert(len
- sizeof(struct bhead
) <= -((bufsize
) ESent
+ 1));
1006 /* Clear the backpointer at the start of the block to indicate that
1007 there is no free block prior to this one. That blocks
1008 recombination when the first block in memory is released. */
1012 /* Chain the new block to the free list. */
1014 assert(freelist
.ql
.blink
->ql
.flink
== &freelist
);
1015 assert(freelist
.ql
.flink
->ql
.blink
== &freelist
);
1016 b
->ql
.flink
= &freelist
;
1017 b
->ql
.blink
= freelist
.ql
.blink
;
1018 freelist
.ql
.blink
= b
;
1019 b
->ql
.blink
->ql
.flink
= b
;
1021 /* Create a dummy allocated buffer at the end of the pool. This dummy
1022 buffer is seen when a buffer at the end of the pool is released and
1023 blocks recombination of the last buffer with the dummy buffer at
1024 the end. The length in the dummy buffer is set to the largest
1025 negative number to denote the end of the pool for diagnostic
1026 routines (this specific value is not counted on by the actual
1027 allocation and release functions). */
1029 len
-= sizeof(struct bhead
);
1030 b
->bh
.bsize
= (bufsize
) len
;
1032 V
memset(((char *) b
) + sizeof(struct bfhead
), 0x55,
1033 (MemSize
) (len
- sizeof(struct bfhead
)));
1035 bn
= BH(((char *) b
) + len
);
1036 bn
->prevfree
= (bufsize
) len
;
1037 /* Definition of ESent assumes two's complement! */
1044 /* BSTATS -- Return buffer allocation free space statistics. */
1046 void bstats(curalloc
, totfree
, maxfree
, nget
, nrel
)
1047 bufsize
*curalloc
, *totfree
, *maxfree
;
1050 struct bfhead
*b
= freelist
.ql
.flink
;
1054 *curalloc
= totalloc
;
1057 while (b
!= &freelist
) {
1058 assert(b
->bh
.bsize
> 0);
1059 *totfree
+= b
->bh
.bsize
;
1060 if (b
->bh
.bsize
> *maxfree
) {
1061 *maxfree
= b
->bh
.bsize
;
1063 b
= b
->ql
.flink
; /* Link to next buffer */
1069 /* BSTATSE -- Return extended statistics */
1071 void bstatse(pool_incr
, npool
, npget
, nprel
, ndget
, ndrel
)
1073 long *npool
, *npget
, *nprel
, *ndget
, *ndrel
;
1075 *pool_incr
= (pool_len
< 0) ? -exp_incr
: exp_incr
;
1083 #endif /* BufStats */
1087 /* BUFDUMP -- Dump the data in a buffer. This is called with the user
1088 data pointer, and backs up to the buffer header. It will
1089 dump either a free block or an allocated one. */
1095 unsigned char *bdump
;
1098 b
= BFH(((char *) buf
) - sizeof(struct bhead
));
1099 assert(b
->bh
.bsize
!= 0);
1100 if (b
->bh
.bsize
< 0) {
1101 bdump
= (unsigned char *) buf
;
1102 bdlen
= (-b
->bh
.bsize
) - sizeof(struct bhead
);
1104 bdump
= (unsigned char *) (((char *) b
) + sizeof(struct bfhead
));
1105 bdlen
= b
->bh
.bsize
- sizeof(struct bfhead
);
1111 char bhex
[50], bascii
[20];
1117 for (i
= 0; i
< l
; i
++) {
1118 V
sprintf(bhex
+ i
* 3, "%02X ", bdump
[i
]);
1119 bascii
[i
] = isprint(bdump
[i
]) ? bdump
[i
] : ' ';
1122 V
printf("%-48s %s\n", bhex
, bascii
);
1125 while ((bdlen
> 16) && (memcmp((char *) (bdump
- 16),
1126 (char *) bdump
, 16) == 0)) {
1133 " (%d lines [%d bytes] identical to above line skipped)\n",
1135 } else if (dupes
== 1) {
1145 /* BPOOLD -- Dump a buffer pool. The buffer headers are always listed.
1146 If DUMPALLOC is nonzero, the contents of allocated buffers
1147 are dumped. If DUMPFREE is nonzero, free blocks are
1148 dumped as well. If FreeWipe checking is enabled, free
1149 blocks which have been clobbered will always be dumped. */
1151 void bpoold(buf
, dumpalloc
, dumpfree
)
1153 int dumpalloc
, dumpfree
;
1155 struct bfhead
*b
= BFH(buf
);
1157 while (b
->bh
.bsize
!= ESent
) {
1158 bufsize bs
= b
->bh
.bsize
;
1162 V
printf("Allocated buffer: size %6ld bytes.\n", (long) bs
);
1164 bufdump((void *) (((char *) b
) + sizeof(struct bhead
)));
1170 if ((b
->ql
.blink
->ql
.flink
!= b
) ||
1171 (b
->ql
.flink
->ql
.blink
!= b
)) {
1172 lerr
= " (Bad free list links)";
1174 V
printf("Free block: size %6ld bytes.%s\n",
1177 lerr
= ((char *) b
) + sizeof(struct bfhead
);
1178 if ((bs
> sizeof(struct bfhead
)) && ((*lerr
!= 0x55) ||
1179 (memcmp(lerr
, lerr
+ 1,
1180 (MemSize
) (bs
- (sizeof(struct bfhead
) + 1))) != 0))) {
1182 "(Contents of above free block have been overstored.)\n");
1183 bufdump((void *) (((char *) b
) + sizeof(struct bhead
)));
1187 bufdump((void *) (((char *) b
) + sizeof(struct bhead
)));
1190 b
= BFH(((char *) b
) + bs
);
1193 #endif /* BufDump */
1197 /* BPOOLV -- Validate a buffer pool. If NDEBUG isn't defined,
1198 any error generates an assertion failure. */
1203 struct bfhead
*b
= BFH(buf
);
1205 while (b
->bh
.bsize
!= ESent
) {
1206 bufsize bs
= b
->bh
.bsize
;
1217 if ((b
->ql
.blink
->ql
.flink
!= b
) ||
1218 (b
->ql
.flink
->ql
.blink
!= b
)) {
1219 V
printf("Free block: size %6ld bytes. (Bad free list links)\n",
1225 lerr
= ((char *) b
) + sizeof(struct bfhead
);
1226 if ((bs
> sizeof(struct bfhead
)) && ((*lerr
!= 0x55) ||
1227 (memcmp(lerr
, lerr
+ 1,
1228 (MemSize
) (bs
- (sizeof(struct bfhead
) + 1))) != 0))) {
1230 "(Contents of above free block have been overstored.)\n");
1231 bufdump((void *) (((char *) b
) + sizeof(struct bhead
)));
1237 b
= BFH(((char *) b
) + bs
);
1241 #endif /* BufValid */
1243 /***********************\
1245 * Built-in test program *
1247 \***********************/
1251 #define Repeatable 1 /* Repeatable pseudorandom sequence */
1252 /* If Repeatable is not defined, a
1253 time-seeded pseudorandom sequence
1254 is generated, exercising BGET with
1255 a different pattern of calls on each
1257 #define OUR_RAND /* Use our own built-in version of
1258 rand() to guarantee the test is
1262 #define PoolSize 300000 /* Test buffer pool size */
1264 #define PoolSize 50000 /* Test buffer pool size */
1266 #define ExpIncr 32768 /* Test expansion block size */
1267 #define CompactTries 10 /* Maximum tries at compacting */
1269 #define dumpAlloc 0 /* Dump allocated buffers ? */
1270 #define dumpFree 0 /* Dump free buffers ? */
1276 extern char *malloc();
1277 extern int free
_((char *));
1279 static char *bchain
= NULL
; /* Our private buffer chain */
1280 static char *bp
= NULL
; /* Our initial buffer pool */
1286 static unsigned long int next
= 1;
1288 /* Return next random integer */
1292 next
= next
* 1103515245L + 12345;
1293 return (unsigned int) (next
/ 65536L) % 32768L;
1296 /* Set seed for random generator */
1305 /* STATS -- Edit statistics returned by bstats() or bstatse(). */
1307 static void stats(when
)
1310 bufsize cural
, totfree
, maxfree
;
1314 long totblocks
, npget
, nprel
, ndget
, ndrel
;
1317 bstats(&cural
, &totfree
, &maxfree
, &nget
, &nfree
);
1319 "%s: %ld gets, %ld releases. %ld in use, %ld free, largest = %ld\n",
1320 when
, nget
, nfree
, (long) cural
, (long) totfree
, (long) maxfree
);
1322 bstatse(&pincr
, &totblocks
, &npget
, &nprel
, &ndget
, &ndrel
);
1324 " Blocks: size = %ld, %ld (%ld bytes) in use, %ld gets, %ld frees\n",
1325 (long)pincr
, totblocks
, pincr
* totblocks
, npget
, nprel
);
1326 V
printf(" %ld direct gets, %ld direct frees\n", ndget
, ndrel
);
1331 static int protect
= 0; /* Disable compaction during bgetr() */
1333 /* BCOMPACT -- Compaction call-back function. */
1335 static int bcompact(bsize
, seq
)
1341 int i
= rand() & 0x3;
1344 V
printf("Compaction requested. %ld bytes needed, sequence %d.\n",
1348 if (protect
|| (seq
> CompactTries
)) {
1350 V
printf("Compaction gave up.\n");
1355 /* Based on a random cast, release a random buffer in the list
1356 of allocated buffers. */
1358 while (i
> 0 && bc
!= NULL
) {
1359 bc
= *((char **) bc
);
1365 fb
= *((char **) bc
);
1367 *((char **) bc
) = *((char **) fb
);
1374 V
printf("Compaction bailed out.\n");
1376 #endif /* CompactTries */
1380 /* BEXPAND -- Expand pool call-back function. */
1382 static void *bexpand(size
)
1386 bufsize cural
, totfree
, maxfree
;
1389 /* Don't expand beyond the total allocated size given by PoolSize. */
1391 bstats(&cural
, &totfree
, &maxfree
, &nget
, &nfree
);
1393 if (cural
< PoolSize
) {
1394 np
= (void *) malloc((unsigned) size
);
1397 V
printf("Expand pool by %ld -- %s.\n", (long) size
,
1398 np
== NULL
? "failed" : "succeeded");
1403 /* BSHRINK -- Shrink buffer pool call-back function. */
1405 static void bshrink(buf
)
1408 if (((char *) buf
) == bp
) {
1410 V
printf("Initial pool released.\n");
1415 V
printf("Shrink pool.\n");
1422 /* Restrict buffer requests to those large enough to contain our pointer and
1423 small enough for the CPU architecture. */
1425 static bufsize
blimit(bs
)
1428 if (bs
< sizeof(char *)) {
1429 bs
= sizeof(char *);
1432 /* This is written out in this ugly fashion because the
1433 cool expression in sizeof(int) that auto-configured
1434 to any length int befuddled some compilers. */
1436 if (sizeof(int) == 2) {
1453 /* Seed the random number generator. If Repeatable is defined, we
1454 always use the same seed. Otherwise, we seed from the clock to
1455 shake things up from run to run. */
1460 V
srand((int) time((long *) NULL
));
1463 /* Compute x such that pow(x, p) ranges between 1 and 4*ExpIncr as
1464 p ranges from 0 to ExpIncr-1, with a concentration in the lower
1469 x
= exp(log(4.0 * ExpIncr
) / (ExpIncr
- 1.0));
1472 bectl(bcompact
, bexpand
, bshrink
, (bufsize
) ExpIncr
);
1473 bp
= malloc(ExpIncr
);
1475 bpool((void *) bp
, (bufsize
) ExpIncr
);
1477 bp
= malloc(PoolSize
);
1479 bpool((void *) bp
, (bufsize
) PoolSize
);
1482 stats("Create pool");
1483 V
bpoolv((void *) bp
);
1484 bpoold((void *) bp
, dumpAlloc
, dumpFree
);
1486 for (i
= 0; i
< TestProg
; i
++) {
1488 bufsize bs
= pow(x
, (double) (rand() & (ExpIncr
- 1)));
1490 assert(bs
<= (((bufsize
) 4) * ExpIncr
));
1492 if (rand() & 0x400) {
1493 cb
= (char *) bgetz(bs
);
1495 cb
= (char *) bget(bs
);
1506 fb
= *((char **) bc
);
1508 *((char **) bc
) = *((char **) fb
);
1515 *((char **) cb
) = (char *) bchain
;
1518 /* Based on a random cast, release a random buffer in the list
1519 of allocated buffers. */
1521 if ((rand() & 0x10) == 0) {
1523 int i
= rand() & 0x3;
1525 while (i
> 0 && bc
!= NULL
) {
1526 bc
= *((char **) bc
);
1532 fb
= *((char **) bc
);
1534 *((char **) bc
) = *((char **) fb
);
1540 /* Based on a random cast, reallocate a random buffer in the list
1543 if ((rand() & 0x20) == 0) {
1545 int i
= rand() & 0x3;
1547 while (i
> 0 && bc
!= NULL
) {
1548 bc
= *((char **) bc
);
1554 fb
= *((char **) bc
);
1558 bs
= pow(x
, (double) (rand() & (ExpIncr
- 1)));
1561 protect
= 1; /* Protect against compaction */
1563 newb
= (char *) bgetr((void *) fb
, bs
);
1568 *((char **) bc
) = newb
;
1574 stats("\nAfter allocation");
1576 V
bpoolv((void *) bp
);
1577 bpoold((void *) bp
, dumpAlloc
, dumpFree
);
1580 while (bchain
!= NULL
) {
1583 bchain
= *((char **) buf
);
1586 stats("\nAfter release");
1589 V
bpoolv((void *) bp
);
1590 bpoold((void *) bp
, dumpAlloc
, dumpFree
);