src/glu/sgi/libnurbs/internals/bufpool.h

   1 /*
   2  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   3  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice including the dates of first publication and
  13  * either this permission notice or a reference to
  14  * http://oss.sgi.com/projects/FreeB/
  15  * shall be included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  26  * shall not be used in advertising or otherwise to promote the sale, use or
  27  * other dealings in this Software without prior written authorization from
  28  * Silicon Graphics, Inc.
  29  */
  30
  31 /*
  32  * bufpool.h
  33  *
  34  */
  35
  36 #ifndef __glubufpool_h_
  37 #define __glubufpool_h_
  38
  39 #include "gluos.h"
  40 #include "myassert.h"
  41 #include "mystdlib.h"
  42
  43 #define NBLOCKS 32
  44
  45 class Buffer {
  46         friend class    Pool;
  47         Buffer  *       next;           /* next buffer on free list     */
  48 };
  49
  50 class Pool {
  51 public:
  52                         Pool( int, int, const char * );
  53                         ~Pool( void );
  54     inline void*        new_buffer( void );
  55     inline void         free_buffer( void * );
  56     void                clear( void );
  57
  58 private:
  59     void                grow( void );
  60
  61 protected:
  62     Buffer              *freelist;              /* linked list of free buffers */
  63     char                *blocklist[NBLOCKS];    /* blocks of malloced memory */
  64     int                 nextblock;              /* next free block index */
  65     char                *curblock;              /* last malloced block */
  66     int                 buffersize;             /* bytes per buffer */
  67     int                 nextsize;               /* size of next block of memory */
  68     int                 nextfree;               /* byte offset past next free buffer */
  69     int                 initsize;
  70     enum Magic { is_allocated = 0xf3a1, is_free = 0xf1a2 };
  71     const char          *name;                  /* name of the pool */
  72     Magic               magic;                  /* marker for valid pool */
  73 };
  74
  75 /*-----------------------------------------------------------------------------
  76  * Pool::free_buffer - return a buffer to a pool
  77  *-----------------------------------------------------------------------------
  78  */
  79
  80 inline void
  81 Pool::free_buffer( void *b )
  82 {
  83     assert( (this != 0) && (magic == is_allocated) );
  84
  85     /* add buffer to singly connected free list */
  86
  87     ((Buffer *) b)->next = freelist;
  88     freelist = (Buffer *) b;
  89 }
  90
  91
  92 /*-----------------------------------------------------------------------------
  93  * Pool::new_buffer - allocate a buffer from a pool
  94  *-----------------------------------------------------------------------------
  95  */
  96
  97 inline void *
  98 Pool::new_buffer( void )
  99 {
 100     void *buffer;
 101
 102     assert( (this != 0) && (magic == is_allocated) );
 103
 104     /* find free buffer */
 105
 106     if( freelist ) {
 107         buffer = (void *) freelist;
 108         freelist = freelist->next;
 109     } else {
 110         if( ! nextfree )
 111             grow( );
 112         nextfree -= buffersize;;
 113         buffer = (void *) (curblock + nextfree);
 114     }
 115     return buffer;
 116 }
 117
 118 class PooledObj {
 119 public:
 120     inline void *       operator new( size_t, Pool & );
 121     inline void *       operator new( size_t, void *);
 122     inline void *       operator new( size_t s)
 123                                 { return ::new char[s]; }
 124     inline void         operator delete( void * ) { assert( 0 ); }
 125     inline void         operator delete( void *, Pool & ) { assert( 0 ); }
 126     inline void         deleteMe( Pool & );
 127 };
 128
 129 inline void *
 130 PooledObj::operator new( size_t, Pool& pool )
 131 {
 132     return pool.new_buffer();
 133 }
 134
 135 inline void
 136 PooledObj::deleteMe( Pool& pool )
 137 {
 138     pool.free_buffer( (void *) this );
 139 }
 140
 141 #endif /* __glubufpool_h_ */