Enter your search terms GNU-Darwin Web Submit search form

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&); 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: