/***************************************************************************
 *   Copyright (C) 2000-2004 by                                            *
 *   Jean-Christophe Hoelt <jeko@ios-software.com>                         *
 *   Guillaume Borios <gyom@ios-software.com>                              *
 *                                                                          *
 *   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.         *
 ***************************************************************************/

#include "goomsl_heap.h"
#include <stdlib.h>

struct _GOOM_HEAP {
  void **arrays;
  int number_of_arrays;
  int size_of_each_array;
  int consumed_in_last_array;
};

/* Constructors / Destructor */
GoomHeap *goom_heap_new(void)
{
  return goom_heap_new_with_granularity(4096);
}

GoomHeap *goom_heap_new_with_granularity(int granularity)
{
  GoomHeap *_this;
  _this = (GoomHeap*)malloc(sizeof(GoomHeap));
  _this->number_of_arrays   = 0;
  _this->size_of_each_array = granularity;
  _this->consumed_in_last_array = 0;
  _this->arrays = (void**)malloc(sizeof(void*));
  return _this;
}

void goom_heap_delete(GoomHeap *_this)
{
  int i;
  for (i=0;i<_this->number_of_arrays;++i) {
    free(_this->arrays[i]);
  }
  free(_this->arrays);
  free(_this);
}

static void align_it(GoomHeap *_this, int alignment)
{
  if ((alignment > 1) && (_this->number_of_arrays>0)) {
    void *last_array = _this->arrays[_this->number_of_arrays - 1];
    long  last_address = (long)last_array + _this->consumed_in_last_array;
    int   decal = (last_address % alignment);
    if (decal != 0) {
      _this->consumed_in_last_array += alignment - decal;
    }
  }
}

void     *goom_heap_malloc_with_alignment_prefixed(GoomHeap *_this, int nb_bytes,
                                                   int alignment, int prefix_bytes)
{
  void *retval = NULL;

  /* d'abord on gere les problemes d'alignement */
  _this->consumed_in_last_array += prefix_bytes;
  align_it(_this, alignment);

  /* ensuite on verifie que la quantite de memoire demandee tient dans le buffer */
  if ((_this->consumed_in_last_array + nb_bytes >= _this->size_of_each_array)
      || (_this->number_of_arrays == 0)) {

    if (prefix_bytes + nb_bytes + alignment >= _this->size_of_each_array) {

      /* Si la zone demandee est plus grosse que la granularitee */
      /* On alloue un buffer plus gros que les autres */
      _this->arrays = (void**)realloc(_this->arrays, sizeof(void*) * (_this->number_of_arrays+2));

      _this->number_of_arrays += 1;
      _this->consumed_in_last_array = prefix_bytes;

      _this->arrays[_this->number_of_arrays - 1] = malloc(prefix_bytes + nb_bytes + alignment);
      align_it(_this,alignment);
      retval = (void*)((char*)_this->arrays[_this->number_of_arrays - 1] + _this->consumed_in_last_array);

      /* puis on repart sur un nouveau buffer vide */
      _this->number_of_arrays += 1;
      _this->consumed_in_last_array = 0;
      _this->arrays[_this->number_of_arrays - 1] = malloc(_this->size_of_each_array);
      return retval;
    }
    else {
      _this->number_of_arrays += 1;
      _this->consumed_in_last_array = prefix_bytes;
      _this->arrays = (void**)realloc(_this->arrays, sizeof(void*) * _this->number_of_arrays);

      _this->arrays[_this->number_of_arrays - 1] = malloc(_this->size_of_each_array);
      align_it(_this,alignment);
    }
  }
  retval = (void*)((char*)_this->arrays[_this->number_of_arrays - 1] + _this->consumed_in_last_array);
  _this->consumed_in_last_array += nb_bytes;
  return retval;
}

void *goom_heap_malloc_with_alignment(GoomHeap *_this, int nb_bytes, int alignment)
{
  return goom_heap_malloc_with_alignment_prefixed(_this, nb_bytes, alignment, 0);
}

void *goom_heap_malloc(GoomHeap *_this, int nb_bytes)
{
  return goom_heap_malloc_with_alignment(_this,nb_bytes,1);
}

