Compare performance of malloc and boost::pool

Andrei Gorine and Konstantin Knizhnik wrote a great article on Dr. Dobb's Journal titled Memory Management & Embedded Databases. In this article, they examine several memory-allocation strategies, explained the advantages/disadvantages based on their experience creating the eXtremeDB in-memory database.

As we know it is normal for malloc/free(new/delete) to take 10-20 percent of the CPU time of an application. Sometime it is nice to have a memory pool to handle some fixed size allocation, especially when you have Boost Pool Library for free.

I wrote a small program, which creates a small and simple data structure on heap a million times to benchmark malloc and boost::object_pool, and the result shows boost::object_pool is a clear winner. I also tried to compare with new operator, even though there is no constructor for the dummy data structure. The difference between malloc and new in this case is insignificant.

The result also shows something interesting which have been mentioned in Raymond Chen's "5 Things Every Win32 Developer Should Know" PDC 2005 talk. If boost::object_pool is used as a pointer, the performance hurts a lot, even through still way faster than malloc.

Here is the result on my laptop (Windows XP, VC 2003 release build, P4 2.4G, 512M):

alloc_with_new_array:   26 microseconds
alloc_with_malloc_array:        11 microseconds
alloc_with_new: 365120 microseconds
alloc_with_malloc:      351586 microseconds
alloc_with_boost_pool_construct:        7852 microseconds
alloc_with_boost_pool_malloc:   3371 microseconds
alloc_with_boost_pool_malloc_use_pointer:       11751 microseconds
alloc_with_boost_pool_malloc_use_reference:     3383 microseconds

Here is code:

#include <boost/pool/object_pool.hpp>

struct dummy_data
{
 int a;
 int b;
};

inline void alloc_with_new(size_t size)
{
 dummy_data* p;
 for (size_t i = 0; i < size; ++i)
 {
  p = new dummy_data;
  delete p;
 }
}

inline void alloc_with_malloc(size_t size)
{
 dummy_data* p;
 for (size_t i = 0; i < size; ++i)
 {
  p = (dummy_data*)malloc(sizeof(dummy_data));
  free(p);
 }
}

inline void alloc_with_boost_pool_construct(size_t size)
{
 boost::object_pool<dummy_data> pool;
 dummy_data* p;
 for (size_t i = 0; i < size; ++i)
 {
  p = pool.construct();
  pool.destroy(p);
 }
}



inline void alloc_with_boost_pool_malloc(size_t size)
{
 boost::object_pool<dummy_data> pool;
 dummy_data* p;
 for (size_t i = 0; i < size; ++i)
 {
  p = pool.malloc();
  pool.free(p);
 }
}

inline void alloc_with_boost_pool_malloc_use_pointer(size_t size)
{
 boost::object_pool<dummy_data>* pool = new boost::object_pool<dummy_data>;
 dummy_data* p;
 for (size_t i = 0; i < size; ++i)
 {
  p = pool->malloc();
  pool->free(p);
 }

 delete pool;
}

inline void alloc_with_boost_pool_malloc_use_reference(size_t size)
{
 boost::object_pool<dummy_data> _pool;
 boost::object_pool<dummy_data>& pool = _pool;
 dummy_data* p;
 for (size_t i = 0; i < size; ++i)
 {
  p = pool.malloc();
  pool.free(p);
 }
}

inline void alloc_with_new_array(size_t size)
{
 dummy_data* p = new dummy_data[size];
 delete[] p;
}

inline void alloc_with_malloc_array(size_t size)
{
 dummy_data* p = (dummy_data*)malloc(sizeof(dummy_data) * size);
 free(p);
}

int main (int, char**)
{
 LARGE_INTEGER freq, t0, t1;
 QueryPerformanceFrequency(&freq);

 size_t number = 1000000;

 QueryPerformanceCounter(&t0);
 alloc_with_new_array(number);
 QueryPerformanceCounter(&t1);
 printf("alloc_with_new_array: %d microseconds\n",
  ((t1.QuadPart-t0.QuadPart)*1000000)/freq.QuadPart);

 QueryPerformanceCounter(&t0);
 alloc_with_malloc_array(number);
 QueryPerformanceCounter(&t1);
 printf("alloc_with_malloc_array: %d microseconds\n",
  ((t1.QuadPart-t0.QuadPart)*1000000)/freq.QuadPart);

 QueryPerformanceCounter(&t0);
 alloc_with_new(number);
 QueryPerformanceCounter(&t1);
 printf("alloc_with_new: %d microseconds\n",
  ((t1.QuadPart-t0.QuadPart)*1000000)/freq.QuadPart);

 QueryPerformanceCounter(&t0);
 alloc_with_malloc(number);
 QueryPerformanceCounter(&t1);
 printf("alloc_with_malloc: %d microseconds\n",
  ((t1.QuadPart-t0.QuadPart)*1000000)/freq.QuadPart);

 QueryPerformanceCounter(&t0);
 alloc_with_boost_pool_construct(number);
 QueryPerformanceCounter(&t1);
 printf("alloc_with_boost_pool_construct: %d microseconds\n",
  ((t1.QuadPart-t0.QuadPart)*1000000)/freq.QuadPart);

 QueryPerformanceCounter(&t0);
 alloc_with_boost_pool_malloc(number);
 QueryPerformanceCounter(&t1);
 printf("alloc_with_boost_pool_malloc: %d microseconds\n",
  ((t1.QuadPart-t0.QuadPart)*1000000)/freq.QuadPart);

 QueryPerformanceCounter(&t0);
 alloc_with_boost_pool_malloc_use_pointer(number);
 QueryPerformanceCounter(&t1);
 printf("alloc_with_boost_pool_malloc_use_pointer: %d microseconds\n",
  ((t1.QuadPart-t0.QuadPart)*1000000)/freq.QuadPart);

 QueryPerformanceCounter(&t0);
 alloc_with_boost_pool_malloc_use_reference(number);
 QueryPerformanceCounter(&t1);
 printf("alloc_with_boost_pool_malloc_use_reference: %d microseconds\n",
  ((t1.QuadPart-t0.QuadPart)*1000000)/freq.QuadPart);

 return 0;
}