1 /*
2
3 B G E T
4
5 Buffer allocator
6
7 Designed and implemented in April of 1972 by John Walker, based on the
8 Case Algol OPRO$ algorithm implemented in 1966.
9
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.
13
14 Portable C version implemented in September of 1990 by an older, wiser
15 instance of the original implementor.
16
17 Souped up and/or weighed down slightly shortly thereafter by Greg
18 Lutz.
19
20 AMIX edition, including the new compaction call-back option, prepared
21 by John Walker in July of 1992.
22
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.
26
27 This program is in the public domain.
28
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
38 years: and he died.
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
43 he died.
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
48 he died.
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
53 he died.
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
60 Enoch:
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:
64 and he died.
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
69 years:
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
72 begat Lamech.
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
76 years: and he died.
77 28. And Lamech lived an hundred eighty and two years, and begat a
78 son:
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
85 years: and he died.
86 32. And Noah was five hundred years old: and Noah begat Shem, Ham,
87 and Japheth.
88
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.
94
95
96 INTRODUCTION
97 ============
98
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:
106
107 * A built-in test program to exercise BGET and
108 demonstrate how the various functions are used.
109
110 * Allocation by either the "first fit" or "best fit"
111 method.
112
113 * Wiping buffers at release time to catch code which
114 references previously released storage.
115
116 * Built-in routines to dump individual buffers or the
117 entire buffer pool.
118
119 * Retrieval of allocation and pool size statistics.
120
121 * Quantisation of buffer sizes to a power of two to
122 satisfy hardware alignment constraints.
123
124 * Automatic pool compaction, growth, and shrinkage by
125 means of call-backs to user defined functions.
126
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.
134
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.
142
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.
150
151
152 BGET IMPLEMENTATION ASSUMPTIONS
153 ===============================
154
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.
169
170
171 GETTING STARTED WITH BGET
172 =========================
173
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
179 likely to need.
180
181 Embedded Applications
182 ---------------------
183
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).
193
194 Malloc() Emulation
195 ------------------
196
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
209 execution.
210
211 Automatic Storage Management
212 ----------------------------
213
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.
235
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.
251
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.)
258
259
260 BGET FUNCTION DESCRIPTIONS
261 ==========================
262
263 Functions implemented in this file (some are enabled by certain of
264 the optional settings below):
265
266 void bpool(void *buffer, bufsize len);
267
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.
271
272 void *bget(bufsize size);
273
274 Allocate a buffer of <size> bytes. The address of the buffer is
275 returned, or NULL if insufficient memory was available to allocate
276 the buffer.
277
278 void *bgetz(bufsize size);
279
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.
283
284 void *bgetr(void *buffer, bufsize newsize);
285
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.
290
291 void brel(void *buf);
292
293 Return the buffer <buf>, previously allocated by bget(), to the
294 free space pool.
295
296 void bectl(int (*compact)(bufsize sizereq, int sequence),
297 void *(*acquire)(bufsize size),
298 void (*release)(void *buf),
299 bufsize pool_incr);
300
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.
333
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>.
347
348 void bstats(bufsize *curalloc, bufsize *totfree,
349 bufsize *maxfree, long *nget, long *nrel);
350
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.
359
360 void bstatse(bufsize *pool_incr, long *npool,
361 long *npget, long *nprel,
362 long *ndget, long *ndrel);
363
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
374 functions.
375
376 void bufdump(void *buf);
377
378 The buffer pointed to by <buf> is dumped on standard output.
379
380 void bpoold(void *pool, int dumpalloc, int dumpfree);
381
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
386 dumped.
387
388 int bpoolv(void *pool);
389
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
394 error is found.
395
396
397 BGET CONFIGURATION
398 ==================
399 */
400
401 #if 0
402 #define TestProg 20000 /* Generate built-in test program
403 if defined. The value specifies
404 how many buffer allocation attempts
405 the test program should make. */
406 #endif
407 #define SizeQuant 4 /* Buffer allocation size quantum:
408 all buffers allocated are a
409 multiple of this size. This
410 MUST be a power of two. */
411 #if 0
412 #define BufDump 1 /* Define this symbol to enable the
413 bpoold() function which dumps the
414 buffers in a buffer pool. */
415
416 #define BufValid 1 /* Define this symbol to enable the
417 bpoolv() function for validating
418 a buffer pool. */
419
420 #define DumpData 1 /* Define this symbol to enable the
421 bufdump() function which allows
422 dumping the contents of an allocated
423 or free buffer. */
424
425 #define BufStats 1 /* Define this symbol to enable the
426 bstats() function which calculates
427 the total free space in the buffer
428 pool, the largest available
429 buffer, and the total space
430 currently allocated. */
431
432 #define FreeWipe 1 /* Wipe free buffers to a guaranteed
433 pattern of garbage to trip up
434 miscreants who attempt to use
435 pointers into released buffers. */
436
437 #define BestFit 1 /* Use a best fit algorithm when
438 searching for space for an
439 allocation request. This uses
440 memory more efficiently, but
441 allocation will be much slower. */
442 #endif
443 #define BECtl 1 /* Define this symbol to enable the
444 bectl() function for automatic
445 pool space control. */
446
447 #include <stdio.h>
448
449 #ifdef lint
450 #define NDEBUG /* Exits in asserts confuse lint */
451 /* LINTLIBRARY */ /* Don't complain about def, no ref */
452 extern char *sprintf(); /* Sun includes don't define sprintf */
453 #endif
454
455 #include <assert.h>
456 #include <memory.h>
457
458 #ifdef BufDump /* BufDump implies DumpData */
459 #ifndef DumpData
460 #define DumpData 1
461 #endif
462 #endif
463
464 #ifdef DumpData
465 #include <ctype.h>
466 #endif
467
468 /* Declare the interface, including the requested buffer size type,
469 bufsize. */
470
471 #include "bget.h"
472
473 #define MemSize int /* Type for size arguments to memxxx()
474 functions such as memcmp(). */
475
476 /* Queue links */
477
478 struct qlinks {
479 struct bfhead *flink; /* Forward link */
480 struct bfhead *blink; /* Backward link */
481 };
482
483 /* Header in allocated and free buffers */
484
485 struct bhead {
486 bufsize prevfree; /* Relative link back to previous
487 free buffer in memory or 0 if
488 previous buffer is allocated. */
489 bufsize bsize; /* Buffer size: positive if free,
490 negative if allocated. */
491 };
492 #define BH(p) ((struct bhead *) (p))
493
494 /* Header in directly allocated buffers (by acqfcn) */
495
496 struct bdhead {
497 bufsize tsize; /* Total size, including overhead */
498 struct bhead bh; /* Common header */
499 };
500 #define BDH(p) ((struct bdhead *) (p))
501
502 /* Header in free buffers */
503
504 struct bfhead {
505 struct bhead bh; /* Common allocated/free header */
506 struct qlinks ql; /* Links on free list */
507 };
508 #define BFH(p) ((struct bfhead *) (p))
509
510 static struct bfhead freelist = { /* List of free buffers */
511 {0, 0},
512 {&freelist, &freelist}
513 };
514
515
516 #ifdef BufStats
517 static bufsize totalloc = 0; /* Total space currently allocated */
518 static long numget = 0, numrel = 0; /* Number of bget() and brel() calls */
519 #ifdef BECtl
520 static long numpblk = 0; /* Number of pool blocks */
521 static long numpget = 0, numprel = 0; /* Number of block gets and rels */
522 static long numdget = 0, numdrel = 0; /* Number of direct gets and rels */
523 #endif /* BECtl */
524 #endif /* BufStats */
525
526 #ifdef BECtl
527
528 /* Automatic expansion block management functions */
529
530 static int (*compfcn) _((bufsize sizereq, int sequence)) = NULL;
531 static void *(*acqfcn) _((bufsize size)) = NULL;
532 static void (*relfcn) _((void *buf)) = NULL;
533
534 static bufsize exp_incr = 0; /* Expansion block size */
535 static bufsize pool_len = 0; /* 0: no bpool calls have been made
536 -1: not all pool blocks are
537 the same size
538 >0: (common) block size for all
539 bpool calls made so far
540 */
541 #endif
542
543 /* Minimum allocation quantum: */
544
545 #define QLSize (sizeof(struct qlinks))
546 #define SizeQ ((SizeQuant > QLSize) ? SizeQuant : QLSize)
547
548 #define V (void) /* To denote unwanted returned values */
549
550 /* End sentinel: value placed in bsize field of dummy block delimiting
551 end of pool block. The most negative number which will fit in a
552 bufsize, defined in a way that the compiler will accept. */
553
554 #define ESent ((bufsize) (-(((1L << (sizeof(bufsize) * 8 - 2)) - 1) * 2) - 2))
555
556 /* BGET -- Allocate a buffer. */
557
bget(requested_size)558 void *bget(requested_size)
559 bufsize requested_size;
560 {
561 bufsize size = requested_size;
562 struct bfhead *b;
563 #ifdef BestFit
564 struct bfhead *best;
565 #endif
566 void *buf;
567 #ifdef BECtl
568 int compactseq = 0;
569 #endif
570
571 assert(size > 0);
572
573 if (size < SizeQ) { /* Need at least room for the */
574 size = SizeQ; /* queue links. */
575 }
576 #ifdef SizeQuant
577 #if SizeQuant > 1
578 size = (size + (SizeQuant - 1)) & (~(SizeQuant - 1));
579 #endif
580 #endif
581
582 size += sizeof(struct bhead); /* Add overhead in allocated buffer
583 to size required. */
584
585 #ifdef BECtl
586 /* If a compact function was provided in the call to bectl(), wrap
587 a loop around the allocation process to allow compaction to
588 intervene in case we don't find a suitable buffer in the chain. */
589
590 while (1) {
591 #endif
592 b = freelist.ql.flink;
593 #ifdef BestFit
594 best = &freelist;
595 #endif
596
597
598 /* Scan the free list searching for the first buffer big enough
599 to hold the requested size buffer. */
600
601 #ifdef BestFit
602 while (b != &freelist) {
603 if (b->bh.bsize >= size) {
604 if ((best == &freelist) || (b->bh.bsize < best->bh.bsize)) {
605 best = b;
606 }
607 }
608 b = b->ql.flink; /* Link to next buffer */
609 }
610 b = best;
611 #endif /* BestFit */
612
613 while (b != &freelist) {
614 if ((bufsize) b->bh.bsize >= size) {
615
616 /* Buffer is big enough to satisfy the request. Allocate it
617 to the caller. We must decide whether the buffer is large
618 enough to split into the part given to the caller and a
619 free buffer that remains on the free list, or whether the
620 entire buffer should be removed from the free list and
621 given to the caller in its entirety. We only split the
622 buffer if enough room remains for a header plus the minimum
623 quantum of allocation. */
624
625 if ((b->bh.bsize - size) > (SizeQ + (sizeof(struct bhead)))) {
626 struct bhead *ba, *bn;
627
628 ba = BH(((char *) b) + (b->bh.bsize - size));
629 bn = BH(((char *) ba) + size);
630 assert(bn->prevfree == b->bh.bsize);
631 /* Subtract size from length of free block. */
632 b->bh.bsize -= size;
633 /* Link allocated buffer to the previous free buffer. */
634 ba->prevfree = b->bh.bsize;
635 /* Plug negative size into user buffer. */
636 ba->bsize = -(bufsize) size;
637 /* Mark buffer after this one not preceded by free block. */
638 bn->prevfree = 0;
639
640 #ifdef BufStats
641 totalloc += size;
642 numget++; /* Increment number of bget() calls */
643 #endif
644 buf = (void *) ((((char *) ba) + sizeof(struct bhead)));
645 return buf;
646 } else {
647 struct bhead *ba;
648
649 ba = BH(((char *) b) + b->bh.bsize);
650 assert(ba->prevfree == b->bh.bsize);
651
652 /* The buffer isn't big enough to split. Give the whole
653 shebang to the caller and remove it from the free list. */
654
655 assert(b->ql.blink->ql.flink == b);
656 assert(b->ql.flink->ql.blink == b);
657 b->ql.blink->ql.flink = b->ql.flink;
658 b->ql.flink->ql.blink = b->ql.blink;
659
660 #ifdef BufStats
661 totalloc += b->bh.bsize;
662 numget++; /* Increment number of bget() calls */
663 #endif
664 /* Negate size to mark buffer allocated. */
665 b->bh.bsize = -(b->bh.bsize);
666
667 /* Zero the back pointer in the next buffer in memory
668 to indicate that this buffer is allocated. */
669 ba->prevfree = 0;
670
671 /* Give user buffer starting at queue links. */
672 buf = (void *) &(b->ql);
673 return buf;
674 }
675 }
676 b = b->ql.flink; /* Link to next buffer */
677 }
678 #ifdef BECtl
679
680 /* We failed to find a buffer. If there's a compact function
681 defined, notify it of the size requested. If it returns
682 TRUE, try the allocation again. */
683
684 if ((compfcn == NULL) || (!(*compfcn)(size, ++compactseq))) {
685 break;
686 }
687 }
688
689 /* No buffer available with requested size free. */
690
691 /* Don't give up yet -- look in the reserve supply. */
692
693 if (acqfcn != NULL) {
694 if (size > exp_incr - sizeof(struct bhead)) {
695
696 /* Request is too large to fit in a single expansion
697 block. Try to satisy it by a direct buffer acquisition. */
698
699 struct bdhead *bdh;
700
701 size += sizeof(struct bdhead) - sizeof(struct bhead);
702 if ((bdh = BDH((*acqfcn)((bufsize) size))) != NULL) {
703
704 /* Mark the buffer special by setting the size field
705 of its header to zero. */
706 bdh->bh.bsize = 0;
707 bdh->bh.prevfree = 0;
708 bdh->tsize = size;
709 #ifdef BufStats
710 totalloc += size;
711 numget++; /* Increment number of bget() calls */
712 numdget++; /* Direct bget() call count */
713 #endif
714 buf = (void *) (bdh + 1);
715 return buf;
716 }
717
718 } else {
719
720 /* Try to obtain a new expansion block */
721
722 void *newpool;
723
724 if ((newpool = (*acqfcn)((bufsize) exp_incr)) != NULL) {
725 bpool(newpool, exp_incr);
726 buf = bget(requested_size); /* This can't, I say, can't
727 get into a loop. */
728 return buf;
729 }
730 }
731 }
732
733 /* Still no buffer available */
734
735 #endif /* BECtl */
736
737 return NULL;
738 }
739
740 /* BGETZ -- Allocate a buffer and clear its contents to zero. We clear
741 the entire contents of the buffer to zero, not just the
742 region requested by the caller. */
743
bgetz(size)744 void *bgetz(size)
745 bufsize size;
746 {
747 char *buf = (char *) bget(size);
748
749 if (buf != NULL) {
750 struct bhead *b;
751 bufsize rsize;
752
753 b = BH(buf - sizeof(struct bhead));
754 rsize = -(b->bsize);
755 if (rsize == 0) {
756 struct bdhead *bd;
757
758 bd = BDH(buf - sizeof(struct bdhead));
759 rsize = bd->tsize - sizeof(struct bdhead);
760 } else {
761 rsize -= sizeof(struct bhead);
762 }
763 assert(rsize >= size);
764 V memset(buf, 0, (MemSize) rsize);
765 }
766 return ((void *) buf);
767 }
768
769 /* BGETR -- Reallocate a buffer. This is a minimal implementation,
770 simply in terms of brel() and bget(). It could be
771 enhanced to allow the buffer to grow into adjacent free
772 blocks and to avoid moving data unnecessarily. */
773
bgetr(buf,size)774 void *bgetr(buf, size)
775 void *buf;
776 bufsize size;
777 {
778 void *nbuf;
779 bufsize osize; /* Old size of buffer */
780 struct bhead *b;
781
782 if ((nbuf = bget(size)) == NULL) { /* Acquire new buffer */
783 return NULL;
784 }
785 if (buf == NULL) {
786 return nbuf;
787 }
788 b = BH(((char *) buf) - sizeof(struct bhead));
789 osize = -b->bsize;
790 #ifdef BECtl
791 if (osize == 0) {
792 /* Buffer acquired directly through acqfcn. */
793 struct bdhead *bd;
794
795 bd = BDH(((char *) buf) - sizeof(struct bdhead));
796 osize = bd->tsize - sizeof(struct bdhead);
797 } else
798 #endif
799 osize -= sizeof(struct bhead);
800 assert(osize > 0);
801 V memcpy((char *) nbuf, (char *) buf, /* Copy the data */
802 (MemSize) ((size < osize) ? size : osize));
803 brel(buf);
804 return nbuf;
805 }
806
807 /* BREL -- Release a buffer. */
808
brel(buf)809 void brel(buf)
810 void *buf;
811 {
812 struct bfhead *b, *bn;
813
814 b = BFH(((char *) buf) - sizeof(struct bhead));
815 #ifdef BufStats
816 numrel++; /* Increment number of brel() calls */
817 #endif
818 assert(buf != NULL);
819
820 #ifdef BECtl
821 if (b->bh.bsize == 0) { /* Directly-acquired buffer? */
822 struct bdhead *bdh;
823
824 bdh = BDH(((char *) buf) - sizeof(struct bdhead));
825 assert(b->bh.prevfree == 0);
826 #ifdef BufStats
827 totalloc -= bdh->tsize;
828 assert(totalloc >= 0);
829 numdrel++; /* Number of direct releases */
830 #endif /* BufStats */
831 #ifdef FreeWipe
832 V memset((char *) buf, 0x55,
833 (MemSize) (bdh->tsize - sizeof(struct bdhead)));
834 #endif /* FreeWipe */
835 assert(relfcn != NULL);
836 (*relfcn)((void *) bdh); /* Release it directly. */
837 return;
838 }
839 #endif /* BECtl */
840
841 /* Buffer size must be negative, indicating that the buffer is
842 allocated. */
843
844 if (b->bh.bsize >= 0) {
845 bn = NULL;
846 }
847 assert(b->bh.bsize < 0);
848
849 /* Back pointer in next buffer must be zero, indicating the
850 same thing: */
851
852 assert(BH((char *) b - b->bh.bsize)->prevfree == 0);
853
854 #ifdef BufStats
855 totalloc += b->bh.bsize;
856 assert(totalloc >= 0);
857 #endif
858
859 /* If the back link is nonzero, the previous buffer is free. */
860
861 if (b->bh.prevfree != 0) {
862
863 /* The previous buffer is free. Consolidate this buffer with it
864 by adding the length of this buffer to the previous free
865 buffer. Note that we subtract the size in the buffer being
866 released, since it's negative to indicate that the buffer is
867 allocated. */
868
869 register bufsize size = b->bh.bsize;
870
871 /* Make the previous buffer the one we're working on. */
872 assert(BH((char *) b - b->bh.prevfree)->bsize == b->bh.prevfree);
873 b = BFH(((char *) b) - b->bh.prevfree);
874 b->bh.bsize -= size;
875 } else {
876
877 /* The previous buffer isn't allocated. Insert this buffer
878 on the free list as an isolated free block. */
879
880 assert(freelist.ql.blink->ql.flink == &freelist);
881 assert(freelist.ql.flink->ql.blink == &freelist);
882 b->ql.flink = &freelist;
883 b->ql.blink = freelist.ql.blink;
884 freelist.ql.blink = b;
885 b->ql.blink->ql.flink = b;
886 b->bh.bsize = -b->bh.bsize;
887 }
888
889 /* Now we look at the next buffer in memory, located by advancing from
890 the start of this buffer by its size, to see if that buffer is
891 free. If it is, we combine this buffer with the next one in
892 memory, dechaining the second buffer from the free list. */
893
894 bn = BFH(((char *) b) + b->bh.bsize);
895 if (bn->bh.bsize > 0) {
896
897 /* The buffer is free. Remove it from the free list and add
898 its size to that of our buffer. */
899
900 assert(BH((char *) bn + bn->bh.bsize)->prevfree == bn->bh.bsize);
901 assert(bn->ql.blink->ql.flink == bn);
902 assert(bn->ql.flink->ql.blink == bn);
903 bn->ql.blink->ql.flink = bn->ql.flink;
904 bn->ql.flink->ql.blink = bn->ql.blink;
905 b->bh.bsize += bn->bh.bsize;
906
907 /* Finally, advance to the buffer that follows the newly
908 consolidated free block. We must set its backpointer to the
909 head of the consolidated free block. We know the next block
910 must be an allocated block because the process of recombination
911 guarantees that two free blocks will never be contiguous in
912 memory. */
913
914 bn = BFH(((char *) b) + b->bh.bsize);
915 }
916 #ifdef FreeWipe
917 V memset(((char *) b) + sizeof(struct bfhead), 0x55,
918 (MemSize) (b->bh.bsize - sizeof(struct bfhead)));
919 #endif
920 assert(bn->bh.bsize < 0);
921
922 /* The next buffer is allocated. Set the backpointer in it to point
923 to this buffer; the previous free buffer in memory. */
924
925 bn->bh.prevfree = b->bh.bsize;
926
927 #ifdef BECtl
928
929 /* If a block-release function is defined, and this free buffer
930 constitutes the entire block, release it. Note that pool_len
931 is defined in such a way that the test will fail unless all
932 pool blocks are the same size. */
933
934 if (relfcn != NULL &&
935 ((bufsize) b->bh.bsize) == (pool_len - sizeof(struct bhead))) {
936
937 assert(b->bh.prevfree == 0);
938 assert(BH((char *) b + b->bh.bsize)->bsize == ESent);
939 assert(BH((char *) b + b->bh.bsize)->prevfree == b->bh.bsize);
940 /* Unlink the buffer from the free list */
941 b->ql.blink->ql.flink = b->ql.flink;
942 b->ql.flink->ql.blink = b->ql.blink;
943
944 (*relfcn)(b);
945 #ifdef BufStats
946 numprel++; /* Nr of expansion block releases */
947 numpblk--; /* Total number of blocks */
948 assert(numpblk == numpget - numprel);
949 #endif /* BufStats */
950 }
951 #endif /* BECtl */
952 }
953
954 #ifdef BECtl
955
956 /* BECTL -- Establish automatic pool expansion control */
957
958 void bectl(compact, acquire, release, pool_incr)
959 int (*compact) _((bufsize sizereq, int sequence));
960 void *(*acquire) _((bufsize size));
961 void (*release) _((void *buf));
962 bufsize pool_incr;
963 {
964 compfcn = compact;
965 acqfcn = acquire;
966 relfcn = release;
967 exp_incr = pool_incr;
968 }
969 #endif
970
971 /* BPOOL -- Add a region of memory to the buffer pool. */
972
bpool(buf,len)973 void bpool(buf, len)
974 void *buf;
975 bufsize len;
976 {
977 struct bfhead *b = BFH(buf);
978 struct bhead *bn;
979
980 #ifdef SizeQuant
981 len &= ~(SizeQuant - 1);
982 #endif
983 #ifdef BECtl
984 if (pool_len == 0) {
985 pool_len = len;
986 } else if (len != pool_len) {
987 pool_len = -1;
988 }
989 #ifdef BufStats
990 numpget++; /* Number of block acquisitions */
991 numpblk++; /* Number of blocks total */
992 assert(numpblk == numpget - numprel);
993 #endif /* BufStats */
994 #endif /* BECtl */
995
996 /* Since the block is initially occupied by a single free buffer,
997 it had better not be (much) larger than the largest buffer
998 whose size we can store in bhead.bsize. */
999
1000 assert(len - sizeof(struct bhead) <= -((bufsize) ESent + 1));
1001
1002 /* Clear the backpointer at the start of the block to indicate that
1003 there is no free block prior to this one. That blocks
1004 recombination when the first block in memory is released. */
1005
1006 b->bh.prevfree = 0;
1007
1008 /* Chain the new block to the free list. */
1009
1010 assert(freelist.ql.blink->ql.flink == &freelist);
1011 assert(freelist.ql.flink->ql.blink == &freelist);
1012 b->ql.flink = &freelist;
1013 b->ql.blink = freelist.ql.blink;
1014 freelist.ql.blink = b;
1015 b->ql.blink->ql.flink = b;
1016
1017 /* Create a dummy allocated buffer at the end of the pool. This dummy
1018 buffer is seen when a buffer at the end of the pool is released and
1019 blocks recombination of the last buffer with the dummy buffer at
1020 the end. The length in the dummy buffer is set to the largest
1021 negative number to denote the end of the pool for diagnostic
1022 routines (this specific value is not counted on by the actual
1023 allocation and release functions). */
1024
1025 len -= sizeof(struct bhead);
1026 b->bh.bsize = (bufsize) len;
1027 #ifdef FreeWipe
1028 V memset(((char *) b) + sizeof(struct bfhead), 0x55,
1029 (MemSize) (len - sizeof(struct bfhead)));
1030 #endif
1031 bn = BH(((char *) b) + len);
1032 bn->prevfree = (bufsize) len;
1033 /* Definition of ESent assumes two's complement! */
1034 assert((~0) == -1);
1035 bn->bsize = ESent;
1036 }
1037
1038 #ifdef BufStats
1039
1040 /* BSTATS -- Return buffer allocation free space statistics. */
1041
bstats(curalloc,totfree,maxfree,nget,nrel)1042 void bstats(curalloc, totfree, maxfree, nget, nrel)
1043 bufsize *curalloc, *totfree, *maxfree;
1044 long *nget, *nrel;
1045 {
1046 struct bfhead *b = freelist.ql.flink;
1047
1048 *nget = numget;
1049 *nrel = numrel;
1050 *curalloc = totalloc;
1051 *totfree = 0;
1052 *maxfree = -1;
1053 while (b != &freelist) {
1054 assert(b->bh.bsize > 0);
1055 *totfree += b->bh.bsize;
1056 if (b->bh.bsize > *maxfree) {
1057 *maxfree = b->bh.bsize;
1058 }
1059 b = b->ql.flink; /* Link to next buffer */
1060 }
1061 }
1062
1063 #ifdef BECtl
1064
1065 /* BSTATSE -- Return extended statistics */
1066
bstatse(pool_incr,npool,npget,nprel,ndget,ndrel)1067 void bstatse(pool_incr, npool, npget, nprel, ndget, ndrel)
1068 bufsize *pool_incr;
1069 long *npool, *npget, *nprel, *ndget, *ndrel;
1070 {
1071 *pool_incr = (pool_len < 0) ? -exp_incr : exp_incr;
1072 *npool = numpblk;
1073 *npget = numpget;
1074 *nprel = numprel;
1075 *ndget = numdget;
1076 *ndrel = numdrel;
1077 }
1078 #endif /* BECtl */
1079 #endif /* BufStats */
1080
1081 #ifdef DumpData
1082
1083 /* BUFDUMP -- Dump the data in a buffer. This is called with the user
1084 data pointer, and backs up to the buffer header. It will
1085 dump either a free block or an allocated one. */
1086
bufdump(buf)1087 void bufdump(buf)
1088 void *buf;
1089 {
1090 struct bfhead *b;
1091 unsigned char *bdump;
1092 bufsize bdlen;
1093
1094 b = BFH(((char *) buf) - sizeof(struct bhead));
1095 assert(b->bh.bsize != 0);
1096 if (b->bh.bsize < 0) {
1097 bdump = (unsigned char *) buf;
1098 bdlen = (-b->bh.bsize) - sizeof(struct bhead);
1099 } else {
1100 bdump = (unsigned char *) (((char *) b) + sizeof(struct bfhead));
1101 bdlen = b->bh.bsize - sizeof(struct bfhead);
1102 }
1103
1104 while (bdlen > 0) {
1105 int i, dupes = 0;
1106 bufsize l = bdlen;
1107 char bhex[50], bascii[20];
1108
1109 if (l > 16) {
1110 l = 16;
1111 }
1112
1113 for (i = 0; i < l; i++) {
1114 V sprintf(bhex + i * 3, "%02X ", bdump[i]);
1115 bascii[i] = isprint(bdump[i]) ? bdump[i] : ' ';
1116 }
1117 bascii[i] = 0;
1118 V printf("%-48s %s\n", bhex, bascii);
1119 bdump += l;
1120 bdlen -= l;
1121 while ((bdlen > 16) && (memcmp((char *) (bdump - 16),
1122 (char *) bdump, 16) == 0)) {
1123 dupes++;
1124 bdump += 16;
1125 bdlen -= 16;
1126 }
1127 if (dupes > 1) {
1128 V printf(
1129 " (%d lines [%d bytes] identical to above line skipped)\n",
1130 dupes, dupes * 16);
1131 } else if (dupes == 1) {
1132 bdump -= 16;
1133 bdlen += 16;
1134 }
1135 }
1136 }
1137 #endif
1138
1139 #ifdef BufDump
1140
1141 /* BPOOLD -- Dump a buffer pool. The buffer headers are always listed.
1142 If DUMPALLOC is nonzero, the contents of allocated buffers
1143 are dumped. If DUMPFREE is nonzero, free blocks are
1144 dumped as well. If FreeWipe checking is enabled, free
1145 blocks which have been clobbered will always be dumped. */
1146
bpoold(buf,dumpalloc,dumpfree)1147 void bpoold(buf, dumpalloc, dumpfree)
1148 void *buf;
1149 int dumpalloc, dumpfree;
1150 {
1151 struct bfhead *b = BFH(buf);
1152
1153 while (b->bh.bsize != ESent) {
1154 bufsize bs = b->bh.bsize;
1155
1156 if (bs < 0) {
1157 bs = -bs;
1158 V printf("Allocated buffer: size %6ld bytes.\n", (long) bs);
1159 if (dumpalloc) {
1160 bufdump((void *) (((char *) b) + sizeof(struct bhead)));
1161 }
1162 } else {
1163 char *lerr = "";
1164
1165 assert(bs > 0);
1166 if ((b->ql.blink->ql.flink != b) ||
1167 (b->ql.flink->ql.blink != b)) {
1168 lerr = " (Bad free list links)";
1169 }
1170 V printf("Free block: size %6ld bytes.%s\n",
1171 (long) bs, lerr);
1172 #ifdef FreeWipe
1173 lerr = ((char *) b) + sizeof(struct bfhead);
1174 if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) ||
1175 (memcmp(lerr, lerr + 1,
1176 (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) {
1177 V printf(
1178 "(Contents of above free block have been overstored.)\n");
1179 bufdump((void *) (((char *) b) + sizeof(struct bhead)));
1180 } else
1181 #endif
1182 if (dumpfree) {
1183 bufdump((void *) (((char *) b) + sizeof(struct bhead)));
1184 }
1185 }
1186 b = BFH(((char *) b) + bs);
1187 }
1188 }
1189 #endif /* BufDump */
1190
1191 #ifdef BufValid
1192
1193 /* BPOOLV -- Validate a buffer pool. If NDEBUG isn't defined,
1194 any error generates an assertion failure. */
1195
bpoolv(buf)1196 int bpoolv(buf)
1197 void *buf;
1198 {
1199 struct bfhead *b = BFH(buf);
1200
1201 while (b->bh.bsize != ESent) {
1202 bufsize bs = b->bh.bsize;
1203
1204 if (bs < 0) {
1205 bs = -bs;
1206 } else {
1207 char *lerr = "";
1208
1209 assert(bs > 0);
1210 if (bs <= 0) {
1211 return 0;
1212 }
1213 if ((b->ql.blink->ql.flink != b) ||
1214 (b->ql.flink->ql.blink != b)) {
1215 V printf("Free block: size %6ld bytes. (Bad free list links)\n",
1216 (long) bs);
1217 assert(0);
1218 return 0;
1219 }
1220 #ifdef FreeWipe
1221 lerr = ((char *) b) + sizeof(struct bfhead);
1222 if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) ||
1223 (memcmp(lerr, lerr + 1,
1224 (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) {
1225 V printf(
1226 "(Contents of above free block have been overstored.)\n");
1227 bufdump((void *) (((char *) b) + sizeof(struct bhead)));
1228 assert(0);
1229 return 0;
1230 }
1231 #endif
1232 }
1233 b = BFH(((char *) b) + bs);
1234 }
1235 return 1;
1236 }
1237 #endif /* BufValid */
1238
1239 /***********************\
1240 * *
1241 * Built-in test program *
1242 * *
1243 \***********************/
1244
1245 #ifdef TestProg
1246
1247 #define Repeatable 1 /* Repeatable pseudorandom sequence */
1248 /* If Repeatable is not defined, a
1249 time-seeded pseudorandom sequence
1250 is generated, exercising BGET with
1251 a different pattern of calls on each
1252 run. */
1253 #define OUR_RAND /* Use our own built-in version of
1254 rand() to guarantee the test is
1255 100% repeatable. */
1256
1257 #ifdef BECtl
1258 #define PoolSize 300000 /* Test buffer pool size */
1259 #else
1260 #define PoolSize 50000 /* Test buffer pool size */
1261 #endif
1262 #define ExpIncr 32768 /* Test expansion block size */
1263 #define CompactTries 10 /* Maximum tries at compacting */
1264
1265 #define dumpAlloc 0 /* Dump allocated buffers ? */
1266 #define dumpFree 0 /* Dump free buffers ? */
1267
1268 #ifndef Repeatable
1269 extern long time();
1270 #endif
1271
1272 extern char *malloc();
1273 extern int free _((char *));
1274
1275 static char *bchain = NULL; /* Our private buffer chain */
1276 static char *bp = NULL; /* Our initial buffer pool */
1277
1278 #include <math.h>
1279
1280 #ifdef OUR_RAND
1281
1282 static unsigned long int next = 1;
1283
1284 /* Return next random integer */
1285
rand()1286 int rand()
1287 {
1288 next = next * 1103515245L + 12345;
1289 return (unsigned int) (next / 65536L) % 32768L;
1290 }
1291
1292 /* Set seed for random generator */
1293
srand(seed)1294 void srand(seed)
1295 unsigned int seed;
1296 {
1297 next = seed;
1298 }
1299 #endif
1300
1301 /* STATS -- Edit statistics returned by bstats() or bstatse(). */
1302
stats(when)1303 static void stats(when)
1304 char *when;
1305 {
1306 bufsize cural, totfree, maxfree;
1307 long nget, nfree;
1308 #ifdef BECtl
1309 bufsize pincr;
1310 long totblocks, npget, nprel, ndget, ndrel;
1311 #endif
1312
1313 bstats(&cural, &totfree, &maxfree, &nget, &nfree);
1314 V printf(
1315 "%s: %ld gets, %ld releases. %ld in use, %ld free, largest = %ld\n",
1316 when, nget, nfree, (long) cural, (long) totfree, (long) maxfree);
1317 #ifdef BECtl
1318 bstatse(&pincr, &totblocks, &npget, &nprel, &ndget, &ndrel);
1319 V printf(
1320 " Blocks: size = %ld, %ld (%ld bytes) in use, %ld gets, %ld frees\n",
1321 (long)pincr, totblocks, pincr * totblocks, npget, nprel);
1322 V printf(" %ld direct gets, %ld direct frees\n", ndget, ndrel);
1323 #endif /* BECtl */
1324 }
1325
1326 #ifdef BECtl
1327 static int protect = 0; /* Disable compaction during bgetr() */
1328
1329 /* BCOMPACT -- Compaction call-back function. */
1330
bcompact(bsize,seq)1331 static int bcompact(bsize, seq)
1332 bufsize bsize;
1333 int seq;
1334 {
1335 #ifdef CompactTries
1336 char *bc = bchain;
1337 int i = rand() & 0x3;
1338
1339 #ifdef COMPACTRACE
1340 V printf("Compaction requested. %ld bytes needed, sequence %d.\n",
1341 (long) bsize, seq);
1342 #endif
1343
1344 if (protect || (seq > CompactTries)) {
1345 #ifdef COMPACTRACE
1346 V printf("Compaction gave up.\n");
1347 #endif
1348 return 0;
1349 }
1350
1351 /* Based on a random cast, release a random buffer in the list
1352 of allocated buffers. */
1353
1354 while (i > 0 && bc != NULL) {
1355 bc = *((char **) bc);
1356 i--;
1357 }
1358 if (bc != NULL) {
1359 char *fb;
1360
1361 fb = *((char **) bc);
1362 if (fb != NULL) {
1363 *((char **) bc) = *((char **) fb);
1364 brel((void *) fb);
1365 return 1;
1366 }
1367 }
1368
1369 #ifdef COMPACTRACE
1370 V printf("Compaction bailed out.\n");
1371 #endif
1372 #endif /* CompactTries */
1373 return 0;
1374 }
1375
1376 /* BEXPAND -- Expand pool call-back function. */
1377
bexpand(size)1378 static void *bexpand(size)
1379 bufsize size;
1380 {
1381 void *np = NULL;
1382 bufsize cural, totfree, maxfree;
1383 long nget, nfree;
1384
1385 /* Don't expand beyond the total allocated size given by PoolSize. */
1386
1387 bstats(&cural, &totfree, &maxfree, &nget, &nfree);
1388
1389 if (cural < PoolSize) {
1390 np = (void *) malloc((unsigned) size);
1391 }
1392 #ifdef EXPTRACE
1393 V printf("Expand pool by %ld -- %s.\n", (long) size,
1394 np == NULL ? "failed" : "succeeded");
1395 #endif
1396 return np;
1397 }
1398
1399 /* BSHRINK -- Shrink buffer pool call-back function. */
1400
bshrink(buf)1401 static void bshrink(buf)
1402 void *buf;
1403 {
1404 if (((char *) buf) == bp) {
1405 #ifdef EXPTRACE
1406 V printf("Initial pool released.\n");
1407 #endif
1408 bp = NULL;
1409 }
1410 #ifdef EXPTRACE
1411 V printf("Shrink pool.\n");
1412 #endif
1413 free((char *) buf);
1414 }
1415
1416 #endif /* BECtl */
1417
1418 /* Restrict buffer requests to those large enough to contain our pointer and
1419 small enough for the CPU architecture. */
1420
blimit(bs)1421 static bufsize blimit(bs)
1422 bufsize bs;
1423 {
1424 if (bs < sizeof(char *)) {
1425 bs = sizeof(char *);
1426 }
1427
1428 /* This is written out in this ugly fashion because the
1429 cool expression in sizeof(int) that auto-configured
1430 to any length int befuddled some compilers. */
1431
1432 if (sizeof(int) == 2) {
1433 if (bs > 32767) {
1434 bs = 32767;
1435 }
1436 } else {
1437 if (bs > 200000) {
1438 bs = 200000;
1439 }
1440 }
1441 return bs;
1442 }
1443
main()1444 int main()
1445 {
1446 int i;
1447 double x;
1448
1449 /* Seed the random number generator. If Repeatable is defined, we
1450 always use the same seed. Otherwise, we seed from the clock to
1451 shake things up from run to run. */
1452
1453 #ifdef Repeatable
1454 V srand(1234);
1455 #else
1456 V srand((int) time((long *) NULL));
1457 #endif
1458
1459 /* Compute x such that pow(x, p) ranges between 1 and 4*ExpIncr as
1460 p ranges from 0 to ExpIncr-1, with a concentration in the lower
1461 numbers. */
1462
1463 x = 4.0 * ExpIncr;
1464 x = log(x);
1465 x = exp(log(4.0 * ExpIncr) / (ExpIncr - 1.0));
1466
1467 #ifdef BECtl
1468 bectl(bcompact, bexpand, bshrink, (bufsize) ExpIncr);
1469 bp = malloc(ExpIncr);
1470 assert(bp != NULL);
1471 bpool((void *) bp, (bufsize) ExpIncr);
1472 #else
1473 bp = malloc(PoolSize);
1474 assert(bp != NULL);
1475 bpool((void *) bp, (bufsize) PoolSize);
1476 #endif
1477
1478 stats("Create pool");
1479 V bpoolv((void *) bp);
1480 bpoold((void *) bp, dumpAlloc, dumpFree);
1481
1482 for (i = 0; i < TestProg; i++) {
1483 char *cb;
1484 bufsize bs = pow(x, (double) (rand() & (ExpIncr - 1)));
1485
1486 assert(bs <= (((bufsize) 4) * ExpIncr));
1487 bs = blimit(bs);
1488 if (rand() & 0x400) {
1489 cb = (char *) bgetz(bs);
1490 } else {
1491 cb = (char *) bget(bs);
1492 }
1493 if (cb == NULL) {
1494 #ifdef EasyOut
1495 break;
1496 #else
1497 char *bc = bchain;
1498
1499 if (bc != NULL) {
1500 char *fb;
1501
1502 fb = *((char **) bc);
1503 if (fb != NULL) {
1504 *((char **) bc) = *((char **) fb);
1505 brel((void *) fb);
1506 }
1507 continue;
1508 }
1509 #endif
1510 }
1511 *((char **) cb) = (char *) bchain;
1512 bchain = cb;
1513
1514 /* Based on a random cast, release a random buffer in the list
1515 of allocated buffers. */
1516
1517 if ((rand() & 0x10) == 0) {
1518 char *bc = bchain;
1519 int i = rand() & 0x3;
1520
1521 while (i > 0 && bc != NULL) {
1522 bc = *((char **) bc);
1523 i--;
1524 }
1525 if (bc != NULL) {
1526 char *fb;
1527
1528 fb = *((char **) bc);
1529 if (fb != NULL) {
1530 *((char **) bc) = *((char **) fb);
1531 brel((void *) fb);
1532 }
1533 }
1534 }
1535
1536 /* Based on a random cast, reallocate a random buffer in the list
1537 to a random size */
1538
1539 if ((rand() & 0x20) == 0) {
1540 char *bc = bchain;
1541 int i = rand() & 0x3;
1542
1543 while (i > 0 && bc != NULL) {
1544 bc = *((char **) bc);
1545 i--;
1546 }
1547 if (bc != NULL) {
1548 char *fb;
1549
1550 fb = *((char **) bc);
1551 if (fb != NULL) {
1552 char *newb;
1553
1554 bs = pow(x, (double) (rand() & (ExpIncr - 1)));
1555 bs = blimit(bs);
1556 #ifdef BECtl
1557 protect = 1; /* Protect against compaction */
1558 #endif
1559 newb = (char *) bgetr((void *) fb, bs);
1560 #ifdef BECtl
1561 protect = 0;
1562 #endif
1563 if (newb != NULL) {
1564 *((char **) bc) = newb;
1565 }
1566 }
1567 }
1568 }
1569 }
1570 stats("\nAfter allocation");
1571 if (bp != NULL) {
1572 V bpoolv((void *) bp);
1573 bpoold((void *) bp, dumpAlloc, dumpFree);
1574 }
1575
1576 while (bchain != NULL) {
1577 char *buf = bchain;
1578
1579 bchain = *((char **) buf);
1580 brel((void *) buf);
1581 }
1582 stats("\nAfter release");
1583 #ifndef BECtl
1584 if (bp != NULL) {
1585 V bpoolv((void *) bp);
1586 bpoold((void *) bp, dumpAlloc, dumpFree);
1587 }
1588 #endif
1589
1590 return 0;
1591 }
1592 #endif
1593