Initial commit

tasks/libmem/tests/SConscript

@@ -0,0 +1,9 @@
+
+# Inherit global environment
+Import('env')
+
+# The set of source files associated with this SConscript file.
+src_local = ['main.c', 'test_kmalloc.c', 'test_memcache.c', 'test_allocpage.c', 'test_alloc_generic.c', 'debug.c', 'memory.c', 'clz.c']
+
+obj = env.Object(src_local)
+Return('obj')

tasks/libmem/tests/clz.c

@@ -0,0 +1,16 @@
+
+#include <l4/macros.h>
+#include <l4/types.h>
+#include <l4/config.h>
+
+/* Emulation of CLZ (count leading zeroes) instruction */
+unsigned int __clz(unsigned int bitvector)
+{
+	unsigned int x = 0;
+	while((!(bitvector & ((unsigned)1 << 31))) && (x < 32)) {
+		bitvector <<= 1;
+		x++;
+	}
+	return x;
+}
+

tasks/libmem/tests/clz.h

@@ -0,0 +1,7 @@
+
+#ifndef __CLZ_H__
+#define __CLZ_H__
+
+unsigned int __clz(unsigned int bitvector);
+
+#endif /* __CLZ_H__ */

tasks/libmem/tests/debug.c

@@ -0,0 +1,33 @@
+#include "debug.h"
+#include <stdio.h>
+
+void print_page_area_list(struct page_allocator *p)
+{
+	struct page_area *area;
+
+	list_for_each_entry (area, &p->page_area_list, list) {
+		printf("%-20s\n%-20s\n", "Page area:","-------------------------");
+		printf("%-20s %u\n", "Pfn:", area->pfn);
+		printf("%-20s %d\n", "Used:", area->used);
+		printf("%-20s %d\n\n", "Number of pages:", area->numpages);
+	}
+}
+
+void print_km_area(struct km_area *s)
+{
+	printf("%-20s\n%-20s\n", "Subpage area:","-------------------------");
+	printf("%-20s 0x%lu\n", "Addr:", s->vaddr);
+	printf("%-20s 0x%lu\n", "Size:", s->size);
+	printf("%-20s %d\n", "Used:", s->used);
+	printf("%-20s %d\n\n", "Head_of_pages:", s->pg_alloc_pages);
+
+}
+
+void print_km_area_list(struct list_head *km_areas)
+{
+	struct km_area *area;
+
+	list_for_each_entry (area, km_areas, list)
+		print_km_area(area);
+}
+

tasks/libmem/tests/debug.h

@@ -0,0 +1,17 @@
+#ifndef __DEBUG_H__
+#define __DEBUG_H__
+
+#include <kmalloc/kmalloc.h>
+#include <mm/alloc_page.h>
+#include <l4/lib/list.h>
+
+#if defined(DEBUG)
+#define dprintf	printf
+#else
+#define dprintf(...)
+#endif
+
+void print_page_area_list(struct page_allocator *p);
+void print_km_area_list(struct list_head *s);
+void print_km_area(struct km_area *s);
+#endif /* DEBUG_H */

tasks/libmem/tests/libl4.c

@@ -0,0 +1,28 @@
+
+#include "libl4.h"
+
+unsigned long virt_to_phys(unsigned long addr)
+{
+	return addr;
+}
+
+unsigned long phys_to_virt(unsigned long addr)
+{
+	return addr;
+}
+
+u32 l4_getpid(unsigned int *a, unsigned int *b, unsigned int *c)
+{
+	return 0;
+}
+
+u32 l4_unmap(unsigned long a, unsigned long b, u32 npages)
+{
+	return 0;
+}
+
+u32 l4_map(unsigned long a, unsigned long b, u32 size, u32 flags, unsigned int tid)
+{
+	return 0;
+}
+

tasks/libmem/tests/libl4.h

@@ -0,0 +1,17 @@
+/*
+ * Mock-up l4 library definitions for host testing.
+ *
+ */
+#ifndef __TESTS_LIBL4_H__
+#define __TESTS_LIBL4_H__
+
+#include <l4/macros.h>
+#include <l4/config.h>
+#include <l4/types.h>
+
+u32 l4_map(unsigned long phys, unsigned long virt, u32 size, u32 flags, u32 tid);
+u32 l4_unmap(unsigned long a, unsigned long b, u32 npages);
+u32 l4_getpid(unsigned int *a, unsigned int *b, unsigned int *c);
+
+
+#endif

tasks/libmem/tests/main.c

@@ -0,0 +1,250 @@
+#include <stdio.h>
+#include <malloc.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <l4/macros.h>
+#include <l4/config.h>
+#include <kmalloc/kmalloc.h>
+#include <mm/alloc_page.h>
+
+#include INC_SUBARCH(mm.h)
+#include INC_ARCH(linker.h)
+#include INC_PLAT(printascii.h)
+#include INC_PLAT(offsets.h)
+#include INC_GLUE(memlayout.h)
+
+#include "tests.h"
+#include "test_kmalloc.h"
+#include "test_allocpage.h"
+#include "test_memcache.h"
+#include "clz.h"
+#include "memory.h"
+#include "libl4.h"
+#include "debug.h"
+
+unsigned int TEST_PHYSMEM_TOTAL_PAGES = 250;
+unsigned int TEST_PHYSMEM_TOTAL_SIZE;
+unsigned int PHYS_MEM_START;
+unsigned int PHYS_MEM_END;
+
+void *malloced_test_memory;
+
+void memory_initialise(void)
+{
+	init_page_allocator(PHYS_MEM_START, PHYS_MEM_END);
+	kmalloc_init();
+}
+
+/* Allocating memory from the host C library, and
+ * it is used as if it is the physical memory available
+ * on the system.
+ */
+void alloc_test_memory()
+{
+	TEST_PHYSMEM_TOTAL_SIZE = (PAGE_SIZE * TEST_PHYSMEM_TOTAL_PAGES);
+
+	if (!(malloced_test_memory = malloc(TEST_PHYSMEM_TOTAL_SIZE)))
+		printf("Host system out of memory.\n");
+	PHYS_MEM_START = (unsigned int)malloced_test_memory;
+	PHYS_MEM_END = PHYS_MEM_START + TEST_PHYSMEM_TOTAL_SIZE;
+	PHYS_MEM_START = page_align_up(PHYS_MEM_START);
+	PHYS_MEM_END = page_align(PHYS_MEM_END);
+	/* Normally _end is to know where the loaded kernel image
+	 * ends in physical memory, so the system can start allocating
+	 * physical memory from there. Because in our mock-up there's no
+	 * used space in the malloc()'ed memory, _end is the same as the
+	 * beginning of malloc()'ed memory.
+	 */
+	_end = PHYS_MEM_START;
+
+	dprintf("Initialising physical memory\n");
+	dprintf("Initialising allocators:\n");
+	memory_initialise();
+
+}
+
+struct cmdline_opts {
+	char run_allocator;
+	int allocations;
+	int alloc_size_max;
+	int physmem_pages;
+	int page_size;
+	int no_of_pages;
+	char *finit_path;
+	char *fexit_path;
+} options;
+
+int check_options_validity(struct cmdline_opts *opts)
+{
+	if (opts->allocations <= 0) {
+		printf("Invalid number of allocations: %d\n", opts->allocations);
+		return -1;
+	}
+	if (opts->no_of_pages <= 0) {
+		printf("Invalid number of pages: %d\n", opts->no_of_pages);
+		return -1;
+	}
+	if (opts->alloc_size_max <= 0) {
+		printf("Invalid alloc_size_max: %d\n", opts->alloc_size_max);
+		return -1;
+	}
+	if (opts->page_size <= 0) {
+		printf("Invalid page_size: %d\n", opts->page_size);
+		return -1;
+	}
+	return 0;
+}
+
+void print_options(struct cmdline_opts *opts)
+{
+	dprintf("Running: %s\n",
+	       ((opts->run_allocator == 'p') ? "page allocator" :
+		((opts->run_allocator == 'k') ? "kmalloc/kfree" :
+		 "memcache allocator")));
+	dprintf("Total allocations: %d\n", opts->allocations);
+	dprintf("Maximum allocation size: %d, 0x%x(hex)\n\n",
+	       opts->alloc_size_max, opts->alloc_size_max);
+	dprintf("Initial state file: %s\n", opts->finit_path);
+	dprintf("Exit state file: %s\n", opts->fexit_path);
+
+}
+
+void display_help(void)
+{
+	printf("Main:\n");
+	printf("\tUsage:\n");
+	printf("\tmain\t-a=<p>|<k>|<m> [-n=<number of allocations>] [-s=<maximum size for any allocation>]\n"
+	       "\t\t[-fi=<file to dump init state>] [-fx=<file to dump exit state>]\n"
+	       "\t\t[-ps=<page size>] [-pn=<total number of pages>]\n");
+	printf("\n");
+}
+
+int get_cmdline_opts(int argc, char *argv[], struct cmdline_opts *opts)
+{
+	int parsed = 0;
+
+	memset(opts, 0, sizeof (struct cmdline_opts));
+	if (argc <= 1)
+		return -1;
+	for (int i = 1; i < argc; i++) {
+		if (argv[i][0] == '-' && argv[i][2] == '=') {
+			if (argv[i][1] == 'a') {
+				if (argv[i][3] == 'k' ||
+				    argv[i][3] == 'm' ||
+				    argv[i][3] == 'p') {
+					opts->run_allocator = argv[i][3];
+					parsed = 1;
+				}
+			}
+			if (argv[i][1] == 'n') {
+				opts->allocations = atoi(&argv[i][3]);
+				parsed = 1;
+			}
+			if (argv[i][1] == 's') {
+				opts->alloc_size_max = atoi(&argv[i][3]);
+				parsed = 1;
+			}
+		}
+		if (argv[i][0] == '-' && argv[i][1] == 'f'
+		    && argv[i][3] == '=') {
+			if (argv[i][2] == 'i') {
+				opts->finit_path = &argv[i][4];
+				parsed = 1;
+			}
+			if (argv[i][2] == 'x') {
+				opts->fexit_path = &argv[i][4];
+				parsed = 1;
+			}
+		}
+		if (argv[i][0] == '-' && argv[i][1] == 'p'
+		    && argv[i][3] == '=') {
+			if (argv[i][2] == 's') {
+				opts->page_size = atoi(&argv[i][4]);
+				parsed = 1;
+			}
+			if (argv[i][2] == 'n') {
+				opts->no_of_pages = atoi(&argv[i][4]);
+				parsed = 1;
+			}
+		}
+	}
+
+	if (!parsed)
+		return -1;
+	return 0;
+}
+
+void get_output_files(FILE **out1, FILE **out2,
+		      char *alloc_func_name, char *rootpath)
+{
+	char pathbuf[150];
+	char *root = "/tmp/";
+	char *initstate_prefix = "test_initstate_";
+	char *endstate_prefix = "test_endstate_";
+	char *extension = ".out";
+
+	if (!rootpath)
+		rootpath = root;
+	/* File path manipulations */
+	sprintf(pathbuf, "%s%s%s%s", rootpath, initstate_prefix, alloc_func_name, extension);
+	*out1 = fopen(pathbuf,"w+");
+	sprintf(pathbuf, "%s%s%s%s", rootpath, endstate_prefix, alloc_func_name, extension);
+	*out2 = fopen(pathbuf, "w+");
+	return;
+}
+
+int main(int argc, char *argv[])
+{
+	FILE *finit, *fexit;
+	int output_files = 0;
+	if (get_cmdline_opts(argc, argv, &options) < 0) {
+		display_help();
+		return 1;
+	}
+	print_options(&options);
+	if (check_options_validity(&options) < 0)
+		exit(1);
+
+	if (options.finit_path && options.fexit_path) {
+		finit = fopen(options.finit_path, "w+");
+		fexit = fopen(options.fexit_path, "w+");
+		output_files = 1;
+	}
+	if (options.page_size) {
+		PAGE_SIZE = options.page_size;
+		PAGE_MASK = PAGE_SIZE - 1;
+		PAGE_BITS = 32 - __clz(PAGE_MASK);
+		dprintf("Using: Page Size: %d\n", PAGE_SIZE);
+		dprintf("Using: Page Mask: 0x%x\n", PAGE_MASK);
+		dprintf("Using: Page Bits: %d\n", PAGE_BITS);
+	}
+	if (options.no_of_pages) {
+		dprintf("Using: Total pages: %d\n", options.no_of_pages);
+		TEST_PHYSMEM_TOTAL_PAGES = options.no_of_pages;
+	}
+	alloc_test_memory();
+	if (options.run_allocator == 'p') {
+		if (!output_files)
+			get_output_files(&finit, &fexit, "alloc_page", 0);
+		test_allocpage(options.allocations, options.alloc_size_max,
+			       finit, fexit);
+	} else if (options.run_allocator == 'k') {
+		if (!output_files)
+			get_output_files(&finit, &fexit, "kmalloc", 0);
+		test_kmalloc(options.allocations, options.alloc_size_max,
+			     finit, fexit);
+	} else if (options.run_allocator == 'm') {
+		if (!output_files)
+			get_output_files(&finit, &fexit, "memcache", 0);
+		test_memcache(options.allocations, options.alloc_size_max,
+			      finit, fexit, 1);
+	} else {
+		printf("Invalid allocator option.\n");
+	}
+	free((void *)malloced_test_memory);
+	fclose(finit);
+	fclose(fexit);
+	return 0;
+}
+

tasks/libmem/tests/memory.c

@@ -0,0 +1,9 @@
+#include <l4/macros.h>
+#include <l4/config.h>
+#include <l4/types.h>
+#include INC_GLUE(memory.h)
+
+unsigned int PAGE_SIZE = TEST_PAGE_SIZE;
+unsigned int PAGE_MASK = TEST_PAGE_MASK;
+unsigned int PAGE_BITS = TEST_PAGE_BITS;
+

tasks/libmem/tests/test_alloc_generic.c

@@ -0,0 +1,216 @@
+/*
+ * Generic random allocation/deallocation test
+ *
+ * Copyright 2007 (C) Bahadir Balban
+ *
+ */
+#include <l4/macros.h>
+#include <l4/config.h>
+#include <l4/types.h>
+#include INC_GLUE(memory.h)
+
+#include <l4/lib/list.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include "test_alloc_generic.h"
+#include "debug.h"
+
+void print_test_state(unsigned int title,
+		      print_alloc_state_t print_allocator_state)
+{
+	switch (title) {
+		case TEST_STATE_BEGIN:
+			printf("=================\n"
+				"===== BEGIN =====\n"
+				"=================\n\n");
+			break;
+		case TEST_STATE_MIDDLE:
+			printf("==================\n"
+				"===== MIDDLE =====\n"
+				"==================\n\n");
+			break;
+		case TEST_STATE_END:
+			printf("===========\n"
+				"=== END ===\n"
+				"===========\n\n");
+			break;
+		case TEST_STATE_ERROR:
+			printf("=================\n"
+				"===== ERROR =====\n"
+				"=================\n\n");
+			break;
+		default:
+			printf("Title error.\n");
+	}
+	print_allocator_state();
+}
+
+void get_output_filepaths(FILE **out1, FILE **out2,
+			  char *alloc_func_name)
+{
+	char pathbuf[150];
+	char *rootpath = "/tmp/";
+	char *initstate_prefix = "test_initstate_";
+	char *endstate_prefix = "test_endstate_";
+	char *extention = ".out";
+
+	/* File path manipulations */
+	sprintf(pathbuf, "%s%s%s%s", rootpath, initstate_prefix, alloc_func_name, extention);
+	*out1 = fopen(pathbuf,"w+");
+	sprintf(pathbuf, "%s%s%s%s", rootpath, endstate_prefix, alloc_func_name, extention);
+	*out2 = fopen(pathbuf, "w+");
+	return;
+}
+
+/* This function is at the heart of generic random allocation testing.
+ * It is made as simple as possible, and can be used for testing all
+ * allocators. It randomly allocates/deallocates data and prints out
+ * the outcome of the action. Here are a few things it does and doesn't
+ * do:
+ * - It does not test false input on the allocators, e.g. attempting
+ *   to free an address that hasn't been allocated, or attempting to
+ *   free address 0.
+ * - It does capture and compare initial and final states of the
+ *   allocators' internal structures after all allocations are freed.
+ *   This is done by comparing two files filled with allocator state
+ *   by functions supplied by the allocators themselves.
+ * - It expects the allocator NOT to run out of memory.
+ */
+int
+test_alloc_free_random_order(const int MAX_ALLOCATIONS,
+			     const int ALLOC_SIZE_MAX,
+			     alloc_func_t alloc,
+			     free_func_t free,
+			     print_alloc_state_t print_allocator_state,
+			     FILE *state_init_file, FILE *state_end_file)
+{
+	/* The last element in full_state that tells about any full index.
+	 * This is the limit the random deallocation would use to find a full
+	 * index */
+	int random_size;
+	int random_action;
+	int random_index;
+	int alloc_so_far = 0;
+	int full_state_last = -1;
+	int halfway_through = 0;
+	FILE * const default_stdout = stdout;
+	/* Memory pointers */
+	void *mem[MAX_ALLOCATIONS];
+	/* Each element keeps track of one currently full index number */
+	int full_state[MAX_ALLOCATIONS];
+
+	/* Check arguments first */
+	if (!MAX_ALLOCATIONS || !ALLOC_SIZE_MAX || !alloc || !free
+	    || !print_allocator_state || !state_init_file || !state_end_file) {
+		printf("Invalid arguments to %s()\n", __FUNCTION__);
+		return 1;
+	}
+	memset(mem, 0, MAX_ALLOCATIONS * sizeof(void *));
+	memset(full_state, 0, MAX_ALLOCATIONS * sizeof(int));
+
+	//print_test_state(TEST_STATE_BEGIN, print_allocator_state);
+	stdout = state_init_file;
+	print_test_state(TEST_STATE_BEGIN, print_allocator_state);
+	stdout = default_stdout;
+
+	/* Randomly either allocate/deallocate at a random
+	 * index, of random size */
+	srand(time(0));
+
+	while (1) {
+		if (alloc_so_far < (MAX_ALLOCATIONS / 2)) {
+			/* Give more chance to allocations at the beginning */
+			if ((rand() % 4) == 0)	/* 1/4 chance */
+				random_action = FREE;
+			else			/* 3/4 chance */
+				random_action = ALLOCATE;
+		} else {
+			if (!halfway_through) {
+#if defined (DEBUG)
+					print_test_state(TEST_STATE_MIDDLE,
+						 	 print_allocator_state);
+#endif
+				halfway_through = 1;
+			}
+			/* Give more chane to freeing after halfway-through */
+			if ((rand() % 3) == 0)  /* 1/3 chance */
+				random_action = ALLOCATE;
+			else			/* 2/3 chance */
+				random_action = FREE;
+		}
+		random_size = (rand() % (ALLOC_SIZE_MAX-1)) + 1;
+
+		if (random_action == ALLOCATE) {
+			if (alloc_so_far < MAX_ALLOCATIONS) {
+				alloc_so_far++;
+				for (int i = 0; i < MAX_ALLOCATIONS; i++) {
+					if (mem[i] == 0) {			// Find the first empty slot.
+						int allocation_error =
+							((mem[i] = alloc(random_size)) <= 0);
+						dprintf("%-12s%-8s%-12p%-8s%-10d\n",
+						       "alloc:", "addr:", mem[i],
+						       "size:", random_size);
+						if (allocation_error) {
+							print_test_state(TEST_STATE_ERROR,
+									 print_allocator_state);
+							if (mem[i] < 0) {
+								printf("Error: alloc() returned negative value\n");
+								BUG();
+							} else if (mem[i] == 0) {
+								printf("Error: Allocator is out of memory.\n");
+								return 1;
+							}
+						}
+						full_state_last++;
+						full_state[full_state_last] = i;
+						break;
+					}
+				}
+			} else
+				random_action = FREE;
+		}
+
+		if (random_action == FREE) {
+			/* all are free, can't free anymore */
+			if (full_state_last < 0)
+				continue;
+			else if (full_state_last > 0)
+				random_index = rand() % full_state_last;
+			else
+				random_index = 0; /* Last item */
+
+			if(mem[full_state[random_index]] == 0)
+				BUG();
+
+			if (free(mem[full_state[random_index]]) < 0)
+				BUG();
+			dprintf("%-12s%-8s%-12p\n","free:",
+			       "addr:",  mem[full_state[random_index]]);
+			mem[full_state[random_index]] = 0;
+
+			/* Fill in the empty gap with last element */
+			full_state[random_index] = full_state[full_state_last];
+			/* Last element now in the gap
+			 * (somewhere inbetween first and last) */
+			full_state[full_state_last] = 0;
+			/* One less in the number of full items */
+			full_state_last--;
+		}
+
+		/* Check that all allocations and deallocations took place */
+		if (alloc_so_far == MAX_ALLOCATIONS && full_state_last < 0) {
+			for (int i = 0; i < MAX_ALLOCATIONS; i++)
+				BUG_ON(full_state[i] != 0);		// A final sanity check.
+			break;
+		}
+	}
+
+	//print_test_state(TEST_STATE_END, print_allocator_state);
+	stdout = state_end_file;
+	print_test_state(TEST_STATE_BEGIN, print_allocator_state);
+	stdout = default_stdout;
+	return 0;
+}
+

tasks/libmem/tests/test_alloc_generic.h

@@ -0,0 +1,29 @@
+#ifndef __TEST_ALLOC_GENERIC_H__
+#define __TEST_ALLOC_GENERIC_H__
+
+enum test_state_title {
+	TEST_STATE_BEGIN = 0,
+	TEST_STATE_MIDDLE,
+	TEST_STATE_END,
+	TEST_STATE_ERROR
+};
+
+typedef void (*print_alloc_state_t)(void);
+typedef void *(*alloc_func_t)(int size);
+typedef int (*free_func_t)(void *addr);
+
+enum alloc_action {
+	FREE = 0,
+	ALLOCATE = 1,
+};
+
+void get_output_filepaths(FILE **out1, FILE **out2,
+			  char *alloc_func_name);
+
+int test_alloc_free_random_order(const int MAX_ALLOCATIONS,
+				 const int ALLOC_SIZE_MAX,
+				 alloc_func_t alloc, free_func_t free,
+				 print_alloc_state_t print_allocator_state,
+				 FILE *init_state, FILE *exit_state);
+
+#endif /* __TEST_ALLOC_GENERIC_H__ */

tasks/libmem/tests/test_allocpage.c

@@ -0,0 +1,85 @@
+/*
+ * Testing code for the page allocator.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+#include <l4/macros.h>
+#include <l4/config.h>
+#include <l4/types.h>
+#include <l4/lib/list.h>
+#include INC_GLUE(memory.h)
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include "test_allocpage.h"
+#include "test_alloc_generic.h"
+#include "debug.h"
+
+unsigned int PAGE_ALLOCATIONS =	30;
+unsigned int PAGE_ALLOC_SIZE_MAX = 8;
+
+extern struct page_allocator allocator;
+
+void print_page_area(struct page_area *a, int areano)
+{
+	printf("Area starts @: 0x%lu, %s, numpages: %d\n",
+	       __pfn_to_addr(a->pfn),
+	       (a->used) ? "used" : "unused", a->numpages);
+	return;
+}
+
+void print_areas(struct list_head *area_head)
+{
+	struct page_area *cur;
+	int areano = 1;
+
+	printf("Page areas:\n-------------\n");
+	list_for_each_entry(cur, area_head, list)
+		print_page_area(cur, areano++);
+}
+
+void print_cache(struct mem_cache *c, int cacheno)
+{
+	printf("Cache %d state:\n-------------\n", cacheno);
+	printf("Total: %d\n", c->total);
+	printf("Free: %d\n", c->free);
+	printf("Start: 0x%x\n", c->start);
+}
+
+void print_caches(struct list_head *cache_head)
+{
+	int caches = 1;
+	struct mem_cache *cur;
+
+	list_for_each_entry(cur, cache_head, list)
+		print_cache(cur, caches++);
+}
+
+void print_page_allocator_state(void)
+{
+	print_areas(&allocator.page_area_list);
+	printf("Data Cache:\n--------\n");
+	print_caches(&allocator.dcache_list);
+	printf("Cache Cache:\n----------\n");
+	print_caches(&allocator.ccache_list);
+}
+
+/* FIXME: with current default parameters (allocations = 30, sizemax = 8),
+ * for some odd reason, we got the bug at line 280 in alloc_page.c.
+ * Very weird. Find out why.
+ */
+void test_allocpage(int page_allocations, int page_alloc_size_max,
+		    FILE *init_state, FILE *exit_state)
+{
+	//if (!page_allocations)
+	//	page_allocations = PAGE_ALLOCATIONS;
+	//if (!page_alloc_size_max)
+	//	page_alloc_size_max = PAGE_ALLOC_SIZE_MAX;
+
+	dprintf("\nPAGE ALLOCATOR TEST:====================================\n\n");
+	test_alloc_free_random_order(page_allocations, page_alloc_size_max,
+				     alloc_page, free_page,
+				     print_page_allocator_state,
+				     init_state, exit_state);
+}

tasks/libmem/tests/test_allocpage.h

@@ -0,0 +1,13 @@
+#ifndef __TEST_ALLOCPAGE_H__
+#define __TEST_ALLOCPAGE_H__
+
+#include <mm/alloc_page.h>
+#include "tests.h"
+
+void test_allocpage(int num_allocs, int alloc_max, FILE *init, FILE *exit);
+void print_page_area(struct page_area *a, int no);
+void print_caches(struct list_head *cache_head);
+void print_cache(struct mem_cache *c, int cacheno);
+void print_areas(struct list_head *area_head);
+void print_page_area(struct page_area *ar, int areano);
+#endif

tasks/libmem/tests/test_kmalloc.c

@@ -0,0 +1,42 @@
+/*
+ * Testing code for the kmalloc allocator.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+#include <l4/macros.h>
+#include <l4/config.h>
+#include <l4/types.h>
+#include <l4/lib/list.h>
+#include INC_GLUE(memory.h)
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "test_alloc_generic.h"
+#include "test_allocpage.h"
+#include "debug.h"
+#include "tests.h"
+
+extern struct list_head km_area_start;
+
+void print_kmalloc_state(void)
+{
+	print_km_area_list(&km_area_start);
+}
+
+void test_kmalloc(int kmalloc_allocations, int kmalloc_alloc_size_max,
+		  FILE *init_state, FILE *exit_state)
+{
+	unsigned int KMALLOC_ALLOCATIONS = 20;
+	unsigned int KMALLOC_ALLOC_SIZE_MAX = (PAGE_SIZE * 3);
+
+	if (!kmalloc_allocations)
+		kmalloc_allocations = KMALLOC_ALLOCATIONS;
+	if (!kmalloc_alloc_size_max)
+		kmalloc_alloc_size_max = KMALLOC_ALLOC_SIZE_MAX;
+
+	test_alloc_free_random_order(kmalloc_allocations, kmalloc_alloc_size_max,
+				     kmalloc, kfree, print_kmalloc_state,
+				     init_state, exit_state);
+}
+

tasks/libmem/tests/test_kmalloc.h

@@ -0,0 +1,8 @@
+#ifndef __TEST_KMALLOC_H__
+#define __TEST_KMALLOC_H__
+
+#include <kmalloc/kmalloc.h>
+
+void test_kmalloc(int num_allocs, int allocs_max, FILE *initstate, FILE *exitstate);
+
+#endif

tasks/libmem/tests/test_memcache.c

@@ -0,0 +1,115 @@
+/*
+ * Testing code for the memcache structure.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+#include <time.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memcache/memcache.h>
+#include "test_memcache.h"
+#include "test_alloc_generic.h"
+#include "debug.h"
+#include "tests.h"
+
+#include <l4/macros.h>
+#include <l4/config.h>
+#include <l4/types.h>
+#include <l4/lib/list.h>
+#include INC_GLUE(memory.h)
+
+unsigned int MEM_CACHE_SIZE;
+
+struct mem_cache *this;
+
+void *buffer;
+
+void *mem_cache_alloc_wrapped(int size)
+{
+	return mem_cache_alloc(this);
+}
+
+int mem_cache_free_wrapped(void *addr)
+{
+	return mem_cache_free(this, addr);
+}
+
+void print_memcache_state(void)
+{
+	printf("%-15s%d\n","Total:", this->total);
+	printf("%-15s%d\n","Free:", this->free);
+	printf("Bitmap has %d words:\n", BITWISE_GETWORD(this->total) + 1);
+	for (int i = 0; i <= BITWISE_GETWORD(this->total); i++)
+		printf("0x%x\n", this->bitmap[i]);
+}
+
+int test_memcache_init_aligned(int *items_max, int item_size)
+{
+	if (item_size * 10 > MEM_CACHE_SIZE)
+		MEM_CACHE_SIZE = item_size * 10;
+	if (!(buffer = calloc(1, MEM_CACHE_SIZE))) {
+		printf("System out of memory.\n");
+		BUG();
+	}
+	if ((this = mem_cache_init(buffer, MEM_CACHE_SIZE,
+				   item_size, 1)) == 0) {
+		printf("Unable to initialise cache.\n");
+		return -1;
+	}
+	*items_max = mem_cache_total_empty(this);
+	printf("\nMEMCACHE TEST: ALIGNED ELEMENTS\n==========================\n");
+	printf("%-30s%d\n", "Item size:", item_size);
+	printf("%-30s0x%x\n", "Cache occupied space:", MEM_CACHE_SIZE);
+	printf("%-30s%d\n","Total items in cache:", *items_max);
+	printf("%-30s0x%x\n","Total items space:", (*items_max * item_size));
+	return 0;
+}
+
+
+int test_memcache_init(int *items_max, int item_size)
+{
+	if (item_size * 10 > MEM_CACHE_SIZE)
+		MEM_CACHE_SIZE = item_size * 10;
+	printf("%s: Allocating cache memory.\n",__FUNCTION__);
+	if (!(buffer = calloc(1, MEM_CACHE_SIZE))) {
+		printf("System out of memory.\n");
+		BUG();
+	}
+	if ((this = mem_cache_init(buffer, MEM_CACHE_SIZE,
+				   item_size, 0)) == 0) {
+		printf("Unable to initialise cache.\n");
+		return -1;
+	}
+	*items_max = mem_cache_total_empty(this);
+	printf("\nMEMCACHE TEST:\n========================\n");
+	printf("%-30s%d\n", "Item size:", item_size);
+	printf("%-30s0x%x\n", "Cache occupied space:", MEM_CACHE_SIZE);
+	printf("%-30s%d\n","Total items in cache:", *items_max);
+	printf("%-30s0x%x\n","Total items space:", (*items_max * item_size));
+	return 0;
+}
+
+int test_memcache(int items_max, int item_size, FILE *init_state, FILE *exit_state, int aligned)
+{
+	const unsigned int TEST_CACHE_ITEM_SIZE = 5;
+	MEM_CACHE_SIZE = PAGE_SIZE * 5;
+	if (!item_size)
+		item_size = TEST_CACHE_ITEM_SIZE;
+	/* items_max value is ignored and overwritten because caches have fixed size. */
+	test_memcache_init(&items_max, item_size);
+	test_alloc_free_random_order(items_max, /* unused */ 2, mem_cache_alloc_wrapped,
+				     mem_cache_free_wrapped, print_memcache_state,
+				     init_state, exit_state);
+	free(buffer);
+	if (aligned) {
+		test_memcache_init_aligned(&items_max, item_size);
+		test_alloc_free_random_order(items_max, /* unused */ 2, mem_cache_alloc_wrapped,
+					     mem_cache_free_wrapped, print_memcache_state,
+					     init_state, exit_state);
+	}
+	free(buffer);
+	return 0;
+}
+
+

tasks/libmem/tests/test_memcache.h

@@ -0,0 +1,10 @@
+#ifndef __TEST_MEMCACHE_H__
+#define __TEST_MEMCACHE_H__
+
+#include <memcache/memcache.h>
+
+int test_memcache(int num_alloc, int alloc_size_max, FILE *initstate, FILE *exitstate, int aligned);
+
+
+#endif /* __TEST_MEMCACHE_H__ */
+

tasks/libmem/tests/tests.h

@@ -0,0 +1,21 @@
+#ifndef __TESTS_H__
+#define __TESTS_H__
+
+/* Mock-up physical memory */
+extern unsigned int TEST_PHYSMEM_TOTAL_PAGES;
+extern unsigned int TEST_PHYSMEM_TOTAL_SIZE;
+
+/* Allocator test */
+extern unsigned int PAGE_ALLOCATIONS;
+extern unsigned int PAGE_ALLOC_SIZE_MAX;
+
+/* Memcache test */
+extern unsigned int MEMCACHE_ALLOCS_MAX;
+extern unsigned int TEST_CACHE_ITEM_SIZE;
+
+/* Kmalloc */
+extern unsigned int KMALLOC_ALLOCATIONS;
+extern unsigned int KMALLOC_ALLOC_SIZE_MAX;
+
+
+#endif /* __TESTS_H__ */