/*
 * Copyright 2025, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


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

#include <OS.h>

#include <util/SimpleAllocator.h>


static SimpleAllocator<> sAllocator;
const int32	kHeapSize = (1024 + 512) * 1024;


static void*
test_malloc(size_t bytes)
{
	return sAllocator.Allocate(bytes);
}


static void*
test_realloc(void* oldBuffer, size_t size)
{
	return sAllocator.Reallocate(oldBuffer, size);
}


static void
test_free(void* buffer)
{
	sAllocator.Free(buffer);
}


enum {
	OP_INVALID = 0,
	OP_MALLOC,
	OP_REALLOC,
	OP_FREE,
};
struct AllocationOperation {
	uint8 operation;
	// uint8 _unused[3];
	uint32 value;
};
#include "heap_allocation_operations.h"


int
main(int argc, char* argv[])
{
	void* base = malloc(kHeapSize);
	if (base == NULL) {
		fprintf(stderr, "Could not initialize heap.\n");
		return -1;
	}
	sAllocator.AddChunk(base, kHeapSize);

	void** allocations = (void**)malloc(kAllocationsCount * sizeof(void*));
	int allocationCounter = 0;

	const bigtime_t start = system_time();
	for (size_t i = 0; i < B_COUNT_OF(kOperations); i++) {
		switch (kOperations[i].operation) {
			case OP_MALLOC: {
				int index = allocationCounter++;
				allocations[index] = test_malloc(kOperations[i].value);
				break;
			}
			case OP_REALLOC: {
				int index = kOperations[i++].value;
				int newSize = kOperations[i].value;
				allocations[index] = test_realloc(allocations[index], newSize);
				break;
			}
			case OP_FREE: {
				int index = kOperations[i].value;
				test_free(allocations[index]);
				allocations[index] = NULL;
				break;
			}
		}
	}
	printf("completed %" B_PRIuSIZE " operations in %" B_PRIdBIGTIME " usec\n",
		B_COUNT_OF(kOperations), system_time() - start);

	free(base);
	return 0;
}