allocator.h

Go to the documentation of this file.

/*
 *  allocator.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef ALLOCATOR_H
#define ALLOCATOR_H
#include <cassert>
#include <cstdlib>
#include <string>

namespace sli {

  class pool 
  {
    struct link { link *next; };

    class chunk 
    {
      const size_t csize;
      chunk(const chunk&);            
      chunk& operator=(const chunk&); 

     public:
      chunk *next;
      char  *mem;

      chunk(size_t s)
    :csize(s),
     next(0),
     mem(new char[csize])
    {}

      ~chunk()
    { 
      delete [] mem;
      mem=NULL;
    }

      size_t size(void)
    { return csize;}

    };

    size_t initial_block_size;
    size_t growth_factor;

    size_t block_size;     
    size_t el_size;        
    size_t instantiations; 
    size_t total;          
    size_t capacity;       
    chunk *chunks;         
    link  *head;           

    bool  initialized_;    

    void grow(size_t);     
    void grow();           

    
   public:
    pool();
    pool(const pool &);
    pool& operator=(const pool&);

    pool(size_t n, size_t initial=100, size_t growth=1); 
    void init(size_t n, size_t initial=100, size_t growth=1); 

    ~pool();               
    
    void reserve_additional(size_t n);

    size_t available(void) const
      { return total-instantiations;}

    inline void *alloc(void);     
    inline void free(void* p);    
    size_t size_of(void) const
      { return el_size;}

    inline size_t get_el_size() const;
    inline size_t get_instantiations() const;
    inline size_t get_total() const;
  };

  inline
  void * pool::alloc(void)
  {

    if(head==0)
    {
      grow(block_size);
      block_size *= growth_factor;
    }

    link *p=head;

    head = head->next;
    ++instantiations;
    
    return p;
  }

  inline
  void pool::free(void *elp)
  {
    link *p= static_cast<link *>(elp);
    p->next= head;
    head = p;
    --instantiations;
  }

  inline
  size_t pool::get_el_size() const
  {
    return el_size;
  }

  inline
  size_t pool::get_instantiations() const
  {
    return instantiations;
  }
 
  inline
  size_t pool::get_total() const
  {
    return total;
  }

}

#ifdef USE_PMA

const int MAX_THREAD = 128;

class PoorMansAllocator
{
  private:

    struct chunk
    {
      chunk(char* mem, chunk* next) : mem_(mem), next_(next) {};
      char* mem_;
      chunk *next_;
    };
  
  public:
    void init(size_t chunk_size=1048576);
    void destruct();
    void* alloc(size_t obj_size);

  private:

    void new_chunk();

    size_t chunk_size_;

    char* head_;

    chunk* chunks_;

    size_t capacity_;
};

#ifdef IS_K

class PaddedPMA : public PoorMansAllocator 
{
  // Only works for sizeof(PoorMansAllocator) < 64
  char padding[64 - sizeof(PoorMansAllocator)];
};
#endif /* #ifdef IS_K */

#endif /* #ifdef USE_PMA */

#endif /* #ifndef ALLOCATOR_H */