main.cpp

#include "xallocator.h"
#include "Fault.h"
#include <new>
#include <iostream>
#include <string.h>

// @see https://github.com/endurodave/xallocator
// David Lafreniere

// On VisualStudio, to disable the debug heap for faster performance when using
// the debugger use this option:
// Debugging > Environment _NO_DEBUG_HEAP=1

class MyClass 
{
	XALLOCATOR
	// remaining class definition
};

class MyClassStatic
{
public:
	MyClassStatic() { memory = xmalloc(100); }
	~MyClassStatic() { xfree(memory); }
private:
	void* memory;
};
static MyClassStatic myClassStatic;

static void out_of_memory()
{
	// new-handler function called by Allocator when pool is out of memory
	ASSERT();
}

static const int MAX_BLOCK_SIZE = 4000;
static const int MAX_ALLOCATIONS = 10000;
static void* memoryPtrs[MAX_ALLOCATIONS];
static void* memoryPtrs2[MAX_ALLOCATIONS];

typedef void* (*AllocFunc)(size_t size);
typedef void (*DeallocFunc)(void* ptr);
void Benchmark(const char* name, AllocFunc allocFunc, DeallocFunc deallocFunc);

//------------------------------------------------------------------------------
// _tmain
//------------------------------------------------------------------------------
int main(void)
{
	srand(1);
	std::set_new_handler(out_of_memory);

	// If AUTOMATIC_XALLOCATOR_INIT_DESTROY defined then XallocInitDestroy() will 
	// call xalloc_init() automatically before main(). 
	//xalloc_init();	

	// Allocate MyClass using fixed block allocator
	MyClass* myClass = new MyClass();
	delete myClass;

    // Allocate MyClass array using fixed block allocator
    MyClass* myClassArr = new MyClass[5];
    delete [] myClassArr;

    // Allocate raw memory using fixed block allocator then create
    // MyClass with placement new
    void* raw = xmalloc(sizeof(MyClass));
    MyClass* myClassPlacement = new(raw) MyClass();
    delete myClassPlacement;

	void* memory1 = xmalloc(100);	
	xfree(memory1);

	char* memory2 = (char*)xmalloc(24);	
	strcpy(memory2, "TEST STRING");
	memory2 = (char*)xrealloc(memory2, 124);
	xfree(memory2);
	
	// Benchmark will cause out_of_memory to be called if STATIC_POOLS defined
	Benchmark("malloc/free (Run 1)", malloc, free);
	Benchmark("malloc/free (Run 2)", malloc, free);
	Benchmark("malloc/free (Run 3)", malloc, free);
	Benchmark("xmalloc/xfree (Run 1)", xmalloc, xfree);
	Benchmark("xmalloc/xfree (Run 2)", xmalloc, xfree);
	Benchmark("xmalloc/xfree (Run 3)", xmalloc, xfree);

	xalloc_stats();

	// If AUTOMATIC_XALLOCATOR_INIT_DESTROY is defined, ~XallocDestroy() will call 
	// xalloc_destroy() automatically. Never call xalloc_destroy() manually except if
	// using xallocator in a C-only application. 
	//xalloc_destroy();
	return 0;
}

//------------------------------------------------------------------------------
// Benchmark
//------------------------------------------------------------------------------
void Benchmark(const char* name, AllocFunc allocFunc, DeallocFunc deallocFunc)
{
#if WIN32
	LARGE_INTEGER StartingTime, EndingTime, ElapsedMicroseconds, TotalElapsedMicroseconds= {0};
	LARGE_INTEGER Frequency;

	SetProcessPriorityBoost(GetCurrentProcess(), true);

	QueryPerformanceFrequency(&Frequency); 

	// Allocate MAX_ALLOCATIONS blocks MAX_BLOCK_SIZE / 2 sized blocks
	QueryPerformanceCounter(&StartingTime);
	for (int i=0; i<MAX_ALLOCATIONS; i++)
		memoryPtrs[i] = allocFunc(MAX_BLOCK_SIZE / 2);
	QueryPerformanceCounter(&EndingTime);
	ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
	ElapsedMicroseconds.QuadPart *= 1000000;
	ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
	std::cout << name << " allocate time: " << ElapsedMicroseconds.QuadPart << std::endl;
	TotalElapsedMicroseconds.QuadPart += ElapsedMicroseconds.QuadPart;

	// Deallocate MAX_ALLOCATIONS blocks (every other one)
	QueryPerformanceCounter(&StartingTime);
	for (int i=0; i<MAX_ALLOCATIONS; i+=2)
		deallocFunc(memoryPtrs[i]);
	QueryPerformanceCounter(&EndingTime);
	ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
	ElapsedMicroseconds.QuadPart *= 1000000;
	ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
	std::cout << name << " deallocate time: " << ElapsedMicroseconds.QuadPart << std::endl;
	TotalElapsedMicroseconds.QuadPart += ElapsedMicroseconds.QuadPart;

	// Allocate MAX_ALLOCATIONS blocks MAX_BLOCK_SIZE sized blocks
	QueryPerformanceCounter(&StartingTime);
	for (int i=0; i<MAX_ALLOCATIONS; i++)
		memoryPtrs2[i] = allocFunc(MAX_BLOCK_SIZE);
	QueryPerformanceCounter(&EndingTime);
	ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
	ElapsedMicroseconds.QuadPart *= 1000000;
	ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
	std::cout << name << " allocate time: " << ElapsedMicroseconds.QuadPart << std::endl;
	TotalElapsedMicroseconds.QuadPart += ElapsedMicroseconds.QuadPart;

	// Deallocate MAX_ALLOCATIONS blocks (every other one)
	QueryPerformanceCounter(&StartingTime);
	for (int i=1; i<MAX_ALLOCATIONS; i+=2)
		deallocFunc(memoryPtrs[i]);
	QueryPerformanceCounter(&EndingTime);
	ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
	ElapsedMicroseconds.QuadPart *= 1000000;
	ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
	std::cout << name << " deallocate time: " << ElapsedMicroseconds.QuadPart << std::endl;
	TotalElapsedMicroseconds.QuadPart += ElapsedMicroseconds.QuadPart;

	// Deallocate MAX_ALLOCATIONS blocks 
	QueryPerformanceCounter(&StartingTime);
	for (int i=MAX_ALLOCATIONS-1; i>=0; i--)
		deallocFunc(memoryPtrs2[i]);
	QueryPerformanceCounter(&EndingTime);
	ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
	ElapsedMicroseconds.QuadPart *= 1000000;
	ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;
	std::cout << name << " deallocate time: " << ElapsedMicroseconds.QuadPart << std::endl;
	TotalElapsedMicroseconds.QuadPart += ElapsedMicroseconds.QuadPart;

	std::cout << name << " TOTAL TIME: " << TotalElapsedMicroseconds.QuadPart << std::endl;

	SetProcessPriorityBoost(GetCurrentProcess(), false);
#endif
}