/*
 * Two Levels Segregate Fit memory allocator (TLSF)
 * Version 1.3
 *
 * Written by Miguel Masmano Tello <mmasmano@disca.upv.es>
 *
 * Thanks to Ismael Ripoll for his suggestions and reviews
 *
 * Copyright (C) April 2004 UPVLC, OCERA Consortium
 * 
 * This code is released using a dual license strategy: GPL/LGPL
 * You can choose the license that better fits your requirements.
 *
 * Released under the terms of the GNU General Public License Version 2.0
 * Released under the terms of the GNU Lesser General Public License Version 2.1
 *
 */

#include "TLSF_nondep.h"
#include "arch/msr.h"

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#define MAX_LEN 45

static int ncolors = 0;
static int failed = 0, passed = 0;

static void test_result_bool (char *title, int res) {
  int length, n;
  char buffer [MAX_LEN + 1];

  strncpy (buffer, title, MAX_LEN);
  buffer[MAX_LEN] = 0;
  fprintf (stderr, "%s ", buffer);
  
  length = strlen (buffer);
  for (n = length; n < MAX_LEN + 3; n++)
    fprintf (stderr, ".");
  
  fprintf (stderr, " [");
  
  if (res) {
    passed ++;
    if (ncolors)
      fprintf (stderr, "PASSED");
    else
      fprintf (stderr, "\E[32mPASSED\E[0m");
  } else {
    failed ++;
    if (ncolors)
      fprintf (stderr, "FAILED");
    else
      fprintf (stderr, "\E[31mFAILED\E[0m");
  }
  fprintf (stderr, "]\n");
}

static void test_result_int (char *title, int res, char *unit) {
  int length, n;
  char buffer [MAX_LEN + 1];

  strncpy (buffer, title, MAX_LEN);
  buffer[MAX_LEN] = 0;
  fprintf (stderr, "%s ", buffer);
  
  length = strlen (buffer);
  for (n = length; n < MAX_LEN + 3; n++)
    fprintf (stderr, ".");

  if (ncolors)
    fprintf (stderr, " %d", res);
  else
    fprintf (stderr, " \E[34m%d\E[0m", res);
  if (unit)
    fprintf (stderr, " %s\n", unit);
}

static void test_result_ll (char *title, unsigned long long res, char *unit) {
  int length, n;
  char buffer [MAX_LEN + 1];

  strncpy (buffer, title, MAX_LEN);
  buffer[MAX_LEN] = 0;
  fprintf (stderr, "%s ", buffer);
  
  length = strlen (buffer);
  for (n = length; n < MAX_LEN + 3; n++)
    fprintf (stderr, ".");

  if (ncolors)
    fprintf (stderr, " %llu", res);
  else
    fprintf (stderr, " \E[34m%llu\E[0m", res);
  if (unit)
    fprintf (stderr, " %s\n", unit);
}


/* This first test checks correct TLSF structure initialisation */
static int initialisation_tests (void) {
  unsigned char memory_pool[1024 * 1024];
  unsigned char *ptr = NULL, buffer[256];
  int mem_alloc, n , sli, total, max, min, m;
  int ext_frag_max, ext_frag_average;
  unsigned long long average;

  fprintf (stderr, "\n>>> INITIALISATION tests <<<\n\n");
  
  test_result_bool ("Normal initialisation", 
	       init_memory_pool (0, 5, 10, memory_pool) > 0);
  test_result_bool ("No memory pool provideed", 
	       init_memory_pool (0, 5, 10, NULL) <= 0);
  
  fprintf (stderr, "\n+ TLSF STRUCTURE SIZE tests (1 KB - 500 KB)\n\n");
  for (sli = 5; sli > 0; sli --) {
    average = 0;
    total = 0;
    max = 0;
    ext_frag_max = 0;
    ext_frag_average = 0;
    min = 1000000;
    for (n = 1; n < 500; n += 10) {
      memset (memory_pool, 0xFF, 1024 * 1024);
   
      mem_alloc = init_memory_pool (0, sli, n, memory_pool);
      if (mem_alloc < 0) {
	test_result_bool ("TLSF structure initialisation", 0);
	goto out;
      }
      if (max < (n*1024 - mem_alloc))
	max = (n*1024 - mem_alloc);

      if (min > (n*1024 - mem_alloc))
	min = (n*1024 - mem_alloc);

      average += (n*1024 - mem_alloc);
      total ++;

      for (m = mem_alloc; m > 0; m --) {
	ptr = rtl_malloc_ex (m, memory_pool);
	if (ptr != NULL) goto out1;
      }
      
    out1:
      ext_frag_average += (mem_alloc - m);
      if (ext_frag_max < (mem_alloc -m))
	ext_frag_max = (mem_alloc - m);
      memset (ptr, 0xAA, m);
      rtl_free_ex (ptr, memory_pool);
      if (memory_pool [n * 1024] != 0xFF)  {
	fprintf (stderr, "\n");
	test_result_bool ("TLSF structure size exceeded", 0);
	goto out;
      }
    }
    sprintf (buffer, "(SLI = %d) struct size average", sli);   
    test_result_ll (buffer, (unsigned long long) average/
		    (unsigned long long)total, "Bytes");
    sprintf (buffer, "(SLI = %d) struct size max", sli);
    test_result_int (buffer, max, "Bytes");
    sprintf (buffer, "(SLI = %d) struct size min", sli);
    test_result_int (buffer, min, "Bytes");
    sprintf (buffer, "(SLI = %d) first block wasted size average", sli);   
    test_result_ll (buffer, (unsigned long long) 
		    ext_frag_average / (unsigned long long)total, "Bytes");
    sprintf (buffer, "(SLI = %d) first block wasted size max", sli);   
    test_result_int (buffer, ext_frag_max, "Bytes");
    fprintf (stderr, "\n");
  }
  fprintf (stderr, "\n");
  test_result_bool ("TLSF structure size exceeded", 1);
  test_result_bool ("TLSF structure initialisation", 1);
  
 out:

  return 0;
}

/* This first test checks correct TLSF structure initialisation */
static int malloc_tests (void) {
  block_header_t *bh;
  char memory_pool[1024 * 1024]; /* For the  initialisation test with 10
				    Kb will be enought */
  char *ptr, buffer [256];
  int n, sli, total, max, real;
  unsigned long long average, t1, t2, t3, maxll, minll, resll;

  fprintf (stderr, "\n>>> MALLOC tests <<<\n\n");
  init_memory_pool (0, 5, 1024, memory_pool);
  test_result_bool ("Requesting a negative value", 
		    rtl_malloc_ex(-1, memory_pool) == NULL);
  test_result_bool ("Requesting 0 Bytes", 
		    rtl_malloc_ex (0, memory_pool) == NULL);
  
  fprintf (stderr, "\n+ INTERNAL FRAGMENTATION tests (1 KB - 500 KB)\n\n");
  for (sli = 5; sli > 0; sli--) {
    init_memory_pool (0, sli, 1024, memory_pool);
    average = 0;
    total = 0;
    max = 0;
    for (n = 1024; n < 500 * 1024; n ++) {
      ptr = rtl_malloc_ex (n, memory_pool);
      if (ptr == NULL) {
	fprintf (stderr, "\n");
	test_result_bool ("Internal Fragmentation", 0);
	goto out;
      }
      bh = (block_header_t *) ((__u8 *) ptr -
			     TLSF_WORDS2BYTES(beg_header_overhead));
      if (TLSF_WORDS2BYTES(bh -> size) < n) {
	fprintf (stderr, "\n");
	test_result_bool ("Internal Fragmentation", 0);
	goto out;
      }

      if (TLSF_WORDS2BYTES(bh -> size) - n > max) 
	max = TLSF_WORDS2BYTES(bh -> size) - n;
      average += (unsigned long long) TLSF_WORDS2BYTES(bh -> size) - n;
      total ++;
      rtl_free_ex (ptr, memory_pool);
    }
    sprintf (buffer, "(SLI = %d) Int. Frag. average", sli);
    test_result_ll (buffer, (unsigned long long) average / 
		    (unsigned long long)total, "Bytes");
    sprintf (buffer, "(SLI = %d) Int. Frag. max", sli);
    test_result_int (buffer, max, "Bytes");
    fprintf (stderr, "\n");
  }
  fprintf (stderr, "\n");
  test_result_bool ("Internal fragmentation", 1);
  
  /**/
  fprintf (stderr, 
	   "\n+ Response time tests (1 KB - 500 KB) (On the worst case)\n\n");
  for (sli = 5; sli > 0; sli--) {
    init_memory_pool (0, sli, 1024, memory_pool);
    real = 0;
    average = 0;
    total = 0;
    maxll = 0;
    minll = 10000;
    for (n = 1024; n < 500 * 1024; n ++) {
      rdtscll(t1);
      ptr = rtl_malloc_ex (n, memory_pool);
      rdtscll(t2);
      rdtscll(t3);
      if (ptr == NULL) {
	fprintf (stderr, "\n");
	test_result_bool ("Response time", 0);
	goto out;
      }
      resll = (t2 - t1) - (t3 - t2);

      /* This is not a real-time OS so there exist some interferences, this
	 anomalous cases must been eliminated */
      if (resll < 1000) {
	if (maxll < resll) maxll = resll;
	if (minll > resll) minll = resll;
	average += (unsigned long long) resll;
	total ++;
      }
      real ++;
      rtl_free_ex (ptr, memory_pool);
    }
    sprintf (buffer, "(SLI = %d) Response time average", sli);
    test_result_ll (buffer, (unsigned long long) average / 
		    (unsigned long long)total, "ticks");
    sprintf (buffer, "(SLI = %d) Response time max", sli);
    test_result_ll (buffer, maxll, "ticks");
    sprintf (buffer, "(SLI = %d) Response time min", sli);
    test_result_ll (buffer, minll, "ticks");
    sprintf (buffer, "(SLI = %d) Total used samples", sli);
    test_result_int (buffer, total, "");
    sprintf (buffer, "(SLI = %d) Ignored samples", sli);
    test_result_int (buffer, real - total, "");
    sprintf (buffer, "(SLI = %d) Real total samples", sli);
    test_result_int (buffer, real, "");
    fprintf (stderr, "\n");
  }
  fprintf (stderr, "\n");
  test_result_bool ("Response time", 1);
 out:

  return 0;
}

/* This first test checks correct TLSF structure initialisation */
static int free_tests (void) {
  //char memory_pool[10 * 1024]; // For the  initialisation test with 10
  // Kb will be enought
  return 0;
}

/* This first test checks correct TLSF structure initialisation */
static int miscellaneous_tests (void) {
  //char memory_pool[10 * 1024]; // For the  initialisation test with 10
			       // Kb will be enought

  return 0;
}


int main (int argc, char **argv) {
  // stdout is closed because TLSF error msg are given through it
  if (argc == 2) {
    if (strcmp ("-nocolors", argv[1]) == 0)
      ncolors = 1;
  }
  close (1);
  initialisation_tests ();
  malloc_tests ();
  free_tests (); 
  miscellaneous_tests ();
  fprintf (stderr, "\n>>> TESTS Summary <<<\n");
  fprintf (stderr, 
	   "\nFAILED tests: %d\nPASSED tests: %d\nTotal tests: %d\n\n", 
	   failed, passed, failed + passed);
  
  return 0;
}