Mineplay/Hallocy
1
0
Fork 0
Code Issues Pull requests Projects 1 Releases 2 Packages Wiki Activity Actions

Merge pull request 'h1-basic-allocator' (#5) from h1-basic-allocator into main

Browse source 
Reviewed-on: #5

Tests folder now only contains the Main.c file. This will be changed to a real test system later, but the Hallocy library is needed first to setup this test framework so for now it will use a simple Main.c with some code to run for testing.
This commit is contained in:
Mineplay 2025-04-12 16:50:07 -05:00
commit 33936eb001
6 changed files with 511 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
CMakeLists.txt
View file

@ -5,21 +5,22 @@ set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)
include_directories(${PROJECT_SOURCE_DIR}/Include)
file(GLOB_RECURSE SRC_FILES "${PROJECT_SOURCE_DIR}/Src/Hallocy/*.c")
file(GLOB_RECURSE SRC_FILES "${PROJECT_SOURCE_DIR}/Src/*.c")
add_library(Hallocy STATIC ${SRC_FILES})
add_executable(HallocyApp ${PROJECT_SOURCE_DIR}/Src/Main.c)
add_executable(HallocyTest ${PROJECT_SOURCE_DIR}/Tests/Main.c)
target_link_libraries(HallocyApp Hallocy)
target_include_directories(HallocyTest PRIVATE ${PROJECT_SOURCE_DIR}/Tests)
target_link_libraries(HallocyTest Hallocy)
if (MSVC)
target_compile_options(Hallocy PRIVATE /W4 /Zl)
else()
target_compile_options(Hallocy PRIVATE -mavx512f -mavx512vl)
target_compile_options(HallocyApp PRIVATE -mavx512f -mavx512vl)
target_compile_options(HallocyTest PRIVATE -mavx512f -mavx512vl)
target_compile_options(Hallocy PRIVATE -march=native)
target_compile_options(HallocyApp PRIVATE -march=native)
target_compile_options(HallocyTest PRIVATE -march=native)
target_compile_options(Hallocy PRIVATE -Wall -Wextra -pedantic)
endif()

34
Include/Hallocy/Allocator.h Normal file
View file

@ -0,0 +1,34 @@
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* -----------------------------------------------------------------------------
* File: Allocator.h
* Description:
* This file contains the functions for allocating, freeing and managing memory.
* It includes functions to allocate, reallocate, free, copy, move and set memory.
*
* Author: Mineplay
* -----------------------------------------------------------------------------
*/
#ifndef HALLOCY_ALLOCATOR
#define HALLOCY_ALLOCATOR
#include <stddef.h>
#include <stdbool.h>
#include "Error.h"
void *hallocy_malloc(size_t size);
HallocyError hallocy_free(void *pointer);
#endif

34
Include/Hallocy/Error.h Normal file
View file

@ -0,0 +1,34 @@
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* -----------------------------------------------------------------------------
* File: Error.h
* Description:
* This file contains the ErrorCode enum that defines the error codes for the
* library.
*
* Author: Mineplay
* -----------------------------------------------------------------------------
*/
#ifndef HALLOCY_ERROR
#define HALLOCY_ERROR
typedef enum {
HALLOCY_ERROR_NONE = 0,
HALLOCY_ERROR_INVALID_POINTER = 1,
HALLOCY_ERROR_OUT_OF_MEMORY = 2,
HALLOCY_ERROR_UNKNOWN = 3,
HALLOCY_ERROR_INVALID_PARAM = 4
} HallocyError;
#endif

393
Src/Allocator.c Normal file
View file

@ -0,0 +1,393 @@
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* -----------------------------------------------------------------------------
* File: Allocator.h
* Description:
* This file implements the functions for allocating, freeing and managing memory.
* It includes functions to allocate, reallocate, free, copy, move and set memory.
*
* Author: Mineplay
* -----------------------------------------------------------------------------
*/
#include "../Include/Hallocy/Allocator.h"
#if defined(_WIN32)
#include <windows.h>
static const INIT_ONCE HALLOCY_INIT_ONCE = INIT_ONCE_STATIC_INIT;
static HANDLE hallocy_heap = NULL;
static CRITICAL_SECTION hallocy_critical_section;
#elif defined(__linux__)
#include <unistd.h>
#include <sys/mman.h>
#include <errno.h>
#include <syscall.h>
static const int HALLOCY_FUTEX_WAKE = 0;
static const int HALLOCY_FUTEX_WAIT = 1;
static int hallocy_futex_address = 0;
#endif
typedef struct HallocyMemoryHeader {
size_t size;
struct HallocyMemoryHeader *next;
} HallocyMemoryHeader;
static size_t hallocy_medium_memory_freed = 0;
static size_t hallocy_medium_memory_allocated = 0;
static HallocyMemoryHeader *hallocy_medium_memory_bin = NULL;
static _Thread_local size_t hallocy_small_memory_freed = 0;
static _Thread_local size_t hallocy_small_memory_allocated = 0;
static _Thread_local HallocyMemoryHeader *hallocy_small_memory_bin = NULL;
static size_t page_size = 0;
static size_t hallocy_small_allocation_size = 0;
static size_t hallocy_medium_allocation_size = 0;
#if defined(_WIN32)
static BOOL CALLBACK hallocy_initialize_mutex(PINIT_ONCE init_once, PVOID parameter, PVOID *context) {
(void)init_once;
(void)parameter;
(void)context;
return InitializeCriticalSectionEx(&hallocy_critical_section, 0x00000400, 0);
}
#endif
void *hallocy_malloc(size_t size) {
if (page_size == 0) {
#if defined(_WIN32)
SYSTEM_INFO system_info;
GetSystemInfo(&system_info);
page_size = system_info.dwPageSize;
#elif defined(__linux__)
page_size = sysconf(_SC_PAGE_SIZE);
#endif
hallocy_small_allocation_size = page_size;
hallocy_medium_allocation_size = page_size * 10;
}
size_t aligned_size = page_size * (((size + sizeof(HallocyMemoryHeader)) / page_size) + 1);
HallocyMemoryHeader *memory_pointer = NULL;
if (aligned_size <= hallocy_small_allocation_size) {
HallocyMemoryHeader *previous_header = NULL;
memory_pointer = hallocy_small_memory_bin;
while (memory_pointer != NULL) {
if (memory_pointer->size >= aligned_size) {
hallocy_small_memory_allocated += memory_pointer->size;
hallocy_small_memory_freed -= memory_pointer->size;
if (previous_header == NULL) {
hallocy_small_memory_bin = hallocy_small_memory_bin->next;
} else {
previous_header->next = memory_pointer->next;
}
memory_pointer->next = NULL;
return (void*)(memory_pointer + 1);
}
previous_header = memory_pointer;
memory_pointer = memory_pointer->next;
}
#if defined(_WIN32)
if (hallocy_heap == NULL) {
hallocy_heap = GetProcessHeap();
}
memory_pointer = HeapAlloc(hallocy_heap, 0, aligned_size);
if (memory_pointer == NULL) {
return NULL;
}
#elif defined(__linux__)
memory_pointer = mmap(NULL, aligned_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (memory_pointer == MAP_FAILED) {
return NULL;
}
#endif
hallocy_small_memory_allocated += aligned_size;
} else if (aligned_size <= hallocy_medium_allocation_size) {
#if defined(_WIN32)
InitOnceExecuteOnce(&HALLOCY_INIT_ONCE, hallocy_initialize_mutex, NULL, NULL);
EnterCriticalSection(&hallocy_critical_section);
#elif defined(__linux__)
bool locked = false;
while (!locked) {
if (__sync_bool_compare_and_swap(&hallocy_futex_address, 0, 1)) {
locked = true;
} else {
syscall(SYS_futex, &hallocy_futex_address, HALLOCY_FUTEX_WAIT, 1, NULL, NULL, 0);
}
}
#endif
HallocyMemoryHeader *previous_header = NULL;
memory_pointer = hallocy_medium_memory_bin;
while (memory_pointer != NULL) {
if (memory_pointer->size >= aligned_size) {
hallocy_medium_memory_allocated += memory_pointer->size;
hallocy_medium_memory_freed -= memory_pointer->size;
if (previous_header == NULL) {
hallocy_medium_memory_bin = hallocy_medium_memory_bin->next;
} else {
previous_header->next = memory_pointer->next;
}
#if defined(_WIN32)
LeaveCriticalSection(&hallocy_critical_section);
#elif defined(__linux__)
hallocy_futex_address = 0;
syscall(SYS_futex, &hallocy_futex_address, HALLOCY_FUTEX_WAKE, 1, NULL, NULL, 0);
#endif
memory_pointer->next = NULL;
return (void*)(memory_pointer + 1);
}
previous_header = memory_pointer;
memory_pointer = memory_pointer->next;
}
#if defined(_WIN32)
if (hallocy_heap == NULL) {
hallocy_heap = GetProcessHeap();
}
memory_pointer = HeapAlloc(hallocy_heap, 0, aligned_size);
if (memory_pointer == NULL) {
return NULL;
}
hallocy_medium_allocation_size += aligned_size;
LeaveCriticalSection(&hallocy_critical_section);
#elif defined(__linux__)
memory_pointer = mmap(NULL, aligned_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (memory_pointer == MAP_FAILED) {
return NULL;
}
hallocy_medium_allocation_size += aligned_size;
hallocy_futex_address = 0;
syscall(SYS_futex, &hallocy_futex_address, HALLOCY_FUTEX_WAKE, 1, NULL, NULL, 0);
#endif
} else {
#if defined(_WIN32)
memory_pointer = (HallocyMemoryHeader*)VirtualAlloc(NULL, aligned_size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (memory_pointer == NULL) {
return NULL;
}
#elif defined(__linux__)
memory_pointer = (HallocyMemoryHeader*)mmap(NULL, aligned_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (memory_pointer == MAP_FAILED) {
return NULL;
}
#endif
}
memory_pointer->size = aligned_size;
memory_pointer->next = NULL;
return (void*)(memory_pointer + 1);
}
HallocyError hallocy_free(void *pointer) {
if (pointer == NULL) {
return HALLOCY_ERROR_INVALID_POINTER;
}
HallocyMemoryHeader *memory_header = ((HallocyMemoryHeader*)pointer) - 1;
if (memory_header->size <= hallocy_small_allocation_size) {
memory_header->next = hallocy_small_memory_bin;
hallocy_small_memory_bin = memory_header;
hallocy_small_memory_allocated -= memory_header->size;
hallocy_small_memory_freed += memory_header->size;
if (hallocy_small_memory_allocated == 0 && hallocy_small_memory_freed > hallocy_medium_allocation_size) {
HallocyMemoryHeader *previous_header = NULL;
HallocyMemoryHeader *current_header = hallocy_small_memory_bin;
while (current_header != NULL) {
previous_header = current_header;
current_header = current_header->next;
#if defined(_WIN32)
bool result = HeapFree(hallocy_heap, 0, previous_header);
if (result == false) {
DWORD error = GetLastError();
switch (error) {
case ERROR_INVALID_PARAMETER:
return HALLOCY_ERROR_INVALID_PARAM;
case ERROR_NOT_ENOUGH_MEMORY:
return HALLOCY_ERROR_OUT_OF_MEMORY;
case ERROR_INVALID_HANDLE:
return HALLOCY_ERROR_INVALID_POINTER;
default:
return HALLOCY_ERROR_UNKNOWN;
}
}
#elif defined(__linux__)
int result = munmap(previous_header, previous_header->size);
if (result == -1) {
switch (errno) {
case EINVAL:
return HALLOCY_ERROR_INVALID_PARAM;
case ENOMEM:
return HALLOCY_ERROR_OUT_OF_MEMORY;
case EFAULT:
return HALLOCY_ERROR_INVALID_POINTER;
default:
return HALLOCY_ERROR_UNKNOWN;
}
}
#endif
}
hallocy_small_memory_bin = NULL;
hallocy_small_memory_allocated = 0;
hallocy_small_memory_freed = 0;
}
} else if (memory_header->size <= hallocy_medium_allocation_size) {
#if defined(_WIN32)
InitOnceExecuteOnce(&HALLOCY_INIT_ONCE, hallocy_initialize_mutex, NULL, NULL);
EnterCriticalSection(&hallocy_critical_section);
#elif defined(__linux__)
bool locked = false;
while (!locked) {
if (__sync_bool_compare_and_swap(&hallocy_futex_address, 0, 1)) {
locked = true;
} else {
syscall(SYS_futex, &hallocy_futex_address, HALLOCY_FUTEX_WAIT, 1, NULL, NULL, 0);
}
}
#endif
memory_header->next = hallocy_medium_memory_bin;
hallocy_medium_memory_bin = memory_header;
hallocy_medium_memory_allocated -= memory_header->size;
hallocy_medium_memory_freed += memory_header->size;
if (hallocy_medium_memory_allocated == 0 && hallocy_medium_memory_freed > hallocy_medium_allocation_size) {
HallocyMemoryHeader *previous_header = NULL;
HallocyMemoryHeader *current_header = hallocy_medium_memory_bin;
while (current_header != NULL) {
previous_header = current_header;
current_header = current_header->next;
#if defined(_WIN32)
bool result = HeapFree(hallocy_heap, 0, previous_header);
if (result == false) {
DWORD error = GetLastError();
switch (error) {
case ERROR_INVALID_PARAMETER:
return HALLOCY_ERROR_INVALID_PARAM;
case ERROR_NOT_ENOUGH_MEMORY:
return HALLOCY_ERROR_OUT_OF_MEMORY;
case ERROR_INVALID_HANDLE:
return HALLOCY_ERROR_INVALID_POINTER;
default:
return HALLOCY_ERROR_UNKNOWN;
}
}
#elif defined(__linux__)
int result = munmap(previous_header, previous_header->size);
if (result == -1) {
switch (errno) {
case EINVAL:
return HALLOCY_ERROR_INVALID_PARAM;
case ENOMEM:
return HALLOCY_ERROR_OUT_OF_MEMORY;
case EFAULT:
return HALLOCY_ERROR_INVALID_POINTER;
default:
return HALLOCY_ERROR_UNKNOWN;
}
}
#endif
}
hallocy_medium_memory_bin = NULL;
hallocy_medium_memory_allocated = 0;
hallocy_medium_memory_freed = 0;
}
#if defined(_WIN32)
LeaveCriticalSection(&hallocy_critical_section);
#elif defined(__linux__)
hallocy_futex_address = 0;
syscall(SYS_futex, &hallocy_futex_address, HALLOCY_FUTEX_WAKE, 1, NULL, NULL, 0);
#endif
} else {
#if defined(_WIN32)
bool result = VirtualFree(memory_header, 0, MEM_RELEASE);
if (result == false) {
DWORD error = GetLastError();
switch (error) {
case ERROR_INVALID_PARAMETER:
return HALLOCY_ERROR_INVALID_PARAM;
case ERROR_NOT_ENOUGH_MEMORY:
return HALLOCY_ERROR_OUT_OF_MEMORY;
case ERROR_INVALID_HANDLE:
return HALLOCY_ERROR_INVALID_POINTER;
case ERROR_INVALID_ADDRESS:
return HALLOCY_ERROR_INVALID_POINTER;
default:
return HALLOCY_ERROR_UNKNOWN;
}
}
#elif defined(__linux__)
int result = munmap(memory_header, memory_header->size);
if (result == -1) {
switch (errno) {
case EINVAL:
return HALLOCY_ERROR_INVALID_PARAM;
case ENOMEM:
return HALLOCY_ERROR_OUT_OF_MEMORY;
case EFAULT:
return HALLOCY_ERROR_INVALID_POINTER;
default:
return HALLOCY_ERROR_UNKNOWN;
}
}
#endif
}
return HALLOCY_ERROR_NONE;
}

6
Src/Main.c
View file

@ -1,6 +0,0 @@
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}

44
Tests/Main.c Normal file
View file

@ -0,0 +1,44 @@
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* -----------------------------------------------------------------------------
* File: Main.c
* Description:
* Executes all tests.
*
* Author: Mineplay
* -----------------------------------------------------------------------------
*/
#include <stdio.h>
#include <Hallocy/Allocator.h>
int main() {
char *memory = (char *)hallocy_malloc(12288);
if (memory == NULL) {
printf("Failed it allocate memory!");
return -1;
}
memory[0] = 'H';
memory[1] = 'i';
memory[2] = '\0';
printf("%s\n", memory);
int code = hallocy_free(memory);
if (code != HALLOCY_ERROR_NONE) {
printf("Failed to free memory error code (%d)!", code);
return -1;
}
return 0;
}