How to get the true allocator for the std::map? - c++

Question

I want to print the results of the work of my custom memory allocator for the STL map container. I want to get the memory allocation map printed.
I have a problem with get_allocator(). See the example.
The get_allocator() call gives the allocator for the initial pair<int,int>. It even creates it...
Is there a way to get the true allocator (the instance of Pool for RBtree) which gives the memory for the map's elements?
I am using gcc. Thanks.
#include <memory>
#include <map>
using namespace std;
class Pool {
//...
public:
Pool(unsigned n);
~Pool();
void* alloc();
void free(void*);
void print_mm(); //print pool map
//...
};
void* Pool::alloc() {
//...
}
//...
void Pool::print_mm() {
//...
}
template<class T> class Pool_alloc : public allocator<T> {
static Pool pool;
public:
template<class U> struct rebind {
typedef Pool_alloc<U> other;
};
template<class U> Pool_alloc(const Pool_alloc<U>&) {}
Pool_alloc() {}
T* allocate(size_t, void*);
void deallocate(T*, size_t);
void print_mm() {pool.print_mm();}
};
template<class T> Pool Pool_alloc<T>::pool(sizeof(T));
template<class T> T* Pool_alloc<T>::allocate(size_t n, void* = 0) {
//...
return p;
}
template<class T> void Pool_alloc<T>::deallocate(T* p, size_t n) {
//...
}
main() {
map<int, int, less<int>, Pool_alloc<pair<int, int> > > m;
m[144] = 12;
m.get_allocator().print_mm(); //doesn't work - it gives the wrong allocator :-(
}
And the next is the complete code of the example - its base is taken from the famous Bjarne Stroustrup's book. ;-)
#include <iostream>
#include <memory>
#include <map>
using namespace std;
class Pool {
struct Link {Link *next;};
struct Chunk {
static const unsigned size = 8192 - sizeof(Chunk*); //page boundary
Chunk *next;
char mem[size];
} *chunks;
Link *head; //pointer to first free link
Pool(Pool&); //disable
void operator=(Pool&); //disable
void grow();
public:
const unsigned int atomsize;
Pool(unsigned n); //n - number of atoms
~Pool();
void* alloc(); //for one atom
void free(void*);
void print_mm(); //print pool memory map
};
void* Pool::alloc() {
if (head == 0) grow();
Link *p = head;
head = p->next;
return p;
}
void Pool::free(void *b) {
Link *p = static_cast<Link*>(b);
p->next = head;
head = p;
}
Pool::Pool(unsigned sz): atomsize(sz < sizeof(Link*) ? sizeof(Link*) : sz) {
cout << "atom size = " << atomsize << " bytes\n";
head = 0;
chunks = 0;
}
Pool::~Pool() {
Chunk *p = chunks;
while (p) {
Chunk *q = p;
p = p->next;
delete q;
}
}
void Pool::grow() {
Chunk *p = new Chunk;
p->next = chunks;
chunks = p;
const unsigned noe = Chunk::size/atomsize;
char *start = p->mem, *last = start + (noe - 1)*atomsize;
for (char *p = start; p < last; p += atomsize)
((Link*)p)->next = (Link*)(p + atomsize);
((Link*)last)->next = 0;
head = (Link*)start;
}
void Pool::print_mm() {
cout << "The pool memory map\n";
///...
}
template<class T> class Pool_alloc : public allocator<T> {
static Pool pool; //static for STL
public:
template<class U> struct rebind {
typedef Pool_alloc<U> other;
};
template<class U> Pool_alloc(const Pool_alloc<U>&) {}
Pool_alloc() {}
T* allocate(size_t, void*);
void deallocate(T*, size_t);
static void print_mm() {pool.print_mm();}
};
template<class T> Pool Pool_alloc<T>::pool(sizeof(T));
template<class T> T* Pool_alloc<T>::allocate(size_t n, void* = 0) {
T* p;
if (n == 1)
p = static_cast<T*>(pool.alloc());
else
p = static_cast<T*>(allocator<T>::allocate(n)); //STL level
//p = static_cast<T*>(operator new (sizeof(T)*n)); //OS level
return p;
}
template<class T> void Pool_alloc<T>::deallocate(T* p, size_t n) {
if (n == 1)
pool.free(p);
else
allocator<T>::deallocate(p, n); //STL level
//operator delete(p); //OS level
}
main() {
map<int, int, less<int>, Pool_alloc<pair<int, int> > > m;
m.insert(pair<int,int>(7, 8));
for (int i(0); i < 200; ++i)
m[i*i] = 2*i;
m.erase(169);
m.erase(121);
m[5] = 88;
cout << m[7] << '-' << m[5] << '-' << m.size() << endl;
m.get_allocator().print_mm(); //doesn't work - it gives the wrong allocator :-(
}

Answer 1

Try this:
template<class T, Pool* pool> class Pool_alloc : public allocator<T> {
public:
template<class U> struct rebind {
typedef Pool_alloc<U, pool> other;
};
This requires your Pool support data of different sizes.
Alternatively, replace Pool with Pool<sizeof(T)>, maybe using the static method trick to allocate the singleton instance, then you can at least find the various sized allocators. (They could register themselves with a global pool of pools so you can find them later).
Your pool allocator can then be smart enough to use different size chunks for different sized data requested. Or not, as you want.