toyspp

memory.cpp (6159B)

---

 #include "memory.hpp"
 
 #if defined(_WIN32)
 # include <windows.h>
 # include <memoryapi.h>
 namespace {
 	uint8_t* Win32PageAlloc(size_t size, size_t alignment)
 	{
 		assert(Test::Utility::IsPowerOfTwo(alignment));
 		assert(Test::Memory::MEM_ALIGN_4_KIB <= alignment);
 
 		uintptr_t aligned_size = Test::Utility::AlignNext(size, alignment);
 
 		DWORD prot = PAGE_READWRITE;
 		DWORD flags = MEM_RESERVE | MEM_COMMIT;
 		LPVOID ptr = VirtualAlloc(nullptr, aligned_size, flags, prot);
 
 		return (uint8_t*) ptr;
 	}
 
 	Test::Memory::MirrorAllocResult Win32MirrorAlloc(size_t size, size_t mirrors)
 	{
 		assert(Test::Utility::IsAlignedTo(size, Test::Memory::MEM_ALIGN_4_KIB));
 
 		Test::Memory::MirrorAllocResult result{};
 
 		(void) size;
 		(void) mirrors;
 
 		return result;
 	}
 }
 
 #elif defined(__linux__)
 # define _GNU_SOURCE 1
 # include <sys/mman.h>
 # include <unistd.h>
 namespace {
 	uint8_t* LinuxPageAlloc(size_t size, size_t alignment)
 	{
 		assert(Test::Utility::IsPowerOfTwo(alignment));
 		assert(Test::Memory::MEM_ALIGN_4_KIB <= alignment);
 
 		int prot = PROT_READ | PROT_WRITE;
 		int flags = MAP_PRIVATE | MAP_ANONYMOUS;
 
 		uintptr_t aligned_size = Test::Utility::AlignNext(size, alignment);
 		void *unaligned_ptr = mmap(nullptr, aligned_size, PROT_NONE, flags, -1, 0);
 		if (unaligned_ptr == MAP_FAILED)
 			return nullptr;
 
 		uintptr_t aligned_base = Test::Utility::AlignNext((uintptr_t) unaligned_ptr, alignment);
 		void *aligned_ptr = mmap((void *) aligned_base, size, prot, flags | MAP_FIXED, -1, 0);
 		assert(aligned_ptr != MAP_FAILED);
 
 		if (Test::Utility::IsAlignedTo(aligned_base, Test::Memory::MEM_ALIGN_2_MIB))
 			madvise(aligned_ptr, size, MADV_HUGEPAGE);
 
 		munmap(unaligned_ptr, aligned_base - (uintptr_t) aligned_ptr);
 
 		return (uint8_t*) aligned_ptr;
 	}
 
 	Test::Memory::MirrorAllocResult LinuxMirrorAlloc(size_t size, size_t mirrors)
 	{
 		assert(Test::Utility::IsAlignedTo(size, Test::Memory::MEM_ALIGN_4_KIB));
 
 		Test::Memory::MirrorAllocResult result{};
 
 		result.len = size;
 		result.cap = size * mirrors;
 
 		int prot = PROT_READ | PROT_WRITE;
 		int buffer_flags = MAP_PRIVATE | MAP_ANONYMOUS;
 		int mirror_flags = MAP_SHARED | MAP_FIXED;
 
 		result.memfd = memfd_create("linux mirror alloc", MFD_CLOEXEC);
 		if (result.memfd < 0) {
 			goto error;
 		}
 
 		ftruncate(result.memfd, result.cap);
 
 		result.ptr = (uint8_t*) mmap(nullptr, result.cap, PROT_NONE, buffer_flags, -1, 0);
 		if (result.ptr == MAP_FAILED) {
 			close(result.memfd);
 			goto error;
 		}
 
 		for (size_t i = 0; i < mirrors; i++) {
 			uint8_t* base = result.ptr + (result.len * i);
 			void *mirror = mmap(base, result.len, prot, mirror_flags, result.memfd, 0);
 			if (mirror == MAP_FAILED) {
 				munmap(result.ptr, result.cap);
 				close(result.memfd);
 				goto error;
 			}
 		}
 
 		return result;
 
 error:
 		result.memfd = -1;
 		result.ptr = nullptr;
 		result.len = result.cap = 0;
 
 		return result;
 	}
 }
 
 #else
 # error "Unknown platform, must be one of: windows linux"
 #endif
 
 namespace Test::Memory {
 	uint8_t *GenAlloc(size_t size, size_t alignment) {
 		assert(Utility::IsPowerOfTwo(alignment));
 
 		size_t upper_bound = size + (alignment - 1);
 
 		uintptr_t ptr = (uintptr_t) malloc(upper_bound);
 		uintptr_t res = Utility::AlignNext(ptr, alignment);
 
 		return (uint8_t *) res;
 	}
 
 	uint8_t *PageAlloc(size_t size, size_t alignment) {
 		if (alignment < MEM_ALIGN_4_KIB)
 			alignment = MEM_ALIGN_4_KIB;
 
 #if defined(_WIN32)
 		return Win32PageAlloc(size, alignment);
 #elif defined(__linux__)
 		return LinuxPageAlloc(size, alignment);
 #else
 		return nullptr;
 #endif
 	}
 
 	MirrorAllocResult MirrorAlloc(size_t size, size_t mirrors) {
 #if defined(_WIN32)
 		return Win32MirrorAlloc(size, mirrors);
 #elif defined(__linux__)
 		return LinuxMirrorAlloc(size, mirrors);
 #else
 		return nullptr;
 #endif
 	}
 
 	void LinearAlloc::Init(uint8_t *buf, size_t cap)
 	{
 		ptr = buf;
 		this->cap = cap;
 		len = 0;
 	}
 
 	void LinearAlloc::Reset()
 	{
 		len = 0;
 	}
 
 	uint8_t *LinearAlloc::AllocRaw(size_t size, size_t alignment)
 	{
 		assert(size);
 		assert(alignment);
 		assert(Utility::IsPowerOfTwo(alignment));
 
 		uintptr_t currentPtr = (uintptr_t) ptr + len;
 		uintptr_t endPtr = (uintptr_t) ptr + cap;
 
 		uintptr_t alignedPtr = Utility::AlignNext(currentPtr, alignment);
 		if (endPtr < alignedPtr + size)
 			return nullptr;
 
 		len = (alignedPtr + size) - (uintptr_t) ptr;
 
 		return (uint8_t *) alignedPtr;
 	}
 
 	void BlockAlloc::Init(uint8_t *buf, size_t cap, size_t block_size, size_t block_alignment)
 	{
 		assert(Utility::IsPowerOfTwo(block_alignment));
 		assert(Utility::IsAlignedTo((uintptr_t) buf, block_alignment));
 
 		assert(sizeof(FreeListNode) <= block_size);
 		assert(alignof(FreeListNode) <= block_alignment);
 
 		ptr = buf;
 		this->cap = cap;
 		this->block_size = block_size;
 		this->block_alignment = block_alignment;
 
 		Reset();
 	}
 
 	void BlockAlloc::Reset()
 	{
 		freelist = nullptr;
 
 		for (size_t i = 0; i < cap / block_size; i++) {
 			uint8_t *block = ptr + (block_size * i);
 
 			FreeListNode *node = (FreeListNode *) block;
 			node->next = freelist;
 			freelist = node;
 		}
 	}
 
 	uint8_t *BlockAlloc::AllocRaw()
 	{
 		if (freelist == nullptr)
 			return nullptr;
 
 		FreeListNode *node = freelist;
 		freelist = node->next;
 
 		return (uint8_t *) node;
 	}
 
 	void BlockAlloc::Free(uint8_t *ptr)
 	{
 		FreeListNode *node = (FreeListNode *) ptr;
 		node->next = freelist;
 		freelist = node;
 	}
 
 	void StackAlloc::Init(uint8_t *buf, size_t cap)
 	{
 		ptr = buf;
 		this->cap = cap;
 		len = 0;
 	}
 
 	void StackAlloc::Reset()
 	{
 		len = 0;
 	}
 
 	StackAlloc::Result StackAlloc::AllocRaw(size_t size, size_t alignment)
 	{
 		assert(size);
 		assert(alignment);
 		assert(Utility::IsPowerOfTwo(alignment));
 
 		uintptr_t currentPtr = (uintptr_t) ptr + len;
 		uintptr_t endPtr = (uintptr_t) ptr + cap;
 
 		uintptr_t alignedPtr = Utility::AlignNext(currentPtr, alignment);
 		if (endPtr < alignedPtr + size) {
 			Result result{};
 			return result;
 		}
 
 		len = (alignedPtr + size) - (uintptr_t) ptr;
 
 		Result result{};
 		result.ptr = (uint8_t *) alignedPtr;
 		result.len = size;
 		result.saveptr = (uint8_t *) currentPtr;
 		return result;
 	}
 
 	void StackAlloc::Free(Result region)
 	{
 		len = region.saveptr - ptr;
 	}
 }