#include <map>
#include <pthread.h>
//#include <iostream>

#include "FixedMalloc.h"


static std::map< size_t, void * > *freeList = NULL;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

inline size_t roundUp(size_t size)
{ // Round up to an even multiple of 8.  This keeps more stuff aligned.  This
  // might help performance.  And this might help with atomic access to data,
  // required for sharing between threads.
  return ((size+7)>>3)<<3;
}

void *fixedMalloc(size_t size)
{
#ifdef SIMPLE_MALLOC
  return malloc(size);
#endif
  size = std::max(sizeof(void *), sizeof(size_t) + size);
  size = roundUp(size);
  pthread_mutex_lock(&mutex);
  if (!freeList)
    {
      freeList = new std::map< size_t, void * >;
    }
  void *&top = (*freeList)[size];
  if (!top)
    {
      //std::cout<<"Requesting 25 more blocks of "<<size<<" bytes.\n";
      const int perBlock = 25;
      size_t blockSize = size * perBlock;
      char *next = new char[blockSize];
      if (next)
	{
	  for (int count = 0; count < perBlock; count++)
	    {
	      *(void **)next = top;
	      top = next;
	      next += size;
	    }
	}
    }
  void *result = 0;
  if (top)
    {
      result = top;
      top = *(void **)result;
      *(size_t *)result = size;
      result = (char *)result + sizeof(size_t);
    }
  pthread_mutex_unlock(&mutex);
  return result;
}

void fixedFree(void *mem)
{
#ifdef SIMPLE_MALLOC
  free(mem);
  return;
#endif
  if (mem)
    {
      mem = (char *)mem - sizeof(size_t);
      size_t size = *(size_t *)mem;
      pthread_mutex_lock(&mutex);
      void *&top = (*freeList)[size];
      *(void **)mem = top;
      top = mem;
      pthread_mutex_unlock(&mutex);
    }
}

size_t fixedMallocSize(void *mem)
{
#ifdef SIMPLE_MALLOC
  return 0;
#endif
  if (mem)
    {
      return *(((size_t *)mem)-1);
    }
  else
    {
      return 0;
    }
}

/*
void *FixedMalloc::operator new(size_t size)
{
  return fixedMalloc(size);
}

void FixedMalloc::operator delete(void *mem, size_t)
{
  fixedFree(mem);
}
*/

/*
 test code

#include <iostream>

#include "FixedMalloc.h"

int main()
{
  void *items[55];
  for (int i = 0; i < 55; i += 2)
    {
      std::cout<<i<<": ";
      for (int j = 0; j <= i; j++)
	{
	  items[j] = fixedMalloc(20);
	  std::cout<<' '<<items[j];
	}
      for (int j = i; j >= 0; j--)
	{
	  fixedFree(items[j]);
	}
      std::cout<<'\n';
    }
}


*/