haiku.git

#include <SupportDefs.h>
#include <OS.h>

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


#ifdef MALLOC_DEBUG
void dump_heap_list(int argc, char **argv);
void dump_allocations(bool statsOnly, thread_id thread);
#endif


inline uint8
sum(addr_t address)
{
	return (address >> 24) | (address >> 16) | (address >> 8) | address;
}


inline void
write_test_pattern(void *address, size_t size)
{
	for (size_t i = 0; i < size; i++)
		*((uint8 *)address + i) = sum((addr_t)address + i);
}


inline void
verify_test_pattern(void *address, size_t size)
{
	for (size_t i = 0; i < size; i++) {
		if (*((uint8 *)address + i) != sum((addr_t)address + i)) {
			printf("test patern invalid at %p: %u vs. %u\n",
				(uint8 *)address + i, *((uint8 *)address + i),
				sum((addr_t)address + i));
			exit(1);
		}
	}
}


void
allocate_random_no_alignment(int32 count, size_t maxSize)
{
	void **allocations = new void *[count];
	size_t *sizes = new size_t[count];
	for (int32 i = 0; i < count; i++) {
		sizes[i] = rand() % maxSize;
		allocations[i] = malloc(sizes[i]);
		if (allocations[i] == NULL) {
			printf("allocation of %lu bytes failed\n", sizes[i]);
			exit(1);
		}
#ifdef __x86_64__
		if (((addr_t)allocations[i] & 0xf) != 0) {
			printf("allocation %p not aligned failed\n",
				allocations[i]);
			exit(1);
		}
#endif
		write_test_pattern(allocations[i], sizes[i]);
	}

	for (int32 i = count - 1; i >= 0; i--) {
		verify_test_pattern(allocations[i], sizes[i]);
		free(allocations[i]);
	}

	delete[] allocations;
	delete[] sizes;
}


void
allocate_random_fixed_alignment(int32 count, size_t maxSize, size_t alignment)
{
	void **allocations = new void *[count];
	size_t *sizes = new size_t[count];
	for (int32 i = 0; i < count; i++) {
		sizes[i] = rand() % maxSize;
		allocations[i] = memalign(alignment, sizes[i]);
		if (allocations[i] == NULL) {
			printf("allocation of %lu bytes failed\n", sizes[i]);
			exit(1);
		}

		if ((addr_t)allocations[i] % alignment != 0) {
			printf("allocation of %lu bytes misaligned: %p -> 0x%08lx "
				" with alignment %lu (0x%08lx)\n", sizes[i],
				allocations[i], (addr_t)allocations[i] % alignment, alignment,
				alignment);
			exit(1);
		}

		write_test_pattern(allocations[i], sizes[i]);
	}

	for (int32 i = count - 1; i >= 0; i--) {
		verify_test_pattern(allocations[i], sizes[i]);
		free(allocations[i]);
	}

	delete[] allocations;
	delete[] sizes;
}


void
allocate_random_random_alignment(int32 count, size_t maxSize)
{
	for (int32 i = 0; i < count / 128; i++)
		allocate_random_fixed_alignment(128, maxSize, 1 << (rand() % 18));
}


int
main(int argc, char *argv[])
{
	allocate_random_no_alignment(1024, B_PAGE_SIZE * 128);
	allocate_random_random_alignment(1024, B_PAGE_SIZE * 128);

#ifdef MALLOC_DEBUG
	dump_heap_list(0, NULL);
	dump_allocations(false, -1);
#endif

	printf("tests succeeded\n");
	return 0;
}