---

gust_pool.h

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.
 */

#ifndef GUST_POOL_H
#define GUST_POOL_H

#ifdef POOLDBG
#include <iostream>
#endif

namespace gust {

class PoolChunkList
{
public:
  void *head;
  void *chunks;

  size_t elemsize;
  size_t growrate;
};

const size_t PoolTabSize=2049;        /* must not be changed */
GULAPI
extern PoolChunkList *PoolTab[2049];
GULAPI
extern PoolChunkList  Pools[6];


GULAPI
void PoolGrow( PoolChunkList *pool );
GULAPI
void PoolFreeAll( void );


#ifdef POOLDBG
struct pooldbg
{
  GULAPI static int freekey;
  GULAPI static int curmark;
  GULAPI static int count;
  GULAPI static pooldbg *head;

  int key;
  int mark;
  size_t insize;
  size_t outsize;
  void   *address;
 
  pooldbg *next;

  pooldbg( void *p, size_t sin, size_t sout )
  {
    count++;

    address = p;
    insize = sin;
    outsize = sout;

    key = ++freekey;
    mark = curmark;

    next = head;
    head = this;
  }
  static void remove( void *p )
  {
    pooldbg *n = head;
    pooldbg *nprev = 0;

    while( (n != 0) && (n->address != p) )
    {
      nprev = n;
      n = n->next;
    }
    if( n != 0 )
    {
      if( nprev == 0 ) head = n->next;
      else nprev->next = n->next;
      delete n;
    }
    else
    {
      std::cout << "ERROR: address not in list of reserved blocks\n"; 
      gul_halt();
    }
  } 
  static void incmark()
  {
    curmark++;
  }
  ~pooldbg()
  {
    count--;
  }
  static void dump( int minmark )
  {
    pooldbg *n = head;

    while( (n != 0) && (n->mark >= minmark) )
    {
      #ifndef _MSC_VER
        std::cout << n->address << ":(m = " << n->mark << ", i = " << n->insize 
                  << ", o = " << n->outsize << ")\n"; 
      #else
        // operator to print a 'size_t' doesn't seem to be defined
        std::cout << n->address << ":(m = " << n->mark << ", i = " 
                  << (unsigned int)n->insize << ", o = " 
                  << (unsigned int)n->outsize << ")\n"; 
      #endif
      n = n->next;
    }
  }
};
#endif

inline void *PoolAlloc( const size_t insize, size_t *outsize  )
{
  PoolChunkList *pool;
  void *head;

  if( !insize ) 
  {
    *outsize = 0;  
    return 0;
  }
  
  pool = PoolTab[insize];

  head = pool->head;
  
  if( head == NULL )
  {
    PoolGrow( pool );
    head = pool->head;
  }

  pool->head = *((void **)head);
  *outsize = pool->elemsize; 
#ifdef POOLDBG
  new pooldbg( (void *)head, insize, *outsize );
#endif
  return((void *)head); 
}

inline void PoolFree( void *ptr, const size_t size )
{
  if( !ptr || !size ) return;

  PoolChunkList *pool = PoolTab[size];

  *((void **)ptr) = pool->head;
  pool->head = ptr;
#ifdef POOLDBG
  pooldbg::remove( ptr );
#endif
}

inline void *PreferPoolAlloc( const size_t insize, size_t *outsize  )
{
  PoolChunkList *pool;
  void *head;

  if( !insize ) 
  {
    *outsize = 0;  
    return 0;
  }

  if( insize >= PoolTabSize )
  {
    *outsize = insize;

    void *p = malloc(insize);
#ifdef POOLDBG
    new pooldbg( p, insize, *outsize );
#endif
    return p;
  }
  
  pool = PoolTab[insize];

  head = pool->head;
  
  if( head == NULL )
  {
    PoolGrow( pool );
    head = pool->head;
  }

  pool->head = *((void **)head);
  *outsize = pool->elemsize; 
#ifdef POOLDBG
  new pooldbg( (void *)head, insize, *outsize );
#endif
  return((void *)head); 
}

inline void PreferPoolFree( void *ptr, const size_t size )
{
  if( !ptr || !size ) return;

  if( size >= PoolTabSize ) 
  {
    free(ptr);
#ifdef POOLDBG
    pooldbg::remove( ptr );
#endif
    return;
  }

  PoolChunkList *pool = PoolTab[size];

  *((void **)ptr) = pool->head;
  pool->head = ptr;
#ifdef POOLDBG
  pooldbg::remove( ptr );
#endif
}

}

#endif

---