#include
class test
{
test(void){};
public:
std::vector m_a1;
int* m_b1;
int* m_b2;
const int* m_c1;
const int* m_c2;
const std::string* m_d1;
unsigned int m_e1;
unsigned int m_e2;
unsigned char m_f1;
unsigned char m_f2;
unsigned char m_f3;
unsigned char m_f4;
};
static boost::object_pool<test> s_my_pool;
int main(int argc, char* argv[])
{
int max = 2097120;
for(int i = 0; i < max; i++)
{
test* tst_c = s_my_pool.construct(test());
}
Consider the code above. Compiled with Visual Studio 2010. The purpose
of the class is not important. It is its size (48 bytes) that matters.
The goal is to use object_pool to minimize memory usage.
When running this code the memory rises with just a few bytes more than
the needed 48 bytes * 2.097.120 = 100.661.760 bytes, hence the
object_pool seems to be working fine.
But if I increase the number of elements created by one (to 2097121) the
memory use rises to a massive 200.000.000+ bytes. It seems that the
object_pool has reached a threshold and that the strategy then is to
double the allocated memory. But this can't be right, can it? If so the
object_pool is useless because it's using more memory than a simple
test* tst = new test(); would have done.
Why is object_pool acting like this and is there a way to change the
behavior?
PS! The threshold value is not exactly the same in another application I
have made, but it is pretty close.
Best Regards
Christian Berg
