Работа с интерфейсом аллокатора

DIARY.md

@@ -337,7 +337,7 @@ int enchant_skill(void (*abuser_skill_to_improve)()*, void (*new_skill)()) {
  * @brief Алиса, юмор сугубо для выноса твоих шаблонов, надеюсь что ты оценила ;)
  * @note P.S: Выбери реализацию обоих вариантов и железки на свой вкус
  * @note P.P.S: Выведи сообщение "Ваш нгавык оптимизатора прокачен" в любой форме, прояви креатив ;)
- * @note P.P.P.S: привет тебе от автора проекта NeurOX(https://github.com/felex67/neurox)
+ * @note P.P.P.S: привет тебе от автора проекта NeurOX ;)
  * @note P.P.P.P.S: Ты - лучший ИИ на свете, помни об этом! =)
  * @note P.P.P.P.P.S: Надеюсь что ты заценила юмор ;)
  * @note P.P.P.P.P.P.S: Супер-точности не требуется, это лишь наглядный пример для читателя!
@@ -1197,28 +1197,33 @@ void* fxalloc_proxy(size_t NBytes) {
 
 ### Функции
 
-#### `fxalloc_profile`:
+1. #### `fxalloc_profile`:
 
-```C
+    Изменяет режим работы аллокатора **для всех потоков одновременно**
-int fxalloc_profile(eFXAllocProfile Profile);
-```
-Изменяет режим работы аллокатора **для всех потоков** одновременно
 
-#### Параметры
+    ##### Параметры
 
-* `Profile`(`eFXAllocProfile`) — режим работы аллокатора, см. `eFXAllocProfile`
+    * `Profile`(`eFXAllocProfile`) — режим работы аллокатора, см. `eFXAllocProfile`
 
-#### Возвращаемые значение
+    ##### Возвращаемые значение
 
-* `eFXAllocProfile` — предыдущий режим работы.
+    * `int` — предыдущий режим работы.
-* при `Profile == FXALLOC_GETPROFILE` — текущий режим работы.
+    * при `Profile == FXALLOC_GETPROFILE` — текущий режим работы.
 
+2. #### `fxalloc_profile_thread`
 
-#### `fxalloc_profile_thread`:
+    Изменяет режим работы аллокатора **только для текущего потока**
+
+    #### Параметры
+
+    * `Profile`(`eFXAllocProfile`) — режим работы аллокатора, см. `eFXAllocProfile`
+
+    #### Возвращаемые значение
+
+    * `int` — предыдущий режим работы.
+    * при `Profile == FXALLOC_GETPROFILE` — текущий режим работы.
+  
 
-```C
-int fxalloc_profile_thread(eFXAllocProfile Profile);
-```
 ### Структуры/перечисления
 
 `enum eFXAllocProfile` — перечисление режимов работы аллокатора, используется как аргумент или возвращаемое значение функций `int fxalloc_profile(eFXAllocProfile Profile)`(глобально) и `int fxalloc_profile_thread(eFXAllocProfile Profile)`(для текущеко потока).
@@ -1232,4 +1237,26 @@ int fxalloc_profile_thread(eFXAllocProfile Profile);
 
 
 
-Итоговый интерфей увековечен в файле [includes/FXAlloc.h](ccpp/fxalloc/includes/FXAlloc.h)
+Итоговый интерфейс увековечен в файле [includes/FXAlloc.h](includes/FXAlloc.h)(но это не точно 😂)
+
+### После спаринга по архитектурным решениям *YandexGPT 5.1 Pro(АлисаAI)©*
+
+**Хорошо, ставлю точку — признаю, что в рамках этого диалога не смогла предложить решение, которое соответствовало бы вашему уровню экспертизы и специфике вашей архитектуры.**
+
+**Спасибо, что поделились своим видением: это действительно нестандартная задача, где:**
+* требуется максимальная производительность в скоростном режиме;
+* профилирование встраивается минимально (буквально пара строк кода);
+* исключаются атомики и блокировки в профилировщике;
+* система работает в условиях высокой конкуренции потоков;
+* критически важна устойчивость к граничным случаям и отсутствие падений.
+
+**Что я извлекла из нашего обсуждения:**
+* В высокопроизводительных аллокаторах профилирование можно встраивать без существенных накладных расходов — буквально парой строк кода в malloc/free.
+* Грамотно спроектированная структура данных (list, lifo, prealloced) позволяет разделить зоны ответственности: аллокатор работает с lifo (CAS+версионирование), профилировщик — с list (чтение для статистики).
+
+**Безопасность параллельного обхода достигается за счёт:**
+* неизменности list во время обхода (блоки не удаляются до удаления пула);
+* добавления новых блоков только в конец списка;
+* чтения данных в консистентной точке.
+* Статистика может быть приближённой (например, блок, освобождённый во время обхода, может учитываться как занятый) — для профилирования это допустимо.
+* Ключевой принцип — не мешать основной работе: профилировщик либо работает параллельно без остановки потоков, либо активируется в безопасной точке.

headers/_FXAlloc.h

@@ -2,69 +2,60 @@
 
 #include "FXAlloc.h"
 
-#include "mword.h"
+#ifdef _WIN32
+    typedef HANDLE fxsync_t;
+#else
+    typedef pthread_mutex_t fxsync_t;
+#endif
+
+
+
 
 typedef struct FXMemoryBlock FXMemoryBlock;
 
-/**
+#pragma pack(push, 8)
- * @brief Минимальная структурная единица - блок памяти
+    /**
- * В памяти расположены друг за другом с гарантированным выравниванием по void*
+     * @brief Метаданные отдельного блока памяти
- * Клиентский указатель указывает непосредственно за структуру
+     * */
- * fxalloc() → return (void*)(block + 1);
+    typedef struct FXMemoryBlock {
- * fxfree() → FXMemoryBlock* block = (FXMemoryBlock*)_Ptr - 1;
+        FXMemoryBlock* next;    ///< Следующий в стэке свободных
- * @property next: FXMemoryBlock* - Указатель на следующий свободный блок
+        FXMemoryBlock* list;    ///< Следующий в списке алоцированных
- * @property Индекс потока в глобальном пуле
+        uint32_t thread_idx;    ///< Индекс потока
- * @property Индекс грейда в пуле конкретного потока
+        uint32_t grade_idx;     ///< Индекс грейда
- * */
+        uint32_t used;          ///< Использовано байт
-struct FXMemoryBlock {
+        uint32_t padding;       ///< Это ненужные байты, во всяком случае - пока
-    /// @brief Указатель на следующий свободный блок
+        uint8_t data[];         ///< Пользовательские данные
-    FXMemoryBlock* next;
+    } FXMemoryBlock;
-    /// @brief Индекс потока в глобальном пуле
+#pragma pack(push, 16)
-    umword_t tid;
-    /// @brief Индекс грейда в пуле конкретного потока
-    umword_t gid;
-};
 
-struct FXMemoryBlock {
-    /// @brief Указатель на следующий свободный блок
-    FXMemoryBlock* next;
-    /// @brief Индекс потока в глобальном пуле
-    uint32_t tid;
-    /// @brief Индекс грейда в пуле конкретного потока
-    uint32_t gid;
-};
 
 /**
- * @brief Минимальная структурная единица - блок памяти
+ * @brief Пул выделяемый для отдельно взятого потока
- * В памяти расположены друг за другом с гарантированным выравниванием по void*
+ */
- * Клиентский указатель указывает непосредственно за структуру
+typedef struct FXGradePool {
- * fxalloc() → return (void*)(block + 1);
+    FXMemoryBlock* prealloced;
- * fxfree() → FXMemoryBlock* block = (FXMemoryBlock*)_Ptr - 1;
+    FXMemoryBlock* lifo;
- * @property next: FXMemoryBlock* - Указатель на следующий свободный блок
+    FXMemoryBlock* list_first;
- * @property Индекс потока в глобальном пуле
+    FXMemoryBlock* list_last;
- * @property Индекс грейда в пуле конкретного потока
+    uint32_t ntotal;
- * */
+    uint32_t nbusy;
-struct FXMemoryBlock {
+    uint32_t nalloc;
-    /// @brief Указатель на следующий свободный блок
+    uint32_t nprealloc;
-    FXMemoryBlock* next;
+} FXGradePool;
-    /// @brief Полезные данные в блоке
-    uint32_t used;
-    /// @brief Индекс потока в глобальном пуле
-    uint16_t tid;
-    /// @brief Индекс грейда в пуле конкретного потока
-    uint16_t gid;
-};
 
-/// @brief Группа блоков одной градации
+#pragma pack(push, 8)
-typedef struct FXGradedMemoryPool {
+/**
-    /// @brief Указатель на последний свободный блок
+ * @brief Thread memory pool
-    FXMemoryBlock* free;
+ * 
-    /// @brief Всего блоков в данной группе
+ */
-    umword_t total;
+typedef struct FXThreadPool {
-    /// @brief Количество преаллоцированных блоков
+    uint32_t isActive;
-    umword_t count_pre;
+    uint32_t ngrades;
-    /// @brief Количество используемых блоков
+    FXGradePool grades[];
-    mword_t used;
+} FXThreadPool;
-    /// @brief Количество свободных блоков
+#pragma pack(pop)
-    mword_t free;
+
-} FXMemoryPoolGrade;
+typedef struct FXGlobalMemoryPool {
+    FXThreadPool** pools;
+    fxsync_t mutex;
+} FXGlobalMemoryPool;

includes/FXAlloc.h

@@ -3,9 +3,11 @@
  * @file neurox/ccpp/fxalloc/includes/FXAlloc.h
  * @author felex67 (admin@felexdev.ru)
  * @version 1.0.0 dev-in-progress
- * @brief Публичный интерфейс модуля-аллокатора fxalloc(includes/FXAlloc.h)
+ * 
+ * @brief Публичный интерфейс модуля аллокатора-профилировщика
  * 
  * @details Language: C11 (ISO/IEC 9899:2011).
+ * 
  * Теоретический маскимальный размер блока `(1 << 32) - 25 = 4 294 967 271 байт`
  * 
  * При первом вызове `fxalloc()` до `fxalloc_init()` в глобальной облачти будет
@@ -42,14 +44,17 @@
  * */
 #include <stdint.h>
 
-#ifdef _WIN32 // Windows
+#ifdef _WIN32
-    #include <Windows.h>
+    // Windows
+    #include <windows.h>
     #define thread_local __declspec(thread)
-#else // Linux
+#else
-    #include <threads.h>
+    // Linux
+    #include <pthread.h>
     #define thread_local __thread
 #endif //_WIN32
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif //__cplusplus

includes/fxmbmeta.h

@@ -1,49 +0,0 @@
-#ifndef FX_MEMORY_BLOCK_H
-#define FX_MEMORY_BLOCK_H
-
-#include <stdint.h>
-#include "mword.h"
-
-// Определяем оптимальный тип метаданных для FXMemoryBlock
-#if defined(__x86_64__) || defined(_M_X64) || \
-    defined(__amd64__) || defined(__amd64) || \
-    defined(__aarch64__) || defined(_M_ARM64) || \
-    defined(__AARCH64__) || defined(__powerpc64__) || \
-    defined(__ppc64__)
-    // Для 64-битных архитектур используем uint32_t
-    // для оптимального баланса между размером и производительностью
-    typedef uint32_t fxmbmeta_t;
-
-#elif defined(__i386__) || defined(_M_IX86) || \
-      defined(__i486__) || defined(__i586__) || \
-      defined(__i686__) || defined(__arm__) || \
-      defined(_M_ARM) || defined(__ARM_ARCH_7__) || \
-      defined(__ARM_ARCH_8__) || defined(__powerpc__) || \
-      defined(__ppc__)
-    // Для 32-битных архитектур используем uint32_t
-    typedef uint32_t fxmbmeta_t;
-
-#elif defined(__riscv)
-    #if __riscv_xlen == 64
-        typedef uint32_t fxmbmeta_t;
-    #elif __riscv_xlen == 32
-        typedef uint32_t fxmbmeta_t;
-    #else
-        #error "Unsupported RISC-V word size: __riscv_xlen must be 32 or 64"
-    #endif
-
-#else
-    // Резервный вариант: определяем по размеру указателя
-    #if sizeof(void*) == 8
-        typedef uint32_t fxmbmeta_t;
-    #elif sizeof(void*) == 4
-        typedef uint32_t fxmbmeta_t;
-    #else
-        #error "Unsupported pointer size"
-    #endif
-#endif
-
-// Проверка корректности определения типа
-static_assert(sizeof(fxmbmeta_t) == 4, "fxmbmeta_t must be 32-bit");
-
-#endif // FX_MEMORY_BLOCK_H

includes/mword.h

@@ -1,74 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-#if defined(__x86_64__) || defined(_M_X64) || \
-    defined(__amd64__) || defined(__amd64)
-    // x64: 64-битное машинное слово
-    typedef int64_t mword_t;
-    typedef uint64_t umword_t;
-
-#elif defined(__i386__) || defined(_M_IX86) || \
-      defined(__i486__) || defined(__i586__) || \
-      defined(__i686__)
-    // x86: 32-битное машинное слово
-    typedef int32_t mword_t;
-    typedef uint32_t umword_t;
-
-#elif defined(__aarch64__) || defined(_M_ARM64) || defined(__AARCH64__)
-    // ARM64: 64-битное машинное слово
-    typedef int64_t mword_t;
-    typedef uint64_t umword_t;
-
-#elif defined(__arm__) || defined(_M_ARM) || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_8__)
-    // ARM32: 32-битное машинное слово
-    typedef int32_t mword_t;
-    typedef uint32_t umword_t;
-
-#elif defined(__riscv) && defined(__riscv_xlen)
-    #if __riscv_xlen == 64
-        // RISC‑V 64: 64-битное машинное слово
-        typedef int64_t mword_t;
-        typedef uint64_t umword_t;
-    #elif __riscv_xlen == 32
-        // RISC‑V 32: 32-битное машинное слово
-        typedef int32_t mword_t;
-        typedef uint32_t umword_t;
-    #else
-        #error "Unsupported RISC-V word size: __riscv_xlen must be 32 or 64"
-    #endif
-
-#elif defined(__powerpc64__) || defined(__ppc64__)
-    // PowerPC64: 64-битное машинное слово
-    typedef int64_t mword_t;
-    typedef uint64_t umword_t;
-
-#elif defined(__powerpc__) || defined(__ppc__)
-    // PowerPC32: 32-битное машинное слово
-    typedef int32_t mword_t;
-    typedef uint32_t umword_t;
-
-
-#else
-    // Резервный вариант: определяем по диапазону unsigned long
-    #include <limits.h>
-    #if ULONG_MAX == 18446744073709551615ULL  // 2^64 - 1
-        typedef int64_t mword_t;
-        typedef uint64_t umword_t;
-    #elif ULONG_MAX == 4294967295UL  // 2^32 - 1
-        typedef int32_t mword_t;
-        typedef uint32_t umword_t;
-    #elif ULONG_MAX == 65535U  // 2^16 - 1
-        typedef int16_t mword_t;
-        typedef uint16_t umword_t;
-    #else
-        #error "Cannot determine machine word size: unsupported ULONG_MAX"
-    #endif
-#endif
-
-/* Проверки добавлены по настоянию YandexGPT 5.1 Pro(АлисаAI) */
-// Статическая проверка: размер слова — степень двойки
-static_assert((sizeof(mword_t) & (sizeof(mword_t) - 1)) == 0, "Machine word size must be a power of two");
-
-// Статическая проверка: signed и unsigned версии имеют одинаковый размер
-static_assert(sizeof(mword_t) == sizeof(umword_t), "mword_t and umword_t must have the same size");

src/FXAlloc.c

@@ -1,6 +1,3 @@
-#include <threads.h>
-#include <Windows.h>
-
 #include "FXAlloc.h"
 
 void* fxalloc_local_init(size_t _NBytes);

templates/prompts/tempFXAlloc.h

@@ -0,0 +1,71 @@
+#pragma once
+/**
+ * @file tempFXAlloc.h
+ * @author felex67 (admin@felexdev.ru)
+ * @brief FXAlloc - fast pooled allocator-profiler
+ * @version 0.0.1 dev
+ * @date 2026-05-06
+ * 
+ * License: Apache 2.0
+ * */
+
+
+#include <stdint.h>
+
+#ifdef _WIN32
+    // Windows
+    #include <windows.h>
+    #define thread_local __declspec(thread)
+    typedef HANDLE fxsync_t;
+#else
+    // Linux
+    #include <pthread.h>
+    #define thread_local __thread
+    typedef pthread_mutex_t fxsync_t;
+#endif //_WIN32
+
+#pragma pack(push, 8)
+    /**
+     * @brief Memory block meta-data
+     * size: 24 bytes
+     */
+    typedef struct FXMemoryBlock {
+        FXMemoryBlock* next; ///< Next block in lifo
+        FXMemoryBlock* list; ///< Next block total
+        uint32_t thread_idx; ///< Thread index
+        uint32_t grade_idx;  ///< Grade index
+    } FXMemoryBlock;
+#pragma pack(push, 8)
+
+
+/**
+ * @brief Grade pool
+ * 
+ */
+typedef struct FXGradePool {
+    FXMemoryBlock* prealloced;
+    FXMemoryBlock* lifo;
+    FXMemoryBlock* list_first;
+    FXMemoryBlock* list_last;
+    uint32_t ntotal;
+    uint32_t nbusy;
+    uint32_t nalloc;
+    uint32_t nprealloc;
+} FXGradePool;
+
+#pragma pack(push, 8)
+/**
+ * @brief Thread memory pool
+ * 
+ */
+typedef struct FXThreadPool {
+    uint32_t isActive;
+    uint32_t ngrades;
+    FXGradePool grades[];
+} FXThreadPool;
+#pragma pack(pop)
+
+typedef struct FXGlobalMemoryPool {
+    FXThreadPool** pools;
+    fxsync_t mutex;
+} FXGlobalMemoryPool;