Доработка архитектуры

.gitignore

@@ -1,2 +1,3 @@
 build
 sandbox
+.vscode

CMakeLists.txt

@@ -1,6 +1,7 @@
 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})

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
+#ifdef __cplusplus
-    typedef HANDLE fxsync_t;
+extern "C" {
-#else
-    typedef pthread_mutex_t fxsync_t;
 #endif
 
-
+#include <stdalign.h>
-#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 201112L)
+#include <stdlib.h>
-    #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
-
-
 
 
 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 Метаданные отдельного блока памяти
          * */
-    typedef struct FXMemoryBlock {
+        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 Метаданные отдельного блока памяти
+     * */
+    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)
+#pragma pack(pop)
-
-
-/**
- * @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(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;
+    void* (**curr_alloc)(size_t NBytes);///< Указатель на указатель на функцию аллокации действующую в данном потоке(для профилирования)
-    uint32_t ngrades;
+    void (**curr_free)(void* Ptr);      ///< Указатель на указатель на функцию освобождения действующую в данном потоке(для профилирования)
-    FXGradePool grades[];
+    eXFAllocSearchType* search_type;    ///< Указатель на переменную хранящую информацию о типе функций аллокации для данного потока(нужна при переключении режимов работы)
+    uint32_t isActive;                  ///< Показатель активности потока(для профилировщика, он же - сборщик мусора)
+    uint32_t ngrades;                   ///< Количество градаций
+    FXGradePool* grades[];              ///< Массив указателей на грейды, заканчивается NULL
 } FXThreadPool;
 #pragma pack(pop)
 
+/**
+ * @brief Глобальный пул памяти
+ * 
+ */
 typedef struct FXGlobalMemoryPool {
-    FXThreadPool** pools;
+    FXThreadPool** pools;   ///< Массив указателей на пулы потоков, заканчивается NULL
-    fxsync_t mutex;
+    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

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_` модуль
+ * Зачем нужен макрос `_I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_`:
- * будет работать в режиме "кукурузник", для перехода в режим "3-я космическая", определение
+ * В случае когда макрос определён модульне может изменять `(*fxalloc)()/(*fxfree)()` напрямую
- * макроса = подписание контракта о невмешательстве в указатели `void* (*fxalloc)(size_t)` и
+ * и вынужден работать через прокси-функцию, что добавляет +-25 такстов к каждому вызову
- * `void (*fxfree)(void* Ptr)`.\
+ * пользователем `(*fxaloc)()/(*fxfree)()`, т.к. оба указывают на прокси-функции. При
+ * рпределении макроса необходимость в проксировании отсутствует, т.к. модуль может менять
+ * `(*fxaloc)()/(*fxfree)()` напрямую. Однако даже при определении макроса пользователь никогда
+ * ни в коем случае не должен изменять эти указатели!!!
+ * Определение макроса `_I_UNDERSTAND_THAT_I_SHOULD_NEVER_CHANGE_THESE_POINTERS_` равно
+ * подписанию контракта. Если в дальнейшем код пользователя изменит любой из этих указателей
+ * вся вина лежит исключительно на нём!
  * 
  * По завершению работы потока/процесса в системах POSIX вся выделенная память
  * освобождается автоматически, в Windows необходимо вызвать `fxalloc_cleanup()`.
@@ -42,22 +48,30 @@
  * Подробное описание процесса разработки интерфейса и аллокатора вцелом можно найти в файле:
  * `neurox/ccpp/fxalloc/DIARY.md`
  * */
-#include <stdint.h>
 
-#ifdef _WIN32
+
-    // Windows
-    #include <windows.h>
-    #define thread_local __declspec(thread)
-#else
-    // Linux
-    #include <pthread.h>
-    #define thread_local __thread
-#endif //_WIN32
 
 
 #ifdef __cplusplus
 extern "C" {
 #endif //__cplusplus
+    #include <stdint.h>
+
+    #if (defined(__GNUC__) && (__GNUC__ >= 5)) || defined(__clang__)
+        #include <stdatomic.h>
+        #include <pthread.h>
+        #define TLS __thread
+        typedef pthread_mutex_t fxsync_t;
+        typedef pthread_t thread_id_t;
+    #elif defined(_MSC_VER) && _MSC_VER >= 1930
+        #include <stdatomic.h>
+        #include <windows.h>
+        #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 {
+    typedef enum eFXAllocConfig {
-        FXALLOC_DEFAULT_GRADE_STEP_SHIFT = 6 ///< left bit shifts (1 << 6) = 64
+        FXALLOC_GRADE_STEP_SHIFT = 6,///< left bit shifts (1 << 6) = 64 - hf
-    } eDefaultGradeStep;
+        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
 
     /**

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;
+TLS void* (*fxalloc)(size_t _NBytes) = fxalloc_local_init;
-void (*fxfree)(void* _Ptr) = fxfree_prod;
+TLS void (*fxfree)(void* _Ptr) = fxfree_prod;
 
 void* fastalloc();