struct AllocHeader {
//  метка своих аллокаций: tag_this = this + leaf_id
    uint64_t  tag_this  {  2020071700  };
// размер аллокации:
    int  size;
// быстрый доступ к листу аллокации:
    int  leaf_id  {  -2020071708  };
  };

void  ffree(void  *ptr)
  {
    char  *to_free  =  static_cast<char  *>(ptr)
         -  sizeof(AllocHeader);
    AllocHeader  *head  =  reinterpret_cast<AllocHeader  *>(to_free);

char  *buf;
      // available == offset наоборот
      std::atomic<int>  available  {  Leaf_Size_Bytes  };
      // allocated == контроль деаллокаций
      std::atomic<int>  deallocated  {  0  };

result_ptr  =  leaf_array[leaf_id].buf + available_after;

const int  deallocated  =  leaf_array[head->leaf_id].deallocated.fetch_add(real_size, std::memory_order_acq_rel)  +  real_size;

if (deallocated  == (Leaf_Size_Bytes - available))
{  // всё что было аллоцировано теперь возвращено,
  // попытаемся, осторожно, сбросить Leaf
  if (leaf_array[head->leaf_id].available
      .compare_exchange_strong(available,  Leaf_Size_Bytes))
  {
    leaf_array[head->leaf_id].deallocated  -=  deallocated;
  }
}

/**
* @brief FFREE  -  функция освобождения аллокации вместо free
* @param iFastMemPool  -  экземпляр FastMemPool в котором проводили аллокацию
* @param ptr  -  указатель на аллокацию через fmaloc
*/
#if defined(Debug)
#define FFREE(iFastMemPool, ptr) \
   (iFastMemPool)->ffreed (__FILE__, __LINE__, __FUNCTION__, ptr)
#else
#define FFREE(iFastMemPool, ptr) \
   (iFastMemPool)->ffree (ptr)
#endif

struct AllocInfo {
// кто произвёл операцию: файл, номер строки кода, в каком методе:
    std::string  who;
//  true - аллоцировано,  false - деаллоцировано:
    bool  allocated  {  false  };
  };
  std::map<void *,  AllocInfo>  map_alloc_info;
  std::mutex  mut_map_alloc_info;

/**
   * @brief check_access  -  проверка возможности доступа к целевой области памяти
   * @param base_alloc_ptr - предполагаемый адрес базовой аллокации из FastMemPool
   * @param target_ptr  -  начало целевой области памяти
   * @param target_size  -  размер структуры, к которой нужен доступ
   * @return - true если целевая область памяти принадлежит базовой аллокации из FastMemPool
   */
  bool  check_access(void  *base_alloc_ptr,  void  *target_ptr,  std::size_t  target_size)
// Пример использования:
  if (FCHECK_ACCESS(fastMemPool, elem.array,
      &elem.array[elem.array_size - 1], sizeof (int)))
  {
    elem.array[elem.array_size - 1] = rand();
  }

set(DEF_Leaf_Size_Bytes "65536" CACHE PATH "Size of each memory pool leaf")
message("DEF_Leaf_Size_Bytes: ${DEF_Leaf_Size_Bytes}")
set(DEF_Leaf_Cnt "16" CACHE PATH "Memory pool leaf count")
message("DEF_Leaf_Cnt: ${DEF_Leaf_Cnt}")

set(SPEC_DEFINITIONS
      ${CMAKE_SYSTEM_NAME}
      ${CMAKE_BUILD_TYPE}
      ${SPEC_BUILD}
      SPEC_VERSION="${Proj_VERSION}"
      DEF_Leaf_Size_Bytes=${DEF_Leaf_Size_Bytes}
      DEF_Leaf_Cnt=${DEF_Leaf_Cnt}
      DEF_Average_Allocation=${DEF_Average_Allocation}
      DEF_Need_Registry=${DEF_Need_Registry}
  )
#через
target_compile_definitions(${TARGET} PUBLIC ${TARGET_DEFINITIONS})

#ifndef DEF_Leaf_Size_Bytes
  #define DEF_Leaf_Size_Bytes  65535
#endif
template<int Leaf_Size_Bytes = DEF_Leaf_Size_Bytes,
    int Leaf_Cnt = DEF_Leaf_Cnt,
    int Average_Allocation = DEF_Average_Allocation,
    bool Do_OS_malloc = DEF_Do_OS_malloc,
    bool Need_Registry = DEF_Need_Registry,
    bool Raise_Exeptions = DEF_Raise_Exeptions>
class FastMemPool
{
// ..
};

// можно инжектировать как compile time шаблон :
std::unordered_map<int,  int, std::hash<int>,
  std::equal_to<int>,
  FastMemPoolAllocator<std::pair<const int,  int>> >   umap1;
// можно инжектировать как runtime объект :
std::unordered_map<int,  int>  umap2(
   1024, std::hash<int>(),
   std::equal_to<int>(),
   FastMemPoolAllocator<std::pair<const int,  int>>());

bool test_Strategy()
{
  /*
   * Инжектируем Стратегию аллокации в Runtime
   *  (будем использовать конкретный экземпляр такого типа)
*/
  using MyAllocatorType = FastMemPool<333, 33>;
// instance of:
  MyAllocatorType  fastMemPool;
// inject instance:
  FastMemPoolAllocator<std::string,
     MyAllocatorType > myAllocator(&fastMemPool);
  // аллоцируем кусок памяти на 3 строки:
  std::string* str = myAllocator.allocate(3);
  // даём отработать конструкторам каждой строки:
  myAllocator.construct(str, "Mother ");
  myAllocator.construct(str + 1, " washed ");
  myAllocator.construct(str + 2, "the frame");
//как-то используем
  std::cout << str[0] << str[1] << str[2];
  // вызываем деструкторы:
  myAllocator.destroy(str);
  myAllocator.destroy(str + 1);
  myAllocator.destroy(str + 2);
  // возвращаем память:
  myAllocator.deallocate(str, 3);
  return  true;
}

FastMemPool<100000000, 1, 1024, true, true>  bulletproof_mempool;
void *ptr = bulletproof_mempool.fmalloc(1234567);
// ..
// делаем что-то полезное для людей c ptr
// ..
bulletproof_mempool.ffree(ptr);

using  TWorkStack = SpecSafeStack<VideoFrame>;
//..
  // Video frames exchanger:
TWorkStack  work_stack;
//..
work_staff->work_stack.push(frame);
//..
VideoFrame * frame = work_staff->work_stack.pop();