diff --git a/.gitignore b/.gitignore index de21ab4..72bcfd7 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ build -sandbox \ No newline at end of file +sandbox +.vscode diff --git a/CMakeLists.txt b/CMakeLists.txt index 71d5773..acec1b0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,8 @@ cmake_minimum_required(VERSION 3.15) project(neurox) -set(SOURCES src/FXAlloc.c) +set(CMAKE_C_STANDART 11) +set(SOURCES ${SOURCES} src/FXAlloc.c) set(HEADERS headers/_FXAlloc.h) set(INCLUDES includes/FXAlloc.h) add_library(fxalloc STATIC ${SOURCES} ${HEADERS} ${INCLUDES}) -target_include_directories(fxalloc PUBLIC includes PRIVATE headers) \ No newline at end of file +target_include_directories(fxalloc PUBLIC includes PRIVATE headers) diff --git a/headers/_FXAlloc.h b/headers/_FXAlloc.h index 38cc9f0..33ca73d 100644 --- a/headers/_FXAlloc.h +++ b/headers/_FXAlloc.h @@ -1,84 +1,229 @@ #pragma once - +/** + * @file fxalloc/headers/_FXAlloc.h + * @author felex67 (admin@felexdev.ru) + * @version 1.0.0 dev-in-progress + * + * @brief Внутренний заголовочный файл модуля FXAlloc + */ #include "FXAlloc.h" -#ifdef _WIN32 - typedef HANDLE fxsync_t; -#else - typedef pthread_mutex_t fxsync_t; +#ifdef __cplusplus +extern "C" { #endif - -#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 201112L) - #error "C11 standard is required for _Atomic support" -#endif - - -#if defined(__clang__) - // Clang: _Atomic поддерживается в C11 во всех актуальных версиях - -#elif defined(__GNUC__) - #if (__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 9) - #error "GCC < 4.9 does not support _Atomic (C11)" - #endif - -#elif defined(_MSC_VER) - #if _MSC_VER < 1930 // VS 2022+ (_MSC_VER >= 1930) - #error "MSVC < VS 2022 (_MSC_VER < 1930) does not support _Atomic (C11)" - #endif - -#else - #error "Unsupported compiler. Only Clang, GCC >=4.9, and MSVC VS 2022+ support _Atomic in C11" -#endif - - +#include +#include typedef struct FXMemoryBlock FXMemoryBlock; +typedef struct FXGradePool FXGradePool; -#pragma pack(push, 8) +#if defined(_I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_) && defined(__FXALLOC_TURBO) + +/*===================================================================================================* + * !!! Опасный режим !!! * + * Сугубо для отпрофилированных серверов. Режим глубокого профилирования не доступен. * + *===================================================================================================*/ + #pragma pack(push, 16) + /** + * @brief Метаданные отдельного блока памяти + * */ + struct FXMemoryBlock { + FXMemoryBlock* next; ///< Следующий в стэке свободных + FXGradePool* pool; ///< Указатель на конкретный грейд хозяина + uint8_t data[]; ///< Пользовательские данные + }; + #pragma pack(pop) + + #pragma pack(push, 16) + /** + * @brief Элемент пула потока выделяемый для градации + * + */ + struct FXGradePool { + _Atomic FXMemoryBlock* lifo; ///< Стэк свободных блоков + _Atomic uint32_t ntotal; ///< Блоков всего + _Atomic int32_t nfree; ///< Блоков свободно + }; + #pragma pack(pop) + +#else +/*===================================================================================================* + * Режим работы в формате профилировщика с возможностью расширенной статистики * + *===================================================================================================*/ +#pragma pack(push, 16) /** * @brief Метаданные отдельного блока памяти * */ - typedef struct FXMemoryBlock { + struct FXMemoryBlock { FXMemoryBlock* next; ///< Следующий в стэке свободных + FXGradePool* pool; ///< Указатель на конкретный грейд хозяина FXMemoryBlock* list; ///< Следующий в списке алоцированных - uint32_t thread_idx; ///< Индекс потока - uint32_t grade_idx; ///< Индекс грейда uint32_t used; ///< Использовано байт uint32_t padding; ///< Это ненужные байты, во всяком случае - пока uint8_t data[]; ///< Пользовательские данные - } FXMemoryBlock; -#pragma pack(push, 16) - - -/** - * @brief Грейдовый пул выделяемый для градации - * - */ -typedef struct FXGradePool { - FXMemoryBlock* prealloced; ///< Преаллоцированные блоки - FXMemoryBlock* lifo; ///< Стэк свободных блоков - FXMemoryBlock* list; ///< Список аллоцированных блоков - uint32_t ntotal; ///< Блоков всего - uint32_t nbusy; ///< Блоков занято - uint32_t nalloc; ///< Блоков алоцировано через `malloc` - uint32_t nprealloc; ///< Блоков преаллоцировано -} FXGradePool; + }; +#pragma pack(pop) #pragma pack(push, 8) /** - * @brief Thread memory pool + * @brief Элемент пула потока выделяемый для градации + * + */ +struct FXGradePool { + _Atomic FXMemoryBlock* lifo;///< Стэк свободных блоков + FXMemoryBlock* list; ///< Список аллоцированных блоков + FXMemoryBlock* prealloced; ///< Преаллоцированные блоки + _Atomic uint32_t ntotal; ///< Блоков всего + _Atomic int32_t nbusy; ///< Блоков занято + uint32_t nprealloc; ///< Блоков преаллоцировано + uint32_t nalloc; ///< Блоков алоцировано через `malloc` + uint32_t vref; +}; +#pragma pack(pop) + +#endif //__FXALLOC_TURBO + +#pragma pack(push, 8) +/** + * @brief Пул памяти потока * */ typedef struct FXThreadPool { - uint32_t isActive; - uint32_t ngrades; - FXGradePool grades[]; + void* (**curr_alloc)(size_t NBytes);///< Указатель на указатель на функцию аллокации действующую в данном потоке(для профилирования) + void (**curr_free)(void* Ptr); ///< Указатель на указатель на функцию освобождения действующую в данном потоке(для профилирования) + eXFAllocSearchType* search_type; ///< Указатель на переменную хранящую информацию о типе функций аллокации для данного потока(нужна при переключении режимов работы) + uint32_t isActive; ///< Показатель активности потока(для профилировщика, он же - сборщик мусора) + uint32_t ngrades; ///< Количество градаций + FXGradePool* grades[]; ///< Массив указателей на грейды, заканчивается NULL } FXThreadPool; #pragma pack(pop) +/** + * @brief Глобальный пул памяти + * + */ typedef struct FXGlobalMemoryPool { - FXThreadPool** pools; - fxsync_t mutex; -} FXGlobalMemoryPool; \ No newline at end of file + FXThreadPool** pools; ///< Массив указателей на пулы потоков, заканчивается NULL + fxsync_t mutex; ///< Мьютекс для синхронизации при инициализации для локального пула +} FXGlobalMemoryPool; + + +/*=====================================================================================================* + * Работа аллокатора в режиме проксирования. Эти функции работают только если не определён макрос * + *=====================================================================================================*/ +/** + * @brief Макрос условной компиляции квалификаторов типа указателя для `fxalloc` и `fxfree` + * В случае если не определён данный блок кода компилируется и все вызовы происзодят через + * прокси функцию + * */ +#ifndef _I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_ + /** @brief Указатель на активную функцию аллокации */ + extern TLS void* (*thread_alloc)(size_t NBytes); + /** @brief Указатель на активную функцию аллокации */ + extern TLS void (*thread_free)(void* Ptr); + + /** + * @brief Прокси-функция аллокации + * + * @param NBytes Количество байт + * + * @return void* + * @retval !NULL Указатель на область памяти выровненный по sizeof(void*) + * @retval NULL ошибка выделения памяти + */ + void* fxalloc_proxy_alloc(size_t NBytes); + + /** + * @brief Прокси-функция высвобождения + * + * @param Ptr указатель на блок выделенный пользователю + */ + void fxalloc_proxy_free(void* Ptr); +#endif //_I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_ + + +/*=====================================================================================================* + * Локальные потоковые переменные * + *=====================================================================================================*/ +/** + * @brief Указатель на пул данного потока + * Изначально равен NULL, инициализируется при первом вызове `fxalloc` или `fxalloc_init` + */ +extern TLS FXThreadPool* thread_pool; +/** + * @brief Переменная хранящая тип поиска для функций выеления памяти в данном потоке + * При первом вызове `fxalloc` без предварительного вызова `fxalloc_init` устанавливается в `FXSEARCH_SHIFTED`, + * в противном случае определяется функцией `fxalloc_init` + */ +extern TLS eXFAllocSearchType search_type; +/** + * @brief Текущий профиль потока + * FXALLOC_SPEED | FXALLOC_SUMMARY | FXALLOC_FULL + */ +extern TLS eFXAllocProfile thread_profile; +/*=====================================================================================================* + * Инициализаторы * + *=====================================================================================================*/ +/** + * @brief Функция для инициализации грейдов по-умолчанию + * + * @param NBytes + * @return void* + */ +void* fxalloc_ungraded_alloc_init(size_t NBytes); + +/*=====================================================================================================* + * Функции выделения памяти * + *=====================================================================================================*/ +/** @brief Выделение блока. Режим: скорость. Алгоритм поиска: сдвиг битов размера. */ +void* fxalloc_shifted_speed(size_t NBytes); + +/** @brief Выделение блока. Режим: поверхностное профилирование. Алгоритм поиска: сдвиг битов размера. */ +void* fxalloc_shifted_summary(size_t NBytes); + +#ifndef __FXALLOC_TURBO // Обычный режим + /** @brief Выделение блока. Режим: глубокое профилирование. Алгоритм поиска: сдвиг битов размера. */ + void* fxalloc_shifted_full(size_t NBytes); +#endif //__FXALLOC_TURBO + +/** @brief Выделение блока. Режим: скорость. Алгоритм поиска: бинарный поиск. */ +void* fxalloc_binary_speed(size_t NBytes); + +/** @brief Выделение блока. Режим: поверхностное профилирование. Алгоритм поиска: бинарный поиск. */ +void* fxalloc_binary_summary(size_t NBytes); + +#ifndef __FXALLOC_TURBO // Обычный режим + /** @brief Выделение блока. Режим: глубокое профилирование. Алгоритм поиска: бинарный поиск. */ + void* fxalloc_binary_full(size_t NBytes); +#endif //__FXALLOC_TURBO + + +/** @brief Выделение блока. Режим: скорость. Алгоритм поиска: линейный поиск. */ +void* fxalloc_linear_speed(size_t NBytes); + +/** @brief Выделение блока. Режим: поверхностное профилирование. Алгоритм поиска: линейный поиск. */ +void* fxalloc_linear_summary(size_t NBytes); + +#ifndef __FXALLOC_TURBO // Обычный режим + /** @brief Выделение блока. Режим: глубокое профилирование. Алгоритм поиска: линейный поиск. */ + void* fxalloc_linear_full(size_t NBytes); +#endif //__FXALLOC_TURBO + +/*=====================================================================================================* + * Функции освобождения памяти(возврат в пул) * + *=====================================================================================================*/ +/** @brief Возврат блока в пул. Режим: скорость */ +void* fxfree_speed(void* Ptr); + +/** @brief Возврат блока в пул. Режим: поверхностное профилирование */ +void* fxfree_summary(void* Ptr); + +/** @brief Возврат блока в пул. Режим: глубокое профилирование */ +void* fxfree_full(void* Ptr); + + +#ifdef __cplusplus +} +#endif diff --git a/includes/FXAlloc.h b/includes/FXAlloc.h index b032b1b..a72a6dd 100644 --- a/includes/FXAlloc.h +++ b/includes/FXAlloc.h @@ -1,6 +1,6 @@ #pragma once /** - * @file neurox/ccpp/fxalloc/includes/FXAlloc.h + * @file fxalloc/includes/FXAlloc.h * @author felex67 (admin@felexdev.ru) * @version 1.0.0 dev-in-progress * @@ -31,10 +31,16 @@ * * Изменение указателей `fxalloc` и `fxfree` строго запрещено!!!\ * - * Без оперделения макроса `_I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_` модуль - * будет работать в режиме "кукурузник", для перехода в режим "3-я космическая", определение - * макроса = подписание контракта о невмешательстве в указатели `void* (*fxalloc)(size_t)` и - * `void (*fxfree)(void* Ptr)`.\ + * Зачем нужен макрос `_I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_`: + * В случае когда макрос определён модульне может изменять `(*fxalloc)()/(*fxfree)()` напрямую + * и вынужден работать через прокси-функцию, что добавляет +-25 такстов к каждому вызову + * пользователем `(*fxaloc)()/(*fxfree)()`, т.к. оба указывают на прокси-функции. При + * рпределении макроса необходимость в проксировании отсутствует, т.к. модуль может менять + * `(*fxaloc)()/(*fxfree)()` напрямую. Однако даже при определении макроса пользователь никогда + * ни в коем случае не должен изменять эти указатели!!! + * Определение макроса `_I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_` равно + * подписанию контракта. Если в дальнейшем код пользователя изменит любой из этих указателей + * вся вина лежит исключительно на нём! * * По завершению работы потока/процесса в системах POSIX вся выделенная память * освобождается автоматически, в Windows необходимо вызвать `fxalloc_cleanup()`. @@ -42,23 +48,31 @@ * Подробное описание процесса разработки интерфейса и аллокатора вцелом можно найти в файле: * `neurox/ccpp/fxalloc/DIARY.md` * */ -#include -#ifdef _WIN32 - // Windows - #include - #define thread_local __declspec(thread) -#else - // Linux - #include - #define thread_local __thread -#endif //_WIN32 + #ifdef __cplusplus extern "C" { #endif //__cplusplus + #include + #if (defined(__GNUC__) && (__GNUC__ >= 5)) || defined(__clang__) + #include + #include + #define TLS __thread + typedef pthread_mutex_t fxsync_t; + typedef pthread_t thread_id_t; + #elif defined(_MSC_VER) && _MSC_VER >= 1930 + #include + #include + #define TLS __declspec(thread) + typedef HANDLE fxsync_t; + typedef HANDLE thread_id_t; + #else + #error "Unsupported compiler. Only Clang, GCC >=5.0 and MSVC VS 2022+ support _Atomic in C11" + #endif + /** * @brief Перечисление режимов работы аллокатора */ @@ -75,6 +89,9 @@ extern "C" { * `1 << FXALLOC_DEFAULT_GRADE_STEP_SHIFT` до размера 65 535 байт(~1024 грейда), * все блоки будут сохраняться в LIFO каждого грейда до конца работы потока. * Такой режим предусмотрен для профилирования. + * @note Изменение шага напрямую влияет на количество грейдов и размер метаданных + * при увеличении на 1(7): шаг грейда - 128 байт, размер пула - 512 грейдов и т.д. + * при уменьшении на 1(5): шаг грейда - 32 байта, размер пула - 2048 грейдов и т.д. * @details Если установить данный параметр 0 будет недоступен режим полного * профилирования, статистика будет содержать только `malloced = N times`, * `average_size = N bytes`, `min = N bytes` и `max = N bytes`. @@ -82,9 +99,28 @@ extern "C" { * каждому грейду и использованию памяти в нём. Не рекомендуется снижать параметр, * т.к. это напрямую повлияет на размер метаданных пула. */ - typedef enum eDefaultGradeStep { - FXALLOC_DEFAULT_GRADE_STEP_SHIFT = 6 ///< left bit shifts (1 << 6) = 64 - } eDefaultGradeStep; + typedef enum eFXAllocConfig { + FXALLOC_GRADE_STEP_SHIFT = 6,///< left bit shifts (1 << 6) = 64 - hf + FXALLOC_LIFO_HEAD_ALIGN = 64,///< Задаёт выравнивание LIFO по L1 cache + } eFXAllocConfig; + /** + * @brief Варианты настройки алгоритма поиска грейдов для данного потока + * В случае если первой в потоке вызывается функция `fxalloc` режим автоматически + * устанавливается в сдвиговый, т.к. Инициализируется пул согласно + * `FXALLOC_GRADE_STEP_SHIFT` в своём алгоритме функции сдвигового поиска опираются + * именно на это значение. + * В противном случае(первый вызов - `fxalloc_init`) вы можете сами задать тип поиска. + * Рекомендации под задачу: + * * Высокая вариативность - оставить градации по умолчанию откалибровав `FXALLOC_GRADE_STEP_SHIFT` + * * Низкая вариативность(очереди) - линейный поиск + * * Средняя вариативность(запросы и т.д.) - бираный поиск + */ + typedef enum eXFAllocSearchType { + FXSEARCH_AUTO, ///< Выберется Бинарный/линейный в зависимости от длины массива градаций(>= 7) + FXSEARCH_LINEAR, ///< Линейный поиск + FXSEARCH_BINARY, ///< Бинарный поиск + FXSEARCH_SHIFTED, ///< Поиск сдвигом вправо(`idx = (NBytes - 1) >> FXALLOC_GRADE_STEP_SHIFT;`) + } eXFAllocSearchType; /** * @brief Структура преднастройки аллокатора задающая градации и количество блоков памяти. @@ -112,10 +148,11 @@ extern "C" { * @brief Инициализирует локальный пулл памяти исходя из заданных параметров блоков * @param[in] Grades: const FXGrade* - Указатель на массив градаций * @param[in] ThreadName: const char* - Наименование потока, используется при профилировании + * @param[in] SearchType: eXFAllocSearchType - Тип поиска по градациям * в следующем виде: `[thread_id] 'thread_name': blocks: total=1024 used=64...`. * Если передан `NULL` - выводится только ID потока, т.е.: `[thread_id]: ...` */ - int fxalloc_init(const FXGrade* Grades, const char* ThreadName); + int fxalloc_init(const FXGrade* Grades, const char* ThreadName, eXFAllocSearchType SearchType); #ifndef _I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_ /** @@ -126,7 +163,7 @@ extern "C" { * @retval `NULL` - В случае единственно возможной ошибки `ENOMEM` результат сохранён в `errno` * подробное описание `strerror(errno)` */ - extern thread_local void (*const fxalloc)(size_t NBytes); + extern TLS void (*const fxalloc)(size_t NBytes); #else /** * @brief Указатель на функцию выделения памяти @@ -135,7 +172,7 @@ extern "C" { * @retval !0 - Кратный размеру(sizeof(size_t)) указатель выровненный для любого типа данных * @retval NULL - В случае единственно возможной ошибки ENOMEM результат сохранён в errno */ - extern thread_local void (*fxalloc)(size_t NBytes); + extern TLS void (*fxalloc)(size_t NBytes); #endif #ifndef _I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_ @@ -145,7 +182,7 @@ extern "C" { * @note Ни в коем разе не должен изменяться из вызывающего кода!!! * @param[in] Ptr: void* - Указатель на блок памяти */ - extern thread_local void (*const fxfree)(void* Ptr); + extern TLS void (*const fxfree)(void* Ptr); #else /** * @brief Указатель на функцию высвобождения памяти выделенной исключительно fxalloc @@ -153,7 +190,7 @@ extern "C" { * @note Ни в коем разе не должен изменяться из вызывающего кода!!! * @param[in] Ptr: void* - Указатель на блок памяти */ - extern thread_local void (*fxfree)(void* Ptr); + extern TLS void (*fxfree)(void* Ptr); #endif /** diff --git a/src/FXAlloc.c b/src/FXAlloc.c index 6b55c4d..cc79644 100644 --- a/src/FXAlloc.c +++ b/src/FXAlloc.c @@ -1,12 +1,18 @@ +#define _I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_ + +#define __FXALLOC_TURBO + #include "FXAlloc.h" +#include "_FXAlloc.h" + void* fxalloc_local_init(size_t _NBytes); void fxfree_prod(void* _Ptr); void fxfree_summ(void* _Ptr); void fxfree_prof(void* _Ptr); -thread_local void* (*fxalloc)(size_t _NBytes) = fxalloc_local_init; -void (*fxfree)(void* _Ptr) = fxfree_prod; +TLS void* (*fxalloc)(size_t _NBytes) = fxalloc_local_init; +TLS void (*fxfree)(void* _Ptr) = fxfree_prod; void* fastalloc();