source: to-imperative/trunk/runtime/pxx_memory_chunk.hh @ 286

// $Source$
// $Revision: 286 $
// $Date: 2002-12-17 13:29:30 +0000 (Tue, 17 Dec 2002) $

#ifndef __pxx_memory_chunk_hh__
#define __pxx_memory_chunk_hh__

#include "pxx_heap_allocator.hh"

namespace pxx {

class Memory_Chunk
{
  //
  // Можно было бы сделать такие поля:
  // 
  //    uintptr_t dummy_field;
  //    uintptr_t order;
  //    uintptr_t size;
  //    uintptr_t ref_count;
  // 
  // Тогда не придётся сдвигать order. Но зато уменьшается кол-во полезного
  // места в chunk'е, в результате возрастает число копирований обоих
  // выражений и скорость работы уменьшается.
  // 
  uintptr_t order;
  uintptr_t ref_count;

#if PARANOIA
  //
  // private constructors and operator= for error checking,
  // construct_mem_chunk() should be used instead of direct constructor calls
  inline Memory_Chunk();
  inline Memory_Chunk( const Memory_Chunk & );
  inline const Memory_Chunk &operator=( const Memory_Chunk & );
#endif
  //
  // nobody from outside should set our internals
  inline void set_order( size_t _order );

public:
  //
  // instead of constructor the following function should be used
  friend inline Memory_Chunk *construct_mem_chunk(
      HeapAllocator *_allocator, size_t _size
  );
  //
  // let _allocator to destruct us
  inline void destruct( HeapAllocator *_allocator );
  //
  // return order of the whole chunk
  inline uintptr_t get_order() const;
  //
  // return size of usable memory
  inline uintptr_t get_size() const;
  //
  // return pointer to the begining of usable memory block
  inline void *get_first() const;
  //
  // return pointer beyond the end of usable memory block
  inline void *get_last() const;
  //
  // increment reference counter
  inline void inc_ref_count();
  //
  // decrement reference counter,
  // return false if it becomes zero
  inline bool dec_ref_count();
  //
  // return true if there is no references to the chunk from outside ???
  inline bool no_extern_refs() const;
};

#if PARANOIA

inline Memory_Chunk::Memory_Chunk()
{
  FATAL( "Default constructor for Memory_Chunk class shouldn't be used!" );
}

inline Memory_Chunk::Memory_Chunk( const Memory_Chunk & )
{
  FATAL( "Copy constructor for Memory_Chunk class shouldn't be used!" );
}

inline const Memory_Chunk &Memory_Chunk::operator=( const Memory_Chunk & )
{
  FATAL( "operator=() for Memory_Chunk class shouldn't be used!" );
  return *this;
}

#endif

inline Memory_Chunk *construct_mem_chunk(
    HeapAllocator *_allocator, size_t _size
)
{
  //
  // allocator will set order to the real order of allocated space
  size_t order;
  //
  // allocate memory including space for information about chunk and get
  // pointer to it
  Memory_Chunk *chunk =
    static_cast<Memory_Chunk*>(
        _allocator->allocate( _size + sizeof(Memory_Chunk), &order )
    );
#if PARANOIA
  //
  // normally allocator should not return null, but we do not believe
  if( chunk == null )
    FATAL( "Unable to allocate expression" );
#endif
  //
  //
  chunk->set_order( order );
  //
  // set initial value of reference counter to 1
  chunk->ref_count = 1;
  //
  //
  return chunk;
}

inline void Memory_Chunk::destruct( HeapAllocator *_allocator )
{
  _allocator->deallocate( this, get_order() );
}

inline void Memory_Chunk::set_order( size_t _order )
{
  order = _order << 1 | 0x01;
}

inline uintptr_t Memory_Chunk::get_order() const
{
  return order >> 1;
}

inline uintptr_t Memory_Chunk::get_size() const
{
  return rounds[get_order()] - sizeof( Memory_Chunk );
}

inline void *Memory_Chunk::get_first() const
{
  return (void*)( ptr_add( this, sizeof(Memory_Chunk) ));
}

inline void *Memory_Chunk::get_last() const
{
  return (void*)( ptr_add( this, rounds[get_order()] ));
}

inline void Memory_Chunk::inc_ref_count()
{
  //
  // check for reference counter owerflow
  if( !(++ref_count) )
    FATAL( "Reference counter overflow" );
}

inline bool Memory_Chunk::dec_ref_count()
{
  return --ref_count;
}

inline bool Memory_Chunk::no_extern_refs() const
{
  return ref_count == 1;
}

}

#endif // __pxx_memory_chunk_hh__