system_linear_allocator.h

Go to the documentation of this file.

/********************************************************************
 *   This file is part of the source code of the realroot library.
 *   Author(s): J.P. Pavone, GALAAD, INRIA
 *   $Id: linear_allocator.hpp,v 1.1 2005/07/11 10:03:56 jppavone Exp $
 ********************************************************************/
#ifndef realroot_SOLVE_SBDSLV_MEMORY_LINEAR_ALLOCATOR_HPP
#define realroot_SOLVE_SBDSLV_MEMORY_LINEAR_ALLOCATOR_HPP
//--------------------------------------------------------------------
#include <algorithm>
#include <assert.h>
//--------------------------------------------------------------------
namespace mmx {
//--------------------------------------------------------------------
namespace memory
{
  /* l'allocateur linéaire pourrait hérité de std::vector mais std::vector ne fournit pas de méthodes pour fixer sa 
     capacité (méthode adjust à faire) */
  template<class T, bool automatic = false>
  struct linear_allocator
  {
    typedef T        data_t;
    typedef unsigned sz_t;
    template<bool v> struct automatic_dispatch {};   
    data_t * m_chnk;
    sz_t     m_csz;
    sz_t     m_nalloc;

    void _chnkresize_ ( sz_t nsz )
    { 
      if ( m_csz )
    {
      data_t * _chnk_ = new data_t[ m_csz = nsz ];
      assert(_chnk_);
      std::copy(m_chnk,m_chnk+m_nalloc,_chnk_);
      std::swap(_chnk_,m_chnk);
      delete[] _chnk_;
    }
      else
    {
      m_chnk = new T[ m_csz = nsz ]; 
      assert(m_chnk);
    };
    };

    static const sz_t block = 1024;
  public:
    sz_t memuse() { return sizeof(T)*m_csz; };
    void reserve( sz_t nsz )
    {
      if ( nsz < m_csz ) return;
      this->_chunkresize_(nsz);
    };
    
    inline sz_t alloc( sz_t sz )
    {
      assert(sz);
      if ( m_nalloc + sz > m_csz ) 
    {
      sz_t ncsz = std::max(m_csz,(sz_t)1);
      while ( ncsz < m_nalloc + sz ) ncsz *= 2;
      _chnkresize_( ncsz );
    };
      m_nalloc = m_nalloc + sz;
      return m_nalloc - sz;
    };
    
    inline void free( sz_t sz ) { 
      assert(m_nalloc >= sz);
      m_nalloc -= sz;
    };
    
    inline void dec ( sz_t sz ) { free(sz); };
    
    void free() { m_nalloc = m_csz = 0; if ( m_chnk ) delete[] m_chnk; m_chnk = 0; };

    inline T * data( sz_t address, const automatic_dispatch<false>&  ) const
    { 
      if ( address >= m_nalloc ) std::cout << address << "/" << m_nalloc << std::endl;
      assert(address<m_nalloc); 
      return m_chnk + address; 
    };
    
    inline T * data( sz_t address, const automatic_dispatch<true> &  ) 
    {
      if ( address < m_nalloc ) return m_chnk+address;
      alloc( address + 1 - m_nalloc );
      return m_chnk + address;
    };
    inline T * data( sz_t address ) const { return data(address,automatic_dispatch<automatic>()); };
    linear_allocator( unsigned n = 0 ): m_chnk(0), m_csz(0), m_nalloc(0) 
    {  
      _chnkresize_( (n?n:std::max((sz_t)(block/sizeof(T)),(sz_t)1)) );
    };
    ~linear_allocator()                  {  free(); };
  };
  
};
//--------------------------------------------------------------------
} //namespace mmx
/********************************************************************/
#endif //