RE: [Boost-users] [pool] Speed of pool_allocator<>

1 Jul 2004

      Peter Dimov wrote:
...
Klaus Nowikow wrote:
...
template <class Allocator>
double Test()
{
std::vector<Allocator::value_type, Allocator> Vector;
boost::timer Timer;
for(int i = 0; i < NUM_ELEMENTS; ++i)
{
Vector.push_back(i);
}
return Timer.elapsed();
}
If I read the code correctly, you don't create or delete 
objects. You create
and delete (large) arrays of objects.
I changed the test program (see below). Now I use object_pool<>
to create and destroy a number of elements (I use a vector<C*> to store
them in the meantime). The results are even worse than before:

new/delete:   0.08s
object_pool: 25.20s

Note that I created a class non_pool with an interface similar to
object_pool to be able to use one function template for
both tests.

// MemoryPoolTest.cpp
#include <boost/timer.hpp>
#include <boost/pool/object_pool.hpp>
#include <vector>
#include <iostream>

enum
{
	NUM_ELEMENTS	= 100000
,	CHUNK_SIZE		= NUM_ELEMENTS
};

class C
{
	int   i_;
	char  c_;
};

struct Empty { };

template <class T, class U = Empty>
struct non_pool // create, destroy with new and delete
{
	explicit non_pool(int) { }

	T*	construct() const { return new T; }
	void	destroy(T* pT) { delete pT; }
};

template <template <class, class> class Pool>
double Test()
{
	Pool<C>		P(CHUNK_SIZE);
	boost::timer	Timer;

	std::vector<C*>	V;
	for(int i = 0; i < NUM_ELEMENTS; ++i)
	{
		V.push_back(P.construct());
	}
	for(std::vector<C*>::iterator pos = V.begin(), end = V.end(); pos != end; ++pos)
	{
		P.destroy(*pos);
	}

	return Timer.elapsed();
}

int main(int, char**)
{
	std::cout << "Starting memory pool test" << std::endl;

	double Time;

	std::cout << "Allocating with new                 : ";
	Time	= Test<non_pool>();
	std::cout << Time << "s" << std::endl;

	std::cout << "Allocating with boost::object_pool<>: ";
	Time	= Test<boost::object_pool>();
	std::cout << Time << "s" << std::endl;

	return 0;
}