template <typename T>
class stl_buddy_alloc
{
public:
  typedef T                 value_type;
  typedef value_type*       pointer;
  typedef value_type&       reference;
  typedef const value_type* const_pointer;
  typedef const value_type& const_reference;
  typedef ptrdiff_t         difference_type;
  typedef size_t            size_type;
public:
  stl_buddy_alloc() throw()
  {  // construct default allocator (do nothing)
  }
  stl_buddy_alloc(const stl_buddy_alloc<T> &) throw()
  {  // construct by copying (do nothing)
  }
  template<class _Other>
  stl_buddy_alloc(const stl_buddy_alloc<_Other> &) throw()
  {  // construct from a related allocator (do nothing)
  }
  void deallocate(pointer _Ptr, size_type)
  {  // deallocate object at _Ptr, ignore size
    xfree(_Ptr);
  }
  pointer allocate(size_type _Count)
  {  // allocate array of _Count elements
    return (pointer)xalloc(sizeof(T) * _Count);
  }
  pointer allocate(size_type _Count, const void *)
  {  // allocate array of _Count elements, ignore hint
    return (allocate(_Count));
  }
};

template <typename _Kty, typename _Ty>
class q_map :
    public std::map<
        _Kty,
        _Ty,
        std::less<_Kty>,
        stl_buddy_alloc<std::pair<const _Kty, _Ty> >
    >
{ };
typedef std::basic_string<
        char,
        std::char_traits<char>,
        stl_buddy_alloc<char> > q_string

class BuddyAllocator {
public:
  BuddyAllocator(uint64_t maxCapacity, u_char * buf, uint64_t bufsize);
  ~BuddyAllocator(){};
  void *allocBlock(uint64_t nbytes);
  void freeBlock(void *ptr);
...
};

struct glob_header_t {
  // каждый знает что такое magic
  uint64_t magic_;
  // hint для присоединения к разделяемой памяти
  const void *own_addr_;
  // собственно аллокатор
  BuddyAllocator alloc_;
  // спинлок
  std::atomic_flag lock_;
  // контейнер для тестирования
  q_map<q_string, q_string> q_map_;
  static const size_t alloc_shift = 0x01000000;
  static const size_t balloc_size = 0x10000000;
  static const size_t alloc_size = balloc_size + alloc_shift;
  static glob_header_t *pglob_;
};
static_assert (
    sizeof(glob_header_t) < glob_header_t::alloc_shift,
    "glob_header_t size mismatch");
glob_header_t *glob_header_t::pglob_ = NULL;

for (int i = 0; i < 100000000; i++)
{
        char buf1[64];
        sprintf(buf1, "key_%d_%d", curid, (i % 100) + 1);
        char buf2[64];
        sprintf(buf2, "val_%d", i + 1);
        LOCK();
        qmap.erase(buf1); // пусть аллокатор трудится
        qmap[buf1] = buf2;
        UNLOCK();
}