---

gust_pool.cpp

Go to the documentation of this file.

/* LIBGUL - Geometry Utility Library
 * Copyright (C) 1998-1999 Norbert Irmer
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#include "stdafx.h"

#include <iostream>
 
#include <stdio.h>
#include <stdlib.h>

#include "gul_types.h"
#include "gust_pool.h"

using std::cout;

GULAPI void gul_halt( void )
{
#ifdef POOLDBG
  cout << "this is a place for setting breakpoints\n";
#endif
}

#ifdef _MSC_VER
GULAPI void *test_gul_dll_malloc( size_t s )
{
  return malloc(s);
}
GULAPI void test_gul_dll_free( void *s )
{
  free(s);
}
#endif

namespace gust {

#ifdef POOLDBG
GULAPI int pooldbg::freekey = 0;
GULAPI int pooldbg::curmark = 0;
GULAPI int pooldbg::count = 0;
GULAPI pooldbg *pooldbg::head;
#endif

GULAPI
extern PoolChunkList Pools[6] =
{
  { 0, 0, 4,    256 },
  { 0, 0, 8,    128 },
  { 0, 0, 16,   64  },
  { 0, 0, 64,   32  },  // for testing
  { 0, 0, 256,  16  },
  { 0, 0, 2048, 4   }
};
}
#include "gust_pooltbl.h" 

namespace gust {

GULAPI void PoolGrow( PoolChunkList *pool )
{
  size_t nelems,elemsize;
  char *chunk,*start,*end,*p;

  nelems = pool->growrate;
  pool->growrate = nelems * 3/2;
  elemsize = pool->elemsize;

  /* important: sizeof(char) has to be ONE !!!!!!!!!!! */
 
  chunk = (char *)malloc( POOL_ALIGNMENT + nelems * elemsize );
  if( chunk == NULL ) return;
  
  start = chunk + POOL_ALIGNMENT;
  end = start + (nelems-1)*elemsize;

  for( p = start; p < end; p += elemsize )
    *((void **)p) = p + elemsize;
  
  *((void **)end) = NULL;
  
  pool->head = start;
  *((void **)chunk) = pool->chunks;
  pool->chunks = chunk;
}

GULAPI void PoolFreeAll( void )
{
  void *ch, *next_ch;
  int nPools = sizeof(Pools)/sizeof(PoolChunkList), i;
  PoolChunkList *pool;

  for( i = 0; i < nPools; i++ )
  {
    pool = &Pools[i];

    ch = pool->chunks;
    while( ch )
    {
      next_ch = *((void **)ch);
      free( ch );
      ch = next_ch;
    }
    pool->head = 0;
    pool->chunks = 0;
  }
}



}

#if 0
/* -------------------------------------------------------------------------
  Program to create the Pool-Table
--------------------------------------------------------------------------- */
#include <stdio.h>

typedef struct
{
  void *head;
  void *chunks;

  size_t elemsize;
  size_t growrate;
}
PoolChunkList;

PoolChunkList Pools[] =
{
  { 0, 0, 4,    256 },
  { 0, 0, 8,    128 },
  { 0, 0, 16,   64  },
  { 0, 0, 64,   16  },
  { 0, 0, 256,  16  },
  { 0, 0, 2048, 4   }
};

#include <iostream>

int main()
{
  cout << "PoolChunkList *PoolTab[2049] = {\n";
  size_t pP = 0;
  for( size_t i = 0; i < 2049; i++ )
  {
    if( Pools[pP].elemsize < i ) pP++;

    if( pP > sizeof(Pools)/sizeof(PoolChunkList) ) break;
       
    cout << "  &Pools[" << pP << "], /* " << i << "*/\n"; 
  }
  cout << "};\n";
}
#endif

---