Squashed 'third_party/boostorg/container/' content from commit 1ad6431
Change-Id: I7d095db3455264c03446268e5675b926bebedb0a
git-subtree-dir: third_party/boostorg/container
git-subtree-split: 1ad64316a432a7f021b4956acf88abc6aaa8a77e
diff --git a/bench/bench_alloc.cpp b/bench/bench_alloc.cpp
new file mode 100644
index 0000000..b05748e
--- /dev/null
+++ b/bench/bench_alloc.cpp
@@ -0,0 +1,184 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef _MSC_VER
+#pragma warning (disable : 4512)
+#endif
+
+#include <boost/container/detail/dlmalloc.hpp>
+
+#define BOOST_INTERPROCESS_VECTOR_ALLOC_STATS
+
+#include <iostream> //std::cout, std::endl
+#include <typeinfo> //typeid
+#include <cassert> //assert
+
+#include <boost/timer/timer.hpp>
+using boost::timer::cpu_timer;
+using boost::timer::cpu_times;
+using boost::timer::nanosecond_type;
+
+using namespace boost::container;
+
+template <class POD>
+void allocation_timing_test(unsigned int num_iterations, unsigned int num_elements)
+{
+ size_t capacity = 0;
+ unsigned int numalloc = 0, numexpand = 0;
+
+ std::cout
+ << " ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \n"
+ << " Iterations/Elements: " << num_iterations << "/" << num_elements << '\n'
+ << " ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \n"
+ << std::endl;
+
+
+ allocation_type malloc_types[] = { BOOST_CONTAINER_EXPAND_BWD, BOOST_CONTAINER_EXPAND_FWD, BOOST_CONTAINER_ALLOCATE_NEW };
+ const char * malloc_names[] = { "Backwards expansion", "Forward expansion", "New allocation" };
+ for(size_t i = 0; i < sizeof(malloc_types)/sizeof(allocation_type); ++i){
+ numalloc = 0; numexpand = 0;
+ const allocation_type m_mode = malloc_types[i];
+ const char *malloc_name = malloc_names[i];
+
+ cpu_timer timer;
+ timer.resume();
+
+ for(unsigned int r = 0; r != num_iterations; ++r){
+ void *first_mem = 0;
+ if(m_mode != BOOST_CONTAINER_EXPAND_FWD)
+ first_mem = dlmalloc_malloc(sizeof(POD)*num_elements*3/2);
+ void *addr = dlmalloc_malloc(1*sizeof(POD));
+ if(m_mode == BOOST_CONTAINER_EXPAND_FWD)
+ first_mem = dlmalloc_malloc(sizeof(POD)*num_elements*3/2);
+ capacity = dlmalloc_size(addr)/sizeof(POD);
+ dlmalloc_free(first_mem);
+ ++numalloc;
+
+ try{
+ dlmalloc_command_ret_t ret;
+ for(size_t e = capacity + 1; e < num_elements; ++e){
+ size_t received_size;
+ size_t min = (capacity+1)*sizeof(POD);
+ size_t max = (capacity*3/2)*sizeof(POD);
+ if(min > max)
+ max = min;
+ ret = dlmalloc_allocation_command
+ ( m_mode, sizeof(POD)
+ , min, max, &received_size, addr);
+ if(!ret.first){
+ std::cout << "(!ret.first)!" << std::endl;
+ throw int(0);
+ }
+ if(!ret.second){
+ assert(m_mode == BOOST_CONTAINER_ALLOCATE_NEW);
+ if(m_mode != BOOST_CONTAINER_ALLOCATE_NEW){
+ std::cout << "m_mode != BOOST_CONTAINER_ALLOCATE_NEW!" << std::endl;
+ return;
+ }
+ dlmalloc_free(addr);
+ addr = ret.first;
+ ++numalloc;
+ }
+ else{
+ assert(m_mode != BOOST_CONTAINER_ALLOCATE_NEW);
+ if(m_mode == BOOST_CONTAINER_ALLOCATE_NEW){
+ std::cout << "m_mode == BOOST_CONTAINER_ALLOCATE_NEW!" << std::endl;
+ return;
+ }
+ ++numexpand;
+ }
+ capacity = received_size/sizeof(POD);
+ addr = ret.first;
+ e = capacity + 1;
+ }
+ dlmalloc_free(addr);
+ }
+ catch(...){
+ dlmalloc_free(addr);
+ throw;
+ }
+ }
+
+ assert( dlmalloc_allocated_memory() == 0);
+ if(dlmalloc_allocated_memory()!= 0){
+ std::cout << "Memory leak!" << std::endl;
+ return;
+ }
+
+ timer.stop();
+ nanosecond_type nseconds = timer.elapsed().wall;
+
+ std::cout << " Malloc type: " << malloc_name
+ << std::endl
+ << " allocation ns: "
+ << float(nseconds)/(num_iterations*num_elements)
+ << std::endl
+ << " capacity - alloc calls (new/expand): "
+ << (unsigned int)capacity << " - "
+ << (float(numalloc) + float(numexpand))/num_iterations
+ << "(" << float(numalloc)/num_iterations << "/" << float(numexpand)/num_iterations << ")"
+ << std::endl << std::endl;
+ dlmalloc_trim(0);
+ }
+}
+
+template<unsigned N>
+struct char_holder
+{
+ char ints_[N];
+};
+
+template<class POD>
+int allocation_loop()
+{
+ std::cout << std::endl
+ << "-------------------------------------------\n"
+ << "-------------------------------------------\n"
+ << " Type(sizeof): " << typeid(POD).name() << " (" << sizeof(POD) << ")\n"
+ << "-------------------------------------------\n"
+ << "-------------------------------------------\n"
+ << std::endl;
+
+ #define SINGLE_TEST
+ #ifndef SINGLE_TEST
+ #ifdef NDEBUG
+ unsigned int numrep [] = { /*10000, */10000, 100000, 1000000 };
+ #else
+ unsigned int numrep [] = { /*10000, */1000, 10000, 100000 };
+ #endif
+ unsigned int numele [] = { /*10000, */1000, 100, 10 };
+ #else
+ #ifdef NDEBUG
+ unsigned int numrep [] = { 50000 };
+ #else
+ unsigned int numrep [] = { 5000 };
+ #endif
+ unsigned int numele [] = { 100 };
+ #endif
+
+ for(unsigned int i = 0; i < sizeof(numele)/sizeof(numele[0]); ++i){
+ allocation_timing_test<POD>(numrep[i], numele[i]);
+ }
+
+ return 0;
+}
+
+int main()
+{
+ dlmalloc_mallopt( (-3)//M_MMAP_THRESHOLD
+ , 100*10000000);
+ //allocation_loop<char_holder<4> >();
+ //allocation_loop<char_holder<6> >();
+ allocation_loop<char_holder<8> >();
+ allocation_loop<char_holder<12> >();
+ //allocation_loop<char_holder<14> >();
+ allocation_loop<char_holder<24> >();
+ return 0;
+}