#define N 1024
#define PAGESIZE 4096
//#define HEAPSIZE ((N/(PAGESIZE/sizeof(struct PageDesc))*PAGESIZE + 3*PAGESIZE))

#include "heap.h"
#include "uthash/src/uthash.h"


struct PageDesc {
  unsigned int vaddr;
  unsigned int paddr;
  unsigned int flags;
  UT_hash_handle hh;
};

enum PAGEBITS { DIRTY_BIT=0, EXECUTE_BIT=1 };
struct PageDesc *pdhash=NULL;


#ifdef PRINT
#  include <stdio.h>
#  define PF(...) printf(__VA_ARGS__)
#else
#  define PF(...)
#endif


void
crash(void)
{
  PF("crash\n");
  ((*(volatile int *)0)=1);
}

void
my_fatal(char *msg) 
{
  PF("my_fatal: %s\n", msg);
  crash();
}

void
verify(void)
{
  volatile int count=0;
  struct PageDesc *pd;

  PF("count=%d\n", HASH_COUNT(pdhash));
  for (unsigned int va=0; va<(N*PAGESIZE); va+=PAGESIZE) {
    pd=NULL;
    HASH_FIND_INT(pdhash, &va, pd);
    if (pd) count++;
  }

  if (count != N) crash();

  PF("SUCCESS: HITS\n");
  
  count=0;
  for (unsigned int va=N; va<(N+(N*PAGESIZE)); va+=PAGESIZE) {
    pd=NULL;
    HASH_FIND_INT(pdhash, &va, pd);
    if (pd==NULL) count++;
  }

  if (count != N) crash();

  PF("SUCCESS: misses\n");
}

// TESTING
#if MODE == 1
#  undef uthash_malloc
#  undef uthash_free

#  define uthash_malloc(sz) my_fatal("uthash_malloc called")
#  define uthash_free(ptr, sz) my_fatal("uthash_free called")

#  undef uthash_fatal
#  define uthash_fatal(msg) my_fatal(msg);

struct PageDesc *
searchhash(unsigned int flagmask)
{
  struct PageDesc *pd, *tmp;

  HASH_ITER(hh, pdhash, pd, tmp) {
    if (pd->flags && flagmask) return pd;
  }
  return NULL;
}

void
test(void)
{
  searchhash(1<<DIRTY_BIT);
}

int
main() 
{
  if (my_malloc_heap != (void *)HEAPADDR) my_fatal("bad heap location");
  pdhash = (struct PageDesc *)PDHASHADDR;
  verify();
  test();
  return 0;
}

#else 

#  undef uthash_malloc
#  undef uthash_free
#  define uthash_malloc(sz) my_malloc(sz)
#  define uthash_free(ptr, sz) my_free(ptr)
#  undef uthash_fatal
#  define uthash_fatal(msg) my_fatal(msg);

char *my_malloc_freemem = my_malloc_heap;

void *
my_malloc(unsigned int size) 
{
  unsigned char *ptr=my_malloc_freemem;

  if ((ptr + size) > (my_malloc_heap + HEAPSIZE))
    return NULL;

  my_malloc_freemem += size;

  return (void *)ptr;
}

void
my_free(void *ptr) 
{
  PF("my_free called\n");
}
 
void 
mymalloc_print_heap(void)
{

  fprintf(stderr, "{\n", HEAPSIZE);
  for (int i=0; i<HEAPSIZE-1; i++)
    fprintf(stderr, "  0x%02x,\n", my_malloc_heap[i]);
  fprintf(stderr, "  0x%02x\n};\n", my_malloc_heap[HEAPSIZE-1]);
  fprintf(stderr, "#define HEAPADDR %p\n", my_malloc_heap);
  fprintf(stderr, "#define PDHASHADDR %p\n", pdhash);
}


void
pophash()
{
  struct PageDesc *pd;

  for (unsigned int addr=0, i=0; addr < (N * PAGESIZE); addr+=PAGESIZE,i++) {
    pd = uthash_malloc(sizeof(struct PageDesc));
    pd->vaddr = addr;
    pd->paddr = (addr & 0xFFFF) | 0xBEAF0000;
    pd->flags = 1 << DIRTY_BIT;
    HASH_ADD_INT(pdhash, vaddr, pd);
  }
}

int 
main()
{
  pophash();
  verify();
  mymalloc_print_heap();
  return 0;
}
#endif