#include "runtime/universe.hpp"
#include "memory/heap.hpp"
#include "memory/oopClosure.hpp"
#include <stdlib.h>

Heap* Heap::instance = NULL;
size_t Heap::MAX_CAP = 2 * 1024 * 1024;

Heap* Heap::get_instance() {
 if (instance == NULL)
 instance = new Heap(MAX_CAP);

 return instance;
}

Heap::Heap(size_t size) {
 mem_1 = new Space(size);
 mem_2 = new Space(size);
 metaspace = new Space(size / 16);

 mem_1->clear();
 mem_2->clear();
 metaspace->clear();

 eden = mem_1;
 survivor = mem_2;
}

Heap::~Heap() {
 if (mem_1) {
 delete mem_1;
 mem_1 = NULL;
 }

 if (mem_2) {
 delete mem_2;
 mem_2 = NULL;
 }

 if (metaspace) {
 delete metaspace;
 metaspace = NULL;
 }

 eden = NULL;
 survivor = NULL;
}

void* Heap::allocate(size_t size) {
 if (!eden->can_alloc(size)) {
 gc();
 }

 return eden->allocate(size);
}

void* Heap::allocate_meta(size_t size) {
 if (!metaspace->can_alloc(size)) {
 return NULL;
 }

 return metaspace->allocate(size);
}

void Heap::copy_live_objects() {
 ScavengeOopClosure* closure = new ScavengeOopClosure(eden, survivor, metaspace);
 closure->scavenge();
 delete closure;
}

void Heap::gc() {
 printf("gc starting...\n");
 printf(" befroe gc : \n");
 printf(" eden's capacity is %lu\n", eden->_capacity);
 copy_live_objects();

 Space* t = eden;
 eden = survivor;
 survivor = t;

 printf(" after gc : \n");
 printf(" eden's capacity is %lu\n", eden->_capacity);
 printf("gc end\n");

 survivor->clear();
}

Space::Space(size_t size) {
 _size = size;
 _base = (char*)malloc(size);
 _end = _base + size;
 _top = (char*)(((long)(_base + 15)) & -16);
 _capacity = _end - _top;
}

Space::~Space() {
 if (_base) {
 free(_base);
 _base = 0;
 }

 _top = 0;
 _end = 0;
 _capacity = 0;
 _size = 0;
}

void Space::clear() {
 memset(_base, 0, _size);
 _top = (char*)(((long)(_base + 15)) & -16);
 _capacity = _end - _top;
}

void* Space::allocate(size_t size) {
 size = (size + 7) & -8;
 char* start = _top;
 _top += size;
 _capacity -= size;
 //printf("after allocate %lx, _top is %p\n", size, _top);
 return start;
}

bool Space::can_alloc(size_t size) {
 return _capacity > size;
}

bool Space::has_obj(char* obj) {
 return obj >= _base && _end > obj;
}