pool.h
//
// pool.h
//
// Copyright (C) 1996 Limit Point Systems, Inc.
//
// Author: Curtis Janssen <cljanss@limitpt.com>
// Maintainer: LPS
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit 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, or (at your option)
// any later version.
//
// The SC Toolkit 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 the SC Toolkit; see the file COPYING.LIB. If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
#ifdef __GNUC__
#pragma interface
#endif
#ifndef _util_group_pool_h
#define _util_group_pool_h
#include <stdlib.h>
#include <new>
#include <iostream>
#include <util/misc/exenv.h>
#undef DEBUG_POOL
namespace sc {
const int pool_data_alignment_bit = 3;
//const int pool_data_alignment_bit = 14;
const size_t pool_data_alignment = 1<<pool_data_alignment_bit;
inline size_t
align_pool_data(size_t size)
{
return (size + pool_data_alignment - 1)
& (~ (pool_data_alignment - 1));
}
inline void*
align_pool_data(void* ptr)
{
return (void*)( (unsigned long) ((char*)ptr + pool_data_alignment - 1)
& (~ (pool_data_alignment - 1)));
}
inline size_t
align_pool_data_downward(size_t size)
{
return size & (~ (pool_data_alignment - 1));
}
inline void*
align_pool_data_downward(void* ptr)
{
return (void*) ( (unsigned long) ptr & (~ (pool_data_alignment - 1)));
}
// ////////////////////////////////////////////////////////////////////////////
class PoolData;
struct FreeData {
PoolData* next_free_;
PoolData* prev_free_;
};
// ////////////////////////////////////////////////////////////////////////////
struct UsedData {
unsigned int flags;
unsigned int held_:16;
int priority_:15;
unsigned int fixed_:1;
};
// ////////////////////////////////////////////////////////////////////////////
class PoolData {
public:
enum {magic = 0x1f1d1e1c};
int magic_;
size_t size_;
unsigned int free_:1;
unsigned int flags_:15;
private:
PoolData* next_;
PoolData* prev_;
public:
union {
FreeData f;
UsedData u;
};
// Allocates a chunk of free memory, only initializing the size.
PoolData(size_t size);
PoolData* next();
PoolData* prev();
void next(PoolData*);
void prev(PoolData*);
void prev_next(PoolData*,PoolData*);
PoolData* next_free();
PoolData* prev_free();
void next_free(PoolData*);
void prev_free(PoolData*);
void prev_next_free(PoolData*,PoolData*);
void set_magic(int = magic);
// This new can only be called with aligned memory.
//void* operator new(size_t size, void* placement);
void* data();
void check(void*lower=(void*)0x0,void*upper=(void*)0x7fffffffL);
};
const int PoolData_aligned_size = (sizeof(PoolData) + pool_data_alignment - 1)
& (~ (pool_data_alignment - 1));
inline void* PoolData::data()
{
return (void*)(((char*)this) + PoolData_aligned_size);
}
inline PoolData*
PoolData::next()
{
return next_;
}
inline PoolData*
PoolData::prev()
{
return prev_;
}
inline void
PoolData::next(PoolData*p)
{
next_ = p;
#ifdef DEBUG_POOL
if (next_ && prev_ && (next_ < prev_)) {
ExEnv::errn() << "PoolData::next(PoolData*): next < prev" << endl;
abort();
}
#endif
}
inline void
PoolData::prev(PoolData*p)
{
prev_ = p;
#ifdef DEBUG_POOL
if (next_ && prev_ && (next_ < prev_)) {
ExEnv::errn() << "PoolData::prev(PoolData*): next < prev" << endl;
abort();
}
#endif
}
inline void
PoolData::prev_next(PoolData*p,PoolData*n)
{
prev_ = p;
next_ = n;
#ifdef DEBUG_POOL
if (next_ && prev_ && (next_ < prev_)) {
ExEnv::errn() << "PoolData::prev_next: next < prev" << endl;
abort();
}
#endif
}
// ////
inline PoolData*
PoolData::next_free()
{
#ifdef DEBUG_POOL
if (!free_) {
ExEnv::errn() << "PoolData::next_free(): datum is not free" << endl;
abort();
}
#endif
return f.next_free_;
}
inline PoolData*
PoolData::prev_free()
{
#ifdef DEBUG_POOL
if (!free_) {
ExEnv::errn() << "PoolData::prev_free(): datum is not free" << endl;
abort();
}
#endif
return f.prev_free_;
}
inline void
PoolData::next_free(PoolData*p)
{
#ifdef DEBUG_POOL
if (!free_) {
ExEnv::errn() << "PoolData::next_free(PoolData*): datum is not free" << endl;
abort();
}
#endif
f.next_free_ = p;
}
inline void
PoolData::prev_free(PoolData*p)
{
#ifdef DEBUG_POOL
if (!free_) {
ExEnv::errn() << "PoolData::prev_free(PoolData*): datum is not free" << endl;
abort();
}
#endif
f.prev_free_ = p;
}
inline void
PoolData::prev_next_free(PoolData*p,PoolData*n)
{
#ifdef DEBUG_POOL
if (!free_) {
ExEnv::errn() << "PoolData::prev_next_free: datum is not free" << endl;
abort();
}
#endif
f.prev_free_ = p;
f.next_free_ = n;
}
inline
PoolData::PoolData(size_t size):
magic_(magic),
size_(size-PoolData_aligned_size)
{
}
inline void
PoolData::set_magic(int magic_a)
{
magic_ = magic_a;
}
// ////////////////////////////////////////////////////////////////////////////
class Pool {
protected:
enum { freelist_size = sizeof(size_t)*8 };
PoolData* freelist_[freelist_size];
size_t size_;
PoolData* firstdatum_;
PoolData* voidptr_to_pd(void*d);
int freelist_find_slot(size_t);
void freelist_add(PoolData*);
void freelist_del(PoolData*);
public:
Pool(size_t);
~Pool();
// void* operator new(size_t size, void* placement) { return placement; }
// Handle& allocate_handle(size_t size, int priority = 0);
// void release(Handle&);
size_t size() { return size_; }
void* allocate(size_t size);
void release(void*d);
double* allocate_double(size_t n);
void release(double*d);
int* allocate_int(size_t n);
void release(int*d);
void print(std::ostream&o=ExEnv::out0());
void check();
};
inline PoolData*
Pool::voidptr_to_pd(void*d)
{
return (PoolData*)((char*)d - PoolData_aligned_size);
}
inline double*
Pool::allocate_double(size_t n)
{
return (double*) allocate(n*sizeof(double));
}
inline void
Pool::release(double*d)
{
release((void*)d);
}
inline int*
Pool::allocate_int(size_t n)
{
return (int*) allocate(n*sizeof(int));
}
inline void
Pool::release(int*d)
{
release((void*)d);
}
}
#endif
// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End: