Thread portable class Gate portable class Timer class Pool class Terimber 2.0 About C++

Downloads Products & Services Support Clients Open Source About Home / Open source / Terimber 2.0 memory.h Go to the documentation of this file. /* * The Software License * ================================================================================= * Copyright (c) 2003-.The Terimber Corporation. All rights reserved. * ================================================================================= * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * The end-user documentation included with the redistribution, if any, * must include the following acknowledgment: * "This product includes software developed by the Terimber Corporation." * ================================================================================= * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE TERIMBER CORPORATION OR ITS CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ================================================================================ */ #ifndef _terimber_memory_h_ #define _terimber_memory_h_ #include "allinc.h" #include "base/proto.h" BEGIN_TERIMBER_NAMESPACE #pragma pack(4) // all classes that support management of memory // for objects with a fixed or dynamic size // must be used only in one thread // NO multithread protection #define ALIGNED_MASK_SIZEOF(s, m) ((s+(m-1))&~(m-1)) #define ALIGNED_SIZEOF(s) ALIGNED_MASK_SIZEOF(s, sizeof(void*)) class mem_chunk { public: size_t _chunk_size; mem_chunk* _next_chunk; unsigned char _mem[sizeof(void*)]; }; class byte_allocator { byte_allocator(const byte_allocator& x); byte_allocator& operator=(const byte_allocator& x); public: byte_allocator( size_t capacity = os_def_size ); ~byte_allocator(); void clear_all( bool secure = false ); void clear_extra( bool secure = false ); inline void reset( bool secure = false ); inline void* allocate( size_t size ); // doesn't support deallocation by pointer // everything or nothing inline void deallocate( void* ); inline size_t capacity() const; inline size_t count() const; private: void* new_chunk( size_t size ); void* next_chunk( size_t size ); protected: const size_t _capacity; size_t _count; unsigned char* _free_pos; mem_chunk* _start_chunk; mem_chunk* _using_chunk; }; class chunk_stack { public: inline chunk_stack(); inline void clear(); inline void push( size_t* chunk ); inline size_t* pop(); inline size_t* top(); inline bool empty(); private: size_t* _head; }; class rep_allocator : public byte_allocator { rep_allocator(const rep_allocator& x); rep_allocator operator=(const rep_allocator& x); protected: rep_allocator( size_t capacity = os_def_size ); ~rep_allocator(); public: inline void clear_all( bool secure = false ); inline void clear_extra( bool secure = false ); inline void reset( bool secure = false ); inline void deallocate( void* p ); protected: chunk_stack _rep; }; template < class T > class node_allocator : public rep_allocator { public: node_allocator< T >(size_t capacity = os_def_size ); inline T* allocate(); }; template < class T > class array_allocator : public rep_allocator { public: array_allocator< T >(size_t capacity = os_def_size ); ~array_allocator< T >(); inline T* allocate( size_t n ); private: inline T* pop( size_t n ); }; class byte_allocator_creator : public proto_creator< byte_allocator_creator, byte_allocator, size_t > { public: static byte_allocator* create( size_t size ); static bool find( byte_allocator* obj, size_t size ); static void back( byte_allocator* obj, size_t ); static void deactivate( byte_allocator* obj, size_t ); }; template < class T > class node_allocator_creator : public proto_creator< node_allocator_creator< T >, node_allocator< T >, size_t > { public: static node_allocator< T >* create( size_t size ); static bool find( node_allocator< T >* obj, size_t size ); static void back( node_allocator< T >* obj, size_t ); static void deactivate( node_allocator< T >* obj, size_t ); }; template < class T > class array_allocator_creator : public proto_creator< array_allocator_creator< T >, array_allocator< T >, size_t > { public: static array_allocator< T >* create( size_t size ); static bool find( array_allocator< T >* obj, size_t size ); static void back( array_allocator< T >* obj, size_t ); static void deactivate( array_allocator< T >* obj, size_t ); }; #pragma pack() END_TERIMBER_NAMESPACE #endif // _terimber_memory_h_

© Copyright Terimber 2003-.