fastalloc.h

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef COL_FASTALLOC_H
#define COL_FASTALLOC_H

#include "fastlib/base/base.h"

template<size_t item_size>
class SlabAllocator {
 private:
  // TODO: what if we want to free the entire thing?
  static char *freelist_;
  //static char *slab_list_;
  
 public:
  static void AllocSlab();
  
  static char *Alloc() {
    if (unlikely(freelist_ == NULL)) {
      AllocSlab();
    }
    char *item = freelist_;
    freelist_ = *reinterpret_cast<char **>(freelist_);
    return item;
  }
  
  static void Free(char *item) {
    *reinterpret_cast<char**>(item) = freelist_;
    freelist_ = item;
  }
};

template<size_t item_size>
void SlabAllocator<item_size>::AllocSlab() {
  int slab_items = 128; // TODO: hard-coded constant
  size_t real_item_size = stride_align(item_size, char *);
  size_t size = real_item_size * slab_items + sizeof(char *);
  char *slab = mem::Alloc<char>(size);
  
  // slab_items must be at least 2
  
  *reinterpret_cast<char **>(slab) = freelist_;
  
  --slab_items;
  
  do {
    char *prev = slab;
    slab += real_item_size;
    *reinterpret_cast<char **>(slab) = prev;
  } while (--slab_items);
  
  freelist_ = slab;
  //slab += real_item_size;
  //
  //*reinterpret_cast<char **>(slab) = slab_list_;
  //slab_list_ = slab;
}

template<size_t item_size>
char *SlabAllocator<item_size>::freelist_ = 0;

#define fast_new(T) new(SlabAllocator<sizeof(T)>::Alloc()) T

template<typename T>
inline void fast_delete(T *ptr) {
  ptr->~T();
  SlabAllocator<sizeof(T)>::Free(reinterpret_cast<char*>(ptr));
}

#endif