tcpreplay/src/fragroute/bget.c

/*

                   B G E T

               Buffer allocator

    Designed and implemented in April of 1972 by John Walker, based on the
    Case Algol OPRO$ algorithm implemented in 1966.

    Reimplemented in 1975 by John Walker for the Interdata 70.
    Reimplemented in 1977 by John Walker for the Marinchip 9900.
    Reimplemented in 1982 by Duff Kurland for the Intel 8080.

    Portable C version implemented in September of 1990 by an older, wiser
    instance of the original implementor.

    Souped up and/or weighed down  slightly  shortly  thereafter  by  Greg
    Lutz.

    AMIX  edition, including the new compaction call-back option, prepared
    by John Walker in July of 1992.

    Bug in built-in test program fixed, ANSI compiler warnings eradicated,
    buffer pool validator  implemented,  and  guaranteed  repeatable  test
    added by John Walker in October of 1995.

    This program is in the public domain.

     1. This is the book of the generations of Adam.   In the day that God
    created man, in the likeness of God made he him;
     2. Male and female created he them;  and  blessed    them,  and  called
    their name Adam, in the day when they were created.
     3. And  Adam  lived  an hundred and thirty years,    and begat a son in
    his own likeness, and after his image; and called his name Seth:
     4. And the days of  Adam  after  he  had  begotten  Seth  were  eight
    hundred years: and he begat sons and daughters:
     5. And  all  the  days  that Adam lived were nine    hundred and thirty
    years: and he died.
     6. And Seth lived an hundred and five years, and begat Enos:
     7. And Seth lived after he begat Enos eight hundred and seven  years,
    and begat sons and daughters:
     8.  And  all the days of Seth were nine hundred and twelve years: and
     he died.
     9. And Enos lived ninety years, and begat Cainan:
    10. And Enos lived after he begat  Cainan eight  hundred  and  fifteen
    years, and begat sons and daughters:
    11. And  all  the days of Enos were nine hundred  and five years:  and
    he died.
    12. And Cainan lived seventy years and begat Mahalaleel:
    13. And Cainan lived  after he  begat  Mahalaleel  eight  hundred  and
    forty years, and begat sons and daughters:
    14. And  all the days of Cainan were nine  hundred and ten years:  and
    he died.
    15. And Mahalaleel lived sixty and five years, and begat Jared:
    16. And Mahalaleel lived  after  he  begat    Jared  eight  hundred  and
    thirty years, and begat sons and daughters:
    17. And  all  the  days  of Mahalaleel  were eight hundred    ninety and
    five years: and he died.
    18. And Jared lived an hundred sixty and  two  years,   and  he  begat
    Enoch:
    19. And  Jared  lived  after he begat Enoch  eight hundred years,  and
    begat sons and daughters:
    20. And all the days of Jared  were nine hundred sixty and two  years:
    and he died.
    21. And Enoch lived sixty and five years, and begat Methuselah:
    22. And  Enoch  walked   with  God    after  he  begat Methuselah  three
    hundred years, and begat sons and daughters:
    23. And all the days of  Enoch  were  three  hundred  sixty  and  five
    years:
    24. And Enoch walked with God: and he was not; for God took him.
    25. And  Methuselah  lived    an  hundred  eighty and  seven years,  and
    begat Lamech.
    26. And Methuselah lived after he  begat Lamech seven  hundred  eighty
    and two years, and begat sons and daughters:
    27. And  all the days of Methuselah  were nine hundred  sixty and nine
    years: and he died.
    28. And Lamech lived an hundred eighty  and two  years,  and  begat  a
    son:
    29. And  he called his name Noah, saying,  This same shall    comfort us
    concerning  our  work and toil of our hands, because of the ground
    which the LORD hath cursed.
    30. And  Lamech  lived  after  he begat Noah  five hundred    ninety and
    five years, and begat sons and daughters:
    31. And all the days of Lamech were  seven hundred seventy    and  seven
    years: and he died.
    32. And  Noah  was five hundred years old:    and Noah begat Shem,  Ham,
    and Japheth.

    And buffers begat buffers, and links begat    links,    and  buffer  pools
    begat  links  to chains of buffer pools containing buffers, and lo the
    buffers and links and pools of buffers and pools of links to chains of
    pools  of  buffers were fruitful and they multiplied and the Operating
    System looked down upon them and said that it was Good.


    INTRODUCTION
    ============

    BGET  is a comprehensive memory allocation package which is easily
    configured to the needs of an application.    BGET is  efficient  in
    both  the  time  needed to allocate and release buffers and in the
    memory  overhead  required    for  buffer   pool   management.    It
    automatically    consolidates   contiguous     space     to   minimize
    fragmentation.  BGET is configured    by  compile-time  definitions,
    Major options include:

    *   A  built-in  test  program    to  exercise  BGET   and
        demonstrate how the various functions are used.

        *   Allocation  by  either the "first fit" or "best fit"
        method.

    *   Wiping buffers at release time to catch  code  which
        references previously released storage.

    *   Built-in  routines to dump individual buffers or the
        entire buffer pool.

    *   Retrieval of allocation and pool size statistics.

    *   Quantisation of buffer sizes to a power  of  two  to
        satisfy hardware alignment constraints.

    *   Automatic  pool compaction, growth, and shrinkage by
        means of call-backs to user defined functions.

    Applications  of  BGET  can  range    from  storage  management   in
    ROM-based  embedded programs to providing the framework upon which
    a  multitasking  system  incorporating   garbage   collection   is
    constructed.   BGET  incorporates  extensive  internal consistency
    checking using the <assert.h> mechanism; all these checks  can  be
    turned off by compiling with NDEBUG defined, yielding a version of
    BGET with minimal size and maximum speed.

    The  basic    algorithm  underlying  BGET  has withstood the test of
    time;  more  than  25  years   have   passed   since   the     first
    implementation  of    this  code.  And yet, it is substantially more
    efficient than the native allocation  schemes  of  many  operating
    systems: the Macintosh and Microsoft Windows to name two, on which
    programs have obtained substantial speed-ups by layering  BGET  as
    an application level memory manager atop the underlying system's.

    BGET has been implemented on the largest mainframes and the lowest
    of    microprocessors.   It  has served as the core for multitasking
    operating systems, multi-thread applications, embedded software in
    data  network switching processors, and a host of C programs.  And
    while it has accreted flexibility and additional options over  the
    years,  it    remains  fast, memory efficient, portable, and easy to
    integrate into your program.


    BGET IMPLEMENTATION ASSUMPTIONS
    ===============================

    BGET is written in as portable a dialect of C  as  possible.   The
    only   fundamental     assumption   about  the  underlying  hardware
    architecture is that memory is allocated is a linear  array  which
    can  be  addressed  as a vector of C "char" objects.  On segmented
    address space architectures, this generally means that BGET should
    be used to allocate storage within a single segment (although some
    compilers    simulate   linear   address   spaces   on    segmented
    architectures).   On  segmented  architectures,  then, BGET buffer
    pools  may not be larger than a segment, but since BGET allows any
    number of separate buffer pools, there is no limit    on  the  total
    storage  which  can  be  managed,  only  on the largest individual
    object which can be allocated.  Machines  with  a  linear  address
    architecture,  such  as  the VAX, 680x0, Sparc, MIPS, or the Intel
    80386 and above in native mode, may use BGET without restriction.


    GETTING STARTED WITH BGET
    =========================

    Although BGET can be configured in a multitude of fashions,  there
    are  three    basic  ways  of  working  with    BGET.    The  functions
    mentioned below are documented in the following  section.    Please
    excuse  the  forward  references which are made in the interest of
    providing a roadmap to guide you  to  the  BGET  functions  you're
    likely to need.

    Embedded Applications
    ---------------------

    Embedded applications  typically  have  a  fixed  area  of    memory
    dedicated  to  buffer  allocation (often in a separate RAM address
    space distinct from the ROM that contains  the  executable    code).
    To    use  BGET in such an environment, simply call bpool() with the
    start address and length of the buffer  pool  area    in  RAM,  then
    allocate  buffers  with  bget()  and  release  them  with  brel().
    Embedded applications with very limited RAM but abundant CPU speed
    may  benefit  by configuring BGET for BestFit allocation (which is
    usually not worth it in other environments).

    Malloc() Emulation
    ------------------

    If the C library malloc() function is too  slow,  not  present  in
    your  development environment (for example, an a native Windows or
    Macintosh program), or otherwise unsuitable, you  can  replace  it
    with  BGET.  Initially define a buffer pool of an appropriate size
    with bpool()--usually obtained by making a call to    the  operating
    system's  low-level  memory allocator.  Then allocate buffers with
    bget(), bgetz(), and bgetr() (the last two permit  the  allocation
    of    buffers initialised to zero and [inefficient] re-allocation of
    existing buffers for  compatibility  with  C  library  functions).
    Release buffers by calling brel().    If a buffer allocation request
    fails, obtain more storage from the underlying  operating  system,
    add it to the buffer pool by another call to bpool(), and continue
    execution.

    Automatic Storage Management
    ----------------------------

    You can use BGET as your application's native memory  manager  and
    implement  automatic  storage  pool  expansion,  contraction,  and
    optionally application-specific  memory  compaction  by  compiling
    BGET  with    the  BECtl  variable defined, then calling bectl() and
    supplying  functions  for  storage    compaction,  acquisition,  and
    release,  as  well as a standard pool expansion increment.    All of
    these functions are optional (although it doesn't make much  sense
    to    provide  a  release  function without an acquisition function,
    does it?).    Once the call-back functions have  been  defined  with
    bectl(),  you simply use bget() and brel() to allocate and release
    storage as before.    You can supply an  initial  buffer  pool  with
    bpool()  or  rely  on  automatic  allocation to acquire the entire
    pool.  When a call on  bget()  cannot  be  satisfied,  BGET  first
    checks  if    a compaction function has been supplied.  If so, it is
    called (with the space required to satisfy the allocation  request
    and a sequence number to allow the compaction routine to be called
    successively without looping).  If the compaction function is able
    to  free any storage (it needn't know whether the storage it freed
    was adequate) it should return a  nonzero  value,  whereupon  BGET
    will retry the allocation request and, if it fails again, call the
    compaction function again with the next-higher sequence number.

    If    the  compaction  function  returns zero, indicating failure to
    free space, or no compaction function is defined, BGET next  tests
    whether  a    non-NULL  allocation function was supplied to bectl().
    If so, that function is called with  an  argument  indicating  how
    many  bytes  of  additional  space are required.  This will be the
    standard pool expansion increment supplied in the call to  bectl()
    unless  the  original  bget()  call requested a buffer larger than
    this; buffers larger than the standard pool block can  be  managed
    "off  the books" by BGET in this mode.  If the allocation function
    succeeds in obtaining the storage, it returns a pointer to the new
    block  and    BGET  expands  the  buffer  pool;  if  it  fails,  the
    allocation request fails and returns NULL to  the  caller.     If  a
    non-NULL  release  function  is  supplied,    expansion blocks which
    become totally empty are released  to  the    global    free  pool  by
    passing their addresses to the release function.

    Equipped  with  appropriate  allocation,  release,    and compaction
    functions, BGET can be used as part of very  sophisticated    memory
    management     strategies,  including  garbage  collection.    (Note,
    however, that BGET is *not* a garbage  collector  by  itself,  and
    that  developing  such a system requires much additional logic and
    careful design of the application's memory allocation strategy.)


    BGET FUNCTION DESCRIPTIONS
    ==========================

    Functions implemented in this file (some are enabled by certain of
    the optional settings below):

        void bpool(void *buffer, bufsize len);

    Create a buffer pool of <len> bytes, using the storage starting at
    <buffer>.    You  can  call    bpool()  subsequently  to   contribute
    additional storage to the overall buffer pool.

        void *bget(bufsize size);

    Allocate  a  buffer of <size> bytes.  The address of the buffer is
    returned, or NULL if insufficient memory was available to allocate
    the buffer.

        void *bgetz(bufsize size);

    Allocate a buffer of <size> bytes and clear it to all zeroes.  The
    address of the buffer is returned, or NULL if insufficient    memory
    was available to allocate the buffer.

        void *bgetr(void *buffer, bufsize newsize);

    Reallocate a buffer previously allocated by bget(),  changing  its
    size  to  <newsize>  and  preserving  all  existing data.  NULL is
    returned if insufficient memory is    available  to  reallocate  the
    buffer, in which case the original buffer remains intact.

        void brel(void *buf);

    Return  the  buffer  <buf>, previously allocated by bget(), to the
    free space pool.

        void bectl(int (*compact)(bufsize sizereq, int sequence),
               void *(*acquire)(bufsize size),
               void (*release)(void *buf),
               bufsize pool_incr);

    Expansion control: specify functions through which the package may
    compact  storage  (or  take  other    appropriate  action)  when  an
    allocation    request  fails,  and  optionally automatically acquire
    storage for expansion blocks  when    necessary,  and  release  such
    blocks when they become empty.  If <compact> is non-NULL, whenever
    a buffer allocation request fails, the <compact> function will  be
    called with arguments specifying the number of bytes (total buffer
    size,  including  header  overhead)  required   to     satisfy   the
    allocation request, and a sequence number indicating the number of
    consecutive  calls    on  <compact>  attempting  to    satisfy   this
    allocation    request.   The sequence number is 1 for the first call
    on <compact> for a given allocation  request,  and    increments  on
    subsequent    calls,    permitting  the  <compact>  function  to  take
    increasingly dire measures in an attempt to free up  storage.   If
    the  <compact>  function  returns  a nonzero value, the allocation
    attempt is re-tried.  If <compact> returns 0 (as  it  must    if  it
    isn't  able  to  release  any  space  or add storage to the buffer
    pool), the allocation request fails, which can  trigger  automatic
    pool expansion if the <acquire> argument is non-NULL.  At the time
    the  <compact>  function  is  called,  the    state  of  the    buffer
    allocator  is  identical  to  that    at  the  moment the allocation
    request was made; consequently, the <compact>  function  may  call
    brel(), bpool(), bstats(), and/or directly manipulate  the    buffer
    pool  in  any  manner which would be valid were the application in
    control.  This does not, however, relieve the  <compact>  function
    of the need to ensure that whatever actions it takes do not change
    things   underneath  the  application  that  made  the  allocation
    request.  For example, a <compact> function that released a buffer
    in    the  process  of  being reallocated with bgetr() would lead to
    disaster.  Implementing a safe and effective  <compact>  mechanism
    requires  careful  design of an application's memory architecture,
    and cannot generally be easily retrofitted into existing code.

    If <acquire> is non-NULL, that function will be called whenever an
    allocation    request  fails.  If the <acquire> function succeeds in
    allocating the requested space and returns a pointer  to  the  new
    area,  allocation will proceed using the expanded buffer pool.  If
    <acquire> cannot obtain the requested space, it should return NULL
    and   the    entire    allocation  process  will  fail.   <pool_incr>
    specifies the normal expansion block size.    Providing an <acquire>
    function will cause subsequent bget()  requests  for  buffers  too
    large  to  be  managed in the linked-block scheme (in other words,
    larger than <pool_incr> minus the buffer overhead) to be satisfied
    directly by calls to the <acquire> function.  Automatic release of
    empty pool blocks will occur only if all pool blocks in the system
    are the size given by <pool_incr>.

        void bstats(bufsize *curalloc, bufsize *totfree,
            bufsize *maxfree, long *nget, long *nrel);

    The amount    of  space  currently  allocated  is  stored  into  the
    variable  pointed  to by <curalloc>.  The total free space (sum of
    all free blocks in the pool) is stored into the  variable  pointed
    to    by  <totfree>, and the size of the largest single block in the
    free space    pool  is  stored  into    the  variable  pointed    to  by
    <maxfree>.     The  variables  pointed  to  by <nget> and <nrel> are
    filled, respectively, with    the  number  of  successful  (non-NULL
    return) bget() calls and the number of brel() calls.

        void bstatse(bufsize *pool_incr, long *npool,
             long *npget, long *nprel,
             long *ndget, long *ndrel);

    Extended  statistics: The expansion block size will be stored into
    the variable pointed to by <pool_incr>, or the negative thereof if
    automatic  expansion  block  releases are disabled.  The number of
    currently active pool blocks will  be  stored  into  the  variable
    pointed  to  by  <npool>.  The variables pointed to by <npget> and
    <nprel> will be filled with, respectively, the number of expansion
    block   acquisitions   and    releases  which  have  occurred.   The
    variables pointed to by <ndget> and <ndrel> will  be  filled  with
    the  number  of  bget()  and  brel()  calls, respectively, managed
    through blocks directly allocated by the acquisition  and  release
    functions.

        void bufdump(void *buf);

    The buffer pointed to by <buf> is dumped on standard output.

        void bpoold(void *pool, int dumpalloc, int dumpfree);

    All buffers in the buffer pool <pool>, previously initialised by a
    call on bpool(), are listed in ascending memory address order.  If
    <dumpalloc> is nonzero, the  contents  of  allocated  buffers  are
    dumped;  if <dumpfree> is nonzero, the contents of free blocks are
    dumped.

        int bpoolv(void *pool);

    The  named    buffer    pool,  previously  initialised    by  a  call on
    bpool(), is validated for bad pointers, overwritten data, etc.  If
    compiled with NDEBUG not defined, any error generates an assertion
    failure.  Otherwise 1 is returned if the pool is valid,  0    if  an
    error is found.


    BGET CONFIGURATION
    ==================
*/

#if 0
#define TestProg    20000          /* Generate built-in test program
                     if defined.  The value specifies
                     how many buffer allocation attempts
                     the test program should make. */
#endif
#define SizeQuant   4              /* Buffer allocation size quantum:
                     all buffers allocated are a
                     multiple of this size.  This
                     MUST be a power of two. */
#if 0
#define BufDump     1              /* Define this symbol to enable the
                     bpoold() function which dumps the
                     buffers in a buffer pool. */

#define BufValid    1              /* Define this symbol to enable the
                     bpoolv() function for validating
                     a buffer pool. */

#define DumpData    1              /* Define this symbol to enable the
                     bufdump() function which allows
                     dumping the contents of an allocated
                     or free buffer. */

#define BufStats    1              /* Define this symbol to enable the
                     bstats() function which calculates
                     the total free space in the buffer
                     pool, the largest available
                     buffer, and the total space
                     currently allocated. */

#define FreeWipe    1              /* Wipe free buffers to a guaranteed
                     pattern of garbage to trip up
                     miscreants who attempt to use
                     pointers into released buffers. */

#define BestFit     1              /* Use a best fit algorithm when
                     searching for space for an
                     allocation request.  This uses
                     memory more efficiently, but
                     allocation will be much slower. */
#endif
#define BECtl        1              /* Define this symbol to enable the
                     bectl() function for automatic
                     pool space control.  */

#include <stdio.h>

#ifdef lint
#define NDEBUG                  /* Exits in asserts confuse lint */
/* LINTLIBRARY */                     /* Don't complain about def, no ref */
extern char *sprintf();               /* Sun includes don't define sprintf */
#endif

#include <assert.h>
#include <memory.h>

#ifdef BufDump                  /* BufDump implies DumpData */
#ifndef DumpData
#define DumpData    1
#endif
#endif

#ifdef DumpData
#include <ctype.h>
#endif

/*  Declare the interface, including the requested buffer size type,
    bufsize.  */

#include "bget.h"

#define MemSize     int           /* Type for size arguments to memxxx()
                     functions such as memcmp(). */

/* Queue links */

struct qlinks {
    struct bfhead *flink;          /* Forward link */
    struct bfhead *blink;          /* Backward link */
};

/* Header in allocated and free buffers */

struct bhead {
    bufsize prevfree;              /* Relative link back to previous
                     free buffer in memory or 0 if
                     previous buffer is allocated.    */
    bufsize bsize;              /* Buffer size: positive if free,
                     negative if allocated. */
};
#define BH(p)    ((struct bhead *) (p))

/*  Header in directly allocated buffers (by acqfcn) */

struct bdhead {
    bufsize tsize;              /* Total size, including overhead */
    struct bhead bh;              /* Common header */
};
#define BDH(p)    ((struct bdhead *) (p))

/* Header in free buffers */

struct bfhead {
    struct bhead bh;              /* Common allocated/free header */
    struct qlinks ql;              /* Links on free list */
};
#define BFH(p)    ((struct bfhead *) (p))

static struct bfhead freelist = {     /* List of free buffers */
    {0, 0},
    {&freelist, &freelist}
};


#ifdef BufStats
static bufsize totalloc = 0;          /* Total space currently allocated */
static long numget = 0, numrel = 0;   /* Number of bget() and brel() calls */
#ifdef BECtl
static long numpblk = 0;          /* Number of pool blocks */
static long numpget = 0, numprel = 0; /* Number of block gets and rels */
static long numdget = 0, numdrel = 0; /* Number of direct gets and rels */
#endif /* BECtl */
#endif /* BufStats */

#ifdef BECtl

/* Automatic expansion block management functions */

static int (*compfcn) _((bufsize sizereq, int sequence)) = NULL;
static void *(*acqfcn) _((bufsize size)) = NULL;
static void (*relfcn) _((void *buf)) = NULL;

static bufsize exp_incr = 0;          /* Expansion block size */
static bufsize pool_len = 0;          /*  0: no bpool calls have been made
                                       * -1: not all pool blocks are
                                       *     the same size
                                       * >0: (common) block size for all
                                       *     bpool calls made so far
                                       */
#endif

/*  Minimum allocation quantum: */

#define QLSize    (sizeof(struct qlinks))
#define SizeQ    ((SizeQuant > QLSize) ? SizeQuant : QLSize)

#define V   (void)              /* To denote unwanted returned values */

/* End sentinel: value placed in bsize field of dummy block delimiting
   end of pool block.  The most negative number which will  fit  in  a
   bufsize, defined in a way that the compiler will accept. */

#define ESent    ((bufsize) (-(((1L << (sizeof(bufsize) * 8 - 2)) - 1) * 2) - 2))

/*  BGET  --  Allocate a buffer.  */

void *bget(requested_size)
bufsize requested_size;
{
    bufsize size = requested_size;
    struct bfhead *b;
#ifdef BestFit
    struct bfhead *best;
#endif
    void *buf;
#ifdef BECtl
    int compactseq = 0;
#endif

    assert(size > 0);

    if (size < (bufsize)SizeQ) {           /* Need at least room for the */
        size = SizeQ;              /*    queue links.  */
    }
#ifdef SizeQuant
#if SizeQuant > 1
    size = (size + (SizeQuant - 1)) & (~(SizeQuant - 1));
#endif
#endif

    size += sizeof(struct bhead);     /* Add overhead in allocated buffer
                                       * to size required.
                                       */

#ifdef BECtl
    /* If a compact function was provided in the call to bectl(), wrap
     * a loop around the allocation process  to  allow    compaction  to
     * intervene in case we don't find a suitable buffer in the chain.
     */

    while (1) {
#endif
        b = freelist.ql.flink;
#ifdef BestFit
        best = &freelist;
#endif


        /* Scan the free list searching for the first buffer big enough
       to hold the requested size buffer. */

#ifdef BestFit
        while (b != &freelist) {
            if (b->bh.bsize >= size) {
                if ((best == &freelist) || (b->bh.bsize < best->bh.bsize)) {
                    best = b;
                }
            }
            b = b->ql.flink;          /* Link to next buffer */
        }
        b = best;
#endif /* BestFit */

        while (b != &freelist) {
            if ((bufsize) b->bh.bsize >= size) {

                /* Buffer  is big enough to satisfy  the request.  Allocate it
                 * to the caller.  We must decide whether the buffer is  large
                 * enough  to  split  into  the part given to the caller and a
                 * free buffer that remains on the free list, or  whether  the
                 * entire  buffer  should  be  removed from the free list and
                 * given to the caller in its entirety.  We  only  split  the
                 * buffer if enough room remains for a header plus the minimum
                 * quantum of allocation.
                 */

                if ((b->bh.bsize - size) > (bufsize)(SizeQ + (sizeof(struct bhead)))) {
                    struct bhead *ba, *bn;

                    ba = BH(((char *) b) + (b->bh.bsize - size));
                    bn = BH(((char *) ba) + size);
                    assert(bn->prevfree == b->bh.bsize);
                    /* Subtract size from length of free block. */
                    b->bh.bsize -= size;
                    /* Link allocated buffer to the previous free buffer. */
                    ba->prevfree = b->bh.bsize;
                    /* Plug negative size into user buffer. */
                    ba->bsize = -(bufsize) size;
                    /* Mark buffer after this one not preceded by free block. */
                    bn->prevfree = 0;

#ifdef BufStats
                    totalloc += size;
                    numget++;          /* Increment number of bget() calls */
#endif
                    buf = (void *) ((((char *) ba) + sizeof(struct bhead)));
                    return buf;
                } else {
                    struct bhead *ba;

                    ba = BH(((char *) b) + b->bh.bsize);
                    assert(ba->prevfree == b->bh.bsize);

                    /* The buffer isn't big enough to split.  Give  the  whole
                     * shebang to the caller and remove it from the free list.
                     */

                    assert(b->ql.blink->ql.flink == b);
                    assert(b->ql.flink->ql.blink == b);
                    b->ql.blink->ql.flink = b->ql.flink;
                    b->ql.flink->ql.blink = b->ql.blink;

#ifdef BufStats
                    totalloc += b->bh.bsize;
                    numget++;          /* Increment number of bget() calls */
#endif
                    /* Negate size to mark buffer allocated. */
                    b->bh.bsize = -(b->bh.bsize);

                    /* Zero the back pointer in the next buffer in memory
                     * to indicate that this buffer is allocated.
                     */
                    ba->prevfree = 0;

                    /* Give user buffer starting at queue links. */
                    buf =  (void *) &(b->ql);
                    return buf;
                }
            }
            b = b->ql.flink;          /* Link to next buffer */
        }
#ifdef BECtl

        /* We failed to find a buffer.  If there's a compact  function
         * defined,  notify  it  of the size requested.  If it returns
         * TRUE, try the allocation again.
         */

        if ((compfcn == NULL) || (!(*compfcn)(size, ++compactseq))) {
            break;
        }
    }

    /* No buffer available with requested size free. */

    /* Don't give up yet -- look in the reserve supply. */

    if (acqfcn != NULL) {
        if (size > (bufsize)(exp_incr - sizeof(struct bhead))) {

            /* Request    is  too  large    to  fit in a single expansion
             * block.  Try to satisy it by a direct buffer acquisition.
             */
            struct bdhead *bdh;

            size += sizeof(struct bdhead) - sizeof(struct bhead);
            if ((bdh = BDH((*acqfcn)((bufsize) size))) != NULL) {

                /*  Mark the buffer special by setting the size field
                 *  of its header to zero.
                 */
                bdh->bh.bsize = 0;
                bdh->bh.prevfree = 0;
                bdh->tsize = size;
#ifdef BufStats
                totalloc += size;
                numget++;          /* Increment number of bget() calls */
                numdget++;          /* Direct bget() call count */
#endif
                buf =  (void *) (bdh + 1);
                return buf;
            }

        } else {

            /*    Try to obtain a new expansion block */

            void *newpool;

            if ((newpool = (*acqfcn)((bufsize) exp_incr)) != NULL) {
                bpool(newpool, exp_incr);
                buf =  bget(requested_size);  /* This can't, I say, can't
                                               * get into a loop.
                                               */
                return buf;
            }
        }
    }

    /*    Still no buffer available */

#endif /* BECtl */

    return NULL;
}

/*  BGETZ  --  Allocate a buffer and clear its contents to zero.  We clear
           the  entire  contents  of  the buffer to zero, not just the
           region requested by the caller. */

void *bgetz(size)
  bufsize size;
{
    char *buf = (char *) bget(size);

    if (buf != NULL) {
    struct bhead *b;
    bufsize rsize;

    b = BH(buf - sizeof(struct bhead));
    rsize = -(b->bsize);
    if (rsize == 0) {
        struct bdhead *bd;

        bd = BDH(buf - sizeof(struct bdhead));
        rsize = bd->tsize - sizeof(struct bdhead);
    } else {
        rsize -= sizeof(struct bhead);
    }
    assert(rsize >= size);
    V memset(buf, 0, (MemSize) rsize);
    }
    return ((void *) buf);
}

/*  BGETR  --  Reallocate a buffer.  This is a minimal implementation,
           simply in terms of brel()  and  bget().     It  could  be
           enhanced to allow the buffer to grow into adjacent free
           blocks and to avoid moving data unnecessarily.  */

void *bgetr(buf, size)
  void *buf;
  bufsize size;
{
    void *nbuf;
    bufsize osize;              /* Old size of buffer */
    struct bhead *b;

    if ((nbuf = bget(size)) == NULL) { /* Acquire new buffer */
        return NULL;
    }
    if (buf == NULL) {
        return nbuf;
    }
    b = BH(((char *) buf) - sizeof(struct bhead));
    osize = -b->bsize;
#ifdef BECtl
    if (osize == 0) {
        /*  Buffer acquired directly through acqfcn. */
        struct bdhead *bd;

        bd = BDH(((char *) buf) - sizeof(struct bdhead));
        osize = bd->tsize - sizeof(struct bdhead);
    } else
#endif
        osize -= sizeof(struct bhead);
    assert(osize > 0);
    V memcpy((char *) nbuf, (char *) buf, /* Copy the data */
            (MemSize) ((size < osize) ? size : osize));

    brel(buf);
    return nbuf;
}

/*  BREL  --  Release a buffer.  */

void brel(buf)
  void *buf;
{
    struct bfhead *b, *bn;

    assert(buf != NULL);
    b = BFH(((char *) buf) - sizeof(struct bhead));
#ifdef BufStats
    numrel++;                  /* Increment number of brel() calls */
#endif

#ifdef BECtl
    if (b->bh.bsize == 0) {          /* Directly-acquired buffer? */
    struct bdhead *bdh;

    bdh = BDH(((char *) buf) - sizeof(struct bdhead));
    assert(b->bh.prevfree == 0);
#ifdef BufStats
    totalloc -= bdh->tsize;
    assert(totalloc >= 0);
    numdrel++;              /* Number of direct releases */
#endif /* BufStats */
#ifdef FreeWipe
    V memset((char *) buf, 0x55,
         (MemSize) (bdh->tsize - sizeof(struct bdhead)));
#endif /* FreeWipe */
    assert(relfcn != NULL);
    (*relfcn)((void *) bdh);      /* Release it directly. */
    return;
    }
#endif /* BECtl */

    /* Buffer size must be negative, indicating that the buffer is
       allocated. */

    if (b->bh.bsize >= 0) {
    bn = NULL;
    }
    assert(b->bh.bsize < 0);

    /*    Back pointer in next buffer must be zero, indicating the
    same thing: */

    assert(BH((char *) b - b->bh.bsize)->prevfree == 0);

#ifdef BufStats
    totalloc += b->bh.bsize;
    assert(totalloc >= 0);
#endif

    /* If the back link is nonzero, the previous buffer is free.  */

    if (b->bh.prevfree != 0) {

    /* The previous buffer is free.  Consolidate this buffer  with    it
       by  adding  the  length  of    this  buffer  to the previous free
       buffer.  Note that we subtract the size  in    the  buffer  being
           released,  since  it's  negative to indicate that the buffer is
       allocated. */

    register bufsize size = b->bh.bsize;

        /* Make the previous buffer the one we're working on. */
    assert(BH((char *) b - b->bh.prevfree)->bsize == b->bh.prevfree);
    b = BFH(((char *) b) - b->bh.prevfree);
    b->bh.bsize -= size;
    } else {

        /* The previous buffer isn't allocated.  Insert this buffer
       on the free list as an isolated free block. */

    assert(freelist.ql.blink->ql.flink == &freelist);
    assert(freelist.ql.flink->ql.blink == &freelist);
    b->ql.flink = &freelist;
    b->ql.blink = freelist.ql.blink;
    freelist.ql.blink = b;
    b->ql.blink->ql.flink = b;
    b->bh.bsize = -b->bh.bsize;
    }

    /* Now we look at the next buffer in memory, located by advancing from
       the  start  of  this  buffer  by its size, to see if that buffer is
       free.  If it is, we combine  this  buffer  with    the  next  one    in
       memory, dechaining the second buffer from the free list. */

    bn =  BFH(((char *) b) + b->bh.bsize);
    if (bn->bh.bsize > 0) {

    /* The buffer is free.    Remove it from the free list and add
       its size to that of our buffer. */

    assert(BH((char *) bn + bn->bh.bsize)->prevfree == bn->bh.bsize);
    assert(bn->ql.blink->ql.flink == bn);
    assert(bn->ql.flink->ql.blink == bn);
    bn->ql.blink->ql.flink = bn->ql.flink;
    bn->ql.flink->ql.blink = bn->ql.blink;
    b->bh.bsize += bn->bh.bsize;

    /* Finally,  advance  to   the    buffer    that   follows    the  newly
       consolidated free block.  We must set its  backpointer  to  the
       head  of  the  consolidated free block.  We know the next block
       must be an allocated block because the process of recombination
       guarantees  that  two  free    blocks will never be contiguous in
       memory.  */

    bn = BFH(((char *) b) + b->bh.bsize);
    }
#ifdef FreeWipe
    V memset(((char *) b) + sizeof(struct bfhead), 0x55,
        (MemSize) (b->bh.bsize - sizeof(struct bfhead)));
#endif
    assert(bn->bh.bsize < 0);

    /* The next buffer is allocated.  Set the backpointer in it  to  point
       to this buffer; the previous free buffer in memory. */

    bn->bh.prevfree = b->bh.bsize;

#ifdef BECtl

    /*    If  a  block-release function is defined, and this free buffer
    constitutes the entire block, release it.  Note that  pool_len
    is  defined  in  such a way that the test will fail unless all
    pool blocks are the same size.    */

    if (relfcn != NULL &&
            b->bh.bsize == (bufsize)(pool_len - sizeof(struct bhead))) {

    assert(b->bh.prevfree == 0);
    assert(BH((char *) b + b->bh.bsize)->bsize == ESent);
    assert(BH((char *) b + b->bh.bsize)->prevfree == b->bh.bsize);
    /*  Unlink the buffer from the free list  */
    b->ql.blink->ql.flink = b->ql.flink;
    b->ql.flink->ql.blink = b->ql.blink;

    (*relfcn)(b);
#ifdef BufStats
    numprel++;              /* Nr of expansion block releases */
    numpblk--;              /* Total number of blocks */
    assert(numpblk == numpget - numprel);
#endif /* BufStats */
    }
#endif /* BECtl */
}

#ifdef BECtl

/*  BECTL  --  Establish automatic pool expansion control  */

void bectl(compact, acquire, release, pool_incr)
  int (*compact) _((bufsize sizereq, int sequence));
  void *(*acquire) _((bufsize size));
  void (*release) _((void *buf));
  bufsize pool_incr;
{
    compfcn = compact;
    acqfcn = acquire;
    relfcn = release;
    exp_incr = pool_incr;
}
#endif

/*  BPOOL  --  Add a region of memory to the buffer pool.  */

void bpool(buf, len)
  void *buf;
  bufsize len;
{
    struct bfhead *b = BFH(buf);
    struct bhead *bn;

#ifdef SizeQuant
    len &= ~(SizeQuant - 1);
#endif
#ifdef BECtl
    if (pool_len == 0) {
    pool_len = len;
    } else if (len != pool_len) {
    pool_len = -1;
    }
#ifdef BufStats
    numpget++;                  /* Number of block acquisitions */
    numpblk++;                  /* Number of blocks total */
    assert(numpblk == numpget - numprel);
#endif /* BufStats */
#endif /* BECtl */

    /* Since the block is initially occupied by a single free  buffer,
       it  had    better    not  be  (much) larger than the largest buffer
       whose size we can store in bhead.bsize. */

    assert(len - sizeof(struct bhead) <= -((bufsize) ESent + 1));

    /* Clear  the  backpointer at  the start of the block to indicate that
       there  is  no  free  block  prior  to  this   one.    That   blocks
       recombination when the first block in memory is released. */

    b->bh.prevfree = 0;

    /* Chain the new block to the free list. */

    assert(freelist.ql.blink->ql.flink == &freelist);
    assert(freelist.ql.flink->ql.blink == &freelist);
    b->ql.flink = &freelist;
    b->ql.blink = freelist.ql.blink;
    freelist.ql.blink = b;
    b->ql.blink->ql.flink = b;

    /* Create a dummy allocated buffer at the end of the pool.    This dummy
       buffer is seen when a buffer at the end of the pool is released and
       blocks  recombination  of  the last buffer with the dummy buffer at
       the end.  The length in the dummy buffer  is  set  to  the  largest
       negative  number  to  denote  the  end  of  the pool for diagnostic
       routines (this specific value is  not  counted  on  by  the  actual
       allocation and release functions). */

    len -= sizeof(struct bhead);
    b->bh.bsize = (bufsize) len;
#ifdef FreeWipe
    V memset(((char *) b) + sizeof(struct bfhead), 0x55,
         (MemSize) (len - sizeof(struct bfhead)));
#endif
    bn = BH(((char *) b) + len);
    bn->prevfree = (bufsize) len;
    /* Definition of ESent assumes two's complement! */
    assert((~0) == -1);
    bn->bsize = ESent;
}

#ifdef BufStats

/*  BSTATS  --    Return buffer allocation free space statistics.  */

void bstats(curalloc, totfree, maxfree, nget, nrel)
  bufsize *curalloc, *totfree, *maxfree;
  long *nget, *nrel;
{
    struct bfhead *b = freelist.ql.flink;

    *nget = numget;
    *nrel = numrel;
    *curalloc = totalloc;
    *totfree = 0;
    *maxfree = -1;
    while (b != &freelist) {
    assert(b->bh.bsize > 0);
    *totfree += b->bh.bsize;
    if (b->bh.bsize > *maxfree) {
        *maxfree = b->bh.bsize;
    }
    b = b->ql.flink;          /* Link to next buffer */
    }
}

#ifdef BECtl

/*  BSTATSE  --  Return extended statistics  */

void bstatse(pool_incr, npool, npget, nprel, ndget, ndrel)
  bufsize *pool_incr;
  long *npool, *npget, *nprel, *ndget, *ndrel;
{
    *pool_incr = (pool_len < 0) ? -exp_incr : exp_incr;
    *npool = numpblk;
    *npget = numpget;
    *nprel = numprel;
    *ndget = numdget;
    *ndrel = numdrel;
}
#endif /* BECtl */
#endif /* BufStats */

#ifdef DumpData

/*  BUFDUMP  --  Dump the data in a buffer.  This is called with the  user
         data pointer, and backs up to the buffer header.  It will
         dump either a free block or an allocated one.    */

void bufdump(buf)
  void *buf;
{
    struct bfhead *b;
    unsigned char *bdump;
    bufsize bdlen;

    b = BFH(((char *) buf) - sizeof(struct bhead));
    assert(b->bh.bsize != 0);
    if (b->bh.bsize < 0) {
    bdump = (unsigned char *) buf;
    bdlen = (-b->bh.bsize) - sizeof(struct bhead);
    } else {
    bdump = (unsigned char *) (((char *) b) + sizeof(struct bfhead));
    bdlen = b->bh.bsize - sizeof(struct bfhead);
    }

    while (bdlen > 0) {
    int i, dupes = 0;
    bufsize l = bdlen;
    char bhex[50], bascii[20];

    if (l > 16) {
        l = 16;
    }

    for (i = 0; i < l; i++) {
            V sprintf(bhex + i * 3, "%02X ", bdump[i]);
            bascii[i] = isprint(bdump[i]) ? bdump[i] : ' ';
    }
    bascii[i] = 0;
        V printf("%-48s   %s\n", bhex, bascii);
    bdump += l;
    bdlen -= l;
    while ((bdlen > 16) && (memcmp((char *) (bdump - 16),
                       (char *) bdump, 16) == 0)) {
        dupes++;
        bdump += 16;
        bdlen -= 16;
    }
    if (dupes > 1) {
        V printf(
                "     (%d lines [%d bytes] identical to above line skipped)\n",
        dupes, dupes * 16);
    } else if (dupes == 1) {
        bdump -= 16;
        bdlen += 16;
    }
    }
}
#endif

#ifdef BufDump

/*  BPOOLD  --    Dump a buffer pool.  The buffer headers are always listed.
        If DUMPALLOC is nonzero, the contents of allocated buffers
        are  dumped.   If  DUMPFREE  is  nonzero,  free blocks are
        dumped as well.  If FreeWipe  checking    is  enabled,  free
        blocks    which  have  been clobbered will always be dumped. */

void bpoold(buf, dumpalloc, dumpfree)
  void *buf;
  int dumpalloc, dumpfree;
{
    struct bfhead *b = BFH(buf);

    while (b->bh.bsize != ESent) {
    bufsize bs = b->bh.bsize;

    if (bs < 0) {
        bs = -bs;
            V printf("Allocated buffer: size %6ld bytes.\n", (long) bs);
        if (dumpalloc) {
        bufdump((void *) (((char *) b) + sizeof(struct bhead)));
        }
    } else {
            char *lerr = "";

        assert(bs > 0);
        if ((b->ql.blink->ql.flink != b) ||
        (b->ql.flink->ql.blink != b)) {
                lerr = "  (Bad free list links)";
        }
            V printf("Free block:       size %6ld bytes.%s\n",
        (long) bs, lerr);
#ifdef FreeWipe
        lerr = ((char *) b) + sizeof(struct bfhead);
        if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) ||
        (memcmp(lerr, lerr + 1,
          (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) {
        V printf(
                    "(Contents of above free block have been overstored.)\n");
        bufdump((void *) (((char *) b) + sizeof(struct bhead)));
        } else
#endif
        if (dumpfree) {
        bufdump((void *) (((char *) b) + sizeof(struct bhead)));
        }
    }
    b = BFH(((char *) b) + bs);
    }
}
#endif /* BufDump */

#ifdef BufValid

/*  BPOOLV  --  Validate a buffer pool.  If NDEBUG isn't defined,
        any error generates an assertion failure.  */

int bpoolv(buf)
  void *buf;
{
    struct bfhead *b = BFH(buf);

    while (b->bh.bsize != ESent) {
    bufsize bs = b->bh.bsize;

    if (bs < 0) {
        bs = -bs;
    } else {
            char *lerr = "";

        assert(bs > 0);
        if (bs <= 0) {
        return 0;
        }
        if ((b->ql.blink->ql.flink != b) ||
        (b->ql.flink->ql.blink != b)) {
                V printf("Free block: size %6ld bytes.  (Bad free list links)\n",
             (long) bs);
        assert(0);
        return 0;
        }
#ifdef FreeWipe
        lerr = ((char *) b) + sizeof(struct bfhead);
        if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) ||
        (memcmp(lerr, lerr + 1,
          (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) {
        V printf(
                    "(Contents of above free block have been overstored.)\n");
        bufdump((void *) (((char *) b) + sizeof(struct bhead)));
        assert(0);
        return 0;
        }
#endif
    }
    b = BFH(((char *) b) + bs);
    }
    return 1;
}
#endif /* BufValid */

        /***********************\
    *            *
    * Built-in test program *
    *            *
        \***********************/

#ifdef TestProg

#define Repeatable  1              /* Repeatable pseudorandom sequence */
                      /* If Repeatable is not defined, a
                     time-seeded pseudorandom sequence
                     is generated, exercising BGET with
                     a different pattern of calls on each
                     run. */
#define OUR_RAND              /* Use our own built-in version of
                     rand() to guarantee the test is
                     100% repeatable. */

#ifdef BECtl
#define PoolSize    300000          /* Test buffer pool size */
#else
#define PoolSize    50000          /* Test buffer pool size */
#endif
#define ExpIncr     32768          /* Test expansion block size */
#define CompactTries 10           /* Maximum tries at compacting */

#define dumpAlloc   0              /* Dump allocated buffers ? */
#define dumpFree    0              /* Dump free buffers ? */

#ifndef Repeatable
extern long time();
#endif

extern char *malloc();
extern int free _((char *));

static char *bchain = NULL;          /* Our private buffer chain */
static char *bp = NULL;           /* Our initial buffer pool */

#include <math.h>

#ifdef OUR_RAND

static unsigned long int next = 1;

/* Return next random integer */

int rand()
{
    next = next * 1103515245L + 12345;
    return (unsigned int) (next / 65536L) % 32768L;
}

/* Set seed for random generator */

void srand(seed)
  unsigned int seed;
{
    next = seed;
}
#endif

/*  STATS  --  Edit statistics returned by bstats() or bstatse().  */

static void stats(when)
  char *when;
{
    bufsize cural, totfree, maxfree;
    long nget, nfree;
#ifdef BECtl
    bufsize pincr;
    long totblocks, npget, nprel, ndget, ndrel;
#endif

    bstats(&cural, &totfree, &maxfree, &nget, &nfree);
    V printf(
        "%s: %ld gets, %ld releases.  %ld in use, %ld free, largest = %ld\n",
    when, nget, nfree, (long) cural, (long) totfree, (long) maxfree);
#ifdef BECtl
    bstatse(&pincr, &totblocks, &npget, &nprel, &ndget, &ndrel);
    V printf(
         "  Blocks: size = %ld, %ld (%ld bytes) in use, %ld gets, %ld frees\n",
     (long)pincr, totblocks, pincr * totblocks, npget, nprel);
    V printf("  %ld direct gets, %ld direct frees\n", ndget, ndrel);
#endif /* BECtl */
}

#ifdef BECtl
static int protect = 0;           /* Disable compaction during bgetr() */

/*  BCOMPACT  --  Compaction call-back function.  */

static int bcompact(bsize, seq)
  bufsize bsize;
  int seq;
{
#ifdef CompactTries
    char *bc = bchain;
    int i = rand() & 0x3;

#ifdef COMPACTRACE
    V printf("Compaction requested.  %ld bytes needed, sequence %d.\n",
    (long) bsize, seq);
#endif

    if (protect || (seq > CompactTries)) {
#ifdef COMPACTRACE
        V printf("Compaction gave up.\n");
#endif
    return 0;
    }

    /* Based on a random cast, release a random buffer in the list
       of allocated buffers. */

    while (i > 0 && bc != NULL) {
    bc = *((char **) bc);
    i--;
    }
    if (bc != NULL) {
    char *fb;

    fb = *((char **) bc);
    if (fb != NULL) {
        *((char **) bc) = *((char **) fb);
        brel((void *) fb);
        return 1;
    }
    }

#ifdef COMPACTRACE
    V printf("Compaction bailed out.\n");
#endif
#endif /* CompactTries */
    return 0;
}

/*  BEXPAND  --  Expand pool call-back function.  */

static void *bexpand(size)
  bufsize size;
{
    void *np = NULL;
    bufsize cural, totfree, maxfree;
    long nget, nfree;

    /* Don't expand beyond the total allocated size given by PoolSize. */

    bstats(&cural, &totfree, &maxfree, &nget, &nfree);

    if (cural < PoolSize) {
    np = (void *) malloc((unsigned) size);
    }
#ifdef EXPTRACE
    V printf("Expand pool by %ld -- %s.\n", (long) size,
        np == NULL ? "failed" : "succeeded");
#endif
    return np;
}

/*  BSHRINK  --  Shrink buffer pool call-back function.  */

static void bshrink(buf)
  void *buf;
{
    if (((char *) buf) == bp) {
#ifdef EXPTRACE
        V printf("Initial pool released.\n");
#endif
    bp = NULL;
    }
#ifdef EXPTRACE
    V printf("Shrink pool.\n");
#endif
    free((char *) buf);
}

#endif /* BECtl */

/*  Restrict buffer requests to those large enough to contain our pointer and
    small enough for the CPU architecture.  */

static bufsize blimit(bs)
  bufsize bs;
{
    if (bs < sizeof(char *)) {
    bs = sizeof(char *);
    }

    /* This is written out in this ugly fashion because the
       cool expression in sizeof(int) that auto-configured
       to any length int befuddled some compilers. */

    if (sizeof(int) == 2) {
    if (bs > 32767) {
        bs = 32767;
    }
    } else {
    if (bs > 200000) {
        bs = 200000;
    }
    }
    return bs;
}

int main()
{
    int i;
    double x;

    /* Seed the random number generator.  If Repeatable is defined, we
       always use the same seed.  Otherwise, we seed from the clock to
       shake things up from run to run. */

#ifdef Repeatable
    V srand(1234);
#else
    V srand((int) time((long *) NULL));
#endif

    /*    Compute x such that pow(x, p) ranges between 1 and 4*ExpIncr as
    p ranges from 0 to ExpIncr-1, with a concentration in the lower
    numbers.  */

    x = 4.0 * ExpIncr;
    x = log(x);
    x = exp(log(4.0 * ExpIncr) / (ExpIncr - 1.0));

#ifdef BECtl
    bectl(bcompact, bexpand, bshrink, (bufsize) ExpIncr);
    bp = malloc(ExpIncr);
    assert(bp != NULL);
    bpool((void *) bp, (bufsize) ExpIncr);
#else
    bp = malloc(PoolSize);
    assert(bp != NULL);
    bpool((void *) bp, (bufsize) PoolSize);
#endif

    stats("Create pool");
    V bpoolv((void *) bp);
    bpoold((void *) bp, dumpAlloc, dumpFree);

    for (i = 0; i < TestProg; i++) {
    char *cb;
    bufsize bs = pow(x, (double) (rand() & (ExpIncr - 1)));

    assert(bs <= (((bufsize) 4) * ExpIncr));
    bs = blimit(bs);
    if (rand() & 0x400) {
        cb = (char *) bgetz(bs);
    } else {
        cb = (char *) bget(bs);
    }
    if (cb == NULL) {
#ifdef EasyOut
        break;
#else
        char *bc = bchain;

        if (bc != NULL) {
        char *fb;

        fb = *((char **) bc);
        if (fb != NULL) {
            *((char **) bc) = *((char **) fb);
            brel((void *) fb);
        }
        continue;
        }
#endif
    }
    *((char **) cb) = (char *) bchain;
    bchain = cb;

    /* Based on a random cast, release a random buffer in the list
       of allocated buffers. */

    if ((rand() & 0x10) == 0) {
        char *bc = bchain;
        int i = rand() & 0x3;

        while (i > 0 && bc != NULL) {
        bc = *((char **) bc);
        i--;
        }
        if (bc != NULL) {
        char *fb;

        fb = *((char **) bc);
        if (fb != NULL) {
            *((char **) bc) = *((char **) fb);
            brel((void *) fb);
        }
        }
    }

    /* Based on a random cast, reallocate a random buffer in the list
       to a random size */

    if ((rand() & 0x20) == 0) {
        char *bc = bchain;
        int i = rand() & 0x3;

        while (i > 0 && bc != NULL) {
        bc = *((char **) bc);
        i--;
        }
        if (bc != NULL) {
        char *fb;

        fb = *((char **) bc);
        if (fb != NULL) {
            char *newb;

            bs = pow(x, (double) (rand() & (ExpIncr - 1)));
            bs = blimit(bs);
#ifdef BECtl
            protect = 1;      /* Protect against compaction */
#endif
            newb = (char *) bgetr((void *) fb, bs);
#ifdef BECtl
            protect = 0;
#endif
            if (newb != NULL) {
            *((char **) bc) = newb;
            }
        }
        }
    }
    }
    stats("\nAfter allocation");
    if (bp != NULL) {
    V bpoolv((void *) bp);
    bpoold((void *) bp, dumpAlloc, dumpFree);
    }

    while (bchain != NULL) {
    char *buf = bchain;

    bchain = *((char **) buf);
    brel((void *) buf);
    }
    stats("\nAfter release");
#ifndef BECtl
    if (bp != NULL) {
    V bpoolv((void *) bp);
    bpoold((void *) bp, dumpAlloc, dumpFree);
    }
#endif

    return 0;
}
#endif