[Boost-commit] svn:boost r54085 - sandbox/monotonic/libs/monotonic/test

Subject: [Boost-commit] svn:boost r54085 - sandbox/monotonic/libs/monotonic/test
From: christian.schladetsch_at_[hidden]
Date: 2009-06-18 23:46:12

Author: cschladetsch
Date: 2009-06-18 23:46:10 EDT (Thu, 18 Jun 2009)
New Revision: 54085
URL: http://svn.boost.org/trac/boost/changeset/54085

Log:
changed tests to just pass the allocator type

Text files modified: 
   sandbox/monotonic/libs/monotonic/test/compare_memory_pool.cpp |   109 ++++++++++++++++++++++----------------- 
   1 files changed, 61 insertions(+), 48 deletions(-)

Modified: sandbox/monotonic/libs/monotonic/test/compare_memory_pool.cpp
==============================================================================
--- sandbox/monotonic/libs/monotonic/test/compare_memory_pool.cpp	(original)
+++ sandbox/monotonic/libs/monotonic/test/compare_memory_pool.cpp	2009-06-18 23:46:10 EDT (Thu, 18 Jun 2009)
@@ -20,35 +20,42 @@
         return A.c < B.c;
 }
 
+template <class Alloc, class T>
+struct Rebind
+{
+	typedef typename Alloc::template rebind<T>::other type;
+};
+
 struct thrash_pool
 {
-	template <class Pool>
-	int operator()(size_t length, Pool &pool) const
+	template <class Alloc>
+	int test(size_t length) const
         {
-		pool.resize(length*rand()/RAND_MAX);
-		return accumulate(pool.begin(), pool.end(), 0);
+		std::vector<int, Rebind<Alloc, int>::type> vector;
+		vector.resize(length*rand()/RAND_MAX);
+		return accumulate(vector.begin(), vector.end(), 0);
         }
 };
 
 struct thrash_pool_sort
 {
-	template <class Pool>
-	int operator()(size_t length, Pool &pool) const
+	template <class Alloc>
+	int test(size_t length) const
         {
-		pool.resize(length*rand()/RAND_MAX);
-		generate_n(back_inserter(pool), length, rand);
-		sort(pool.begin(), pool.end());
+		std::vector<int, Rebind<Alloc, int>::type> vector;
+		vector.resize(length*rand()/RAND_MAX);
+		generate_n(back_inserter(vector), length, rand);
+		sort(vector.begin(), vector.end());
                 return 0;
         }
 };
 
 struct thrash_pool_sort_list_int
 {
-	template <class Pool>
-	int operator()(size_t length, Pool &pool) const
+	template <class Alloc>
+	int test(size_t length) const
         {
-		typedef typename Pool::allocator_type allocator;
-		std::list<int, typename allocator::template rebind<int>::other> list;
+		std::list<int, Rebind<Alloc, int>::type> list;
                 generate_n(back_inserter(list), length, rand);
                 list.sort();
                 return 0;
@@ -57,14 +64,13 @@
 
 struct thrash_pool_iter
 {
-	template <class Pool>
-	int operator()(size_t length, Pool &pool) const
+	template <class Alloc>
+	int test(size_t length) const
         {
-		typedef typename Pool::allocator_type allocator;
-		std::vector<Unaligned, typename allocator::template rebind<Unaligned>::other> vec;
-		vec.resize(length);
+		std::vector<Unaligned, Rebind<Alloc, Unaligned>::type> vector;
+		vector.resize(length);
                 int total = 0;
-		BOOST_FOREACH(Unaligned const &val, vec)
+		BOOST_FOREACH(Unaligned const &val, vector)
                 {
                         total += val.c;
                 }
@@ -75,14 +81,13 @@
 
 struct thrash_pool_map_list_unaligned
 {
-	template <class Pool>
-	int operator()(size_t length, Pool &pool) const
+	template <class Alloc>
+	int test(size_t length) const
         {
-		typedef typename Pool::allocator_type allocator;
                 std::map<int
-			, std::list<Unaligned, typename allocator::template rebind<Unaligned>::other>
+			, std::list<Unaligned, Rebind<Alloc, Unaligned>::type>
                         , std::less<int>
-			, typename allocator::template rebind<int>::other
+			, Rebind<Alloc, int>::type
 		> map;
                 size_t mod = length/10;
                 for (size_t n = 0; n < length; ++n)
@@ -94,6 +99,23 @@
         }
 };
 
+struct test_dupe_list
+{
+	template <class Alloc>
+	int test(size_t count) const
+	{
+		size_t dummy = 0;
+		std::list<int, Rebind<Alloc, int>::type> list;
+		fill_n(back_inserter(list), size, 42);
+		for (size_t n = 0; n < count; ++n)
+		{
+			List dupe = list;
+			dummy += dupe.size();
+		}
+		return dummy;
+	}
+};
+
 struct PoolResult 
 {
         double pool_elapsed;
@@ -112,20 +134,16 @@
 template <class Fun>
 PoolResult compare_memory_pool(size_t count, size_t length, Fun fun)
 {
-	typedef std::vector<
-		int
-		, boost::fast_pool_allocator<int
-			, boost::default_user_allocator_new_delete
-			, boost::details::pool::null_mutex> > 
-		fast_pool_v;
-	typedef std::vector<
-		int
-		, boost::pool_allocator<int
-			, boost::default_user_allocator_new_delete
-			, boost::details::pool::null_mutex> > 
-		pool_v;
-	typedef std::vector<int, boost::monotonic::allocator<int> > mono_v;
-	typedef std::vector<int > std_v;
+	typedef boost::fast_pool_allocator<int
+		, boost::default_user_allocator_new_delete
+		, boost::details::pool::null_mutex>
+		fast_pool_alloc;
+	typedef boost::pool_allocator<int
+		, boost::default_user_allocator_new_delete
+		, boost::details::pool::null_mutex>
+		pool_alloc;
+	typedef monotonic::allocator<int> mono_alloc;
+	typedef std::allocator<int > std_alloc;
 
         PoolResult result;
 
@@ -136,8 +154,7 @@
                 for (size_t n = 0; n < count; ++n)
                 {
                         {
-				fast_pool_v pool;
-				fun(length, pool);
+				fun.test<fast_pool_alloc>(length);
                         }
                         boost::singleton_pool<boost::fast_pool_allocator_tag, sizeof(int)>::release_memory();
                         boost::singleton_pool<boost::fast_pool_allocator_tag, sizeof(Unaligned)>::release_memory();
@@ -153,8 +170,7 @@
                 for (size_t n = 0; n < count; ++n)
                 {
                         {
-				pool_v pool;
-				fun(length, pool);
+				fun.test<pool_alloc>(length);
                         }
                         boost::singleton_pool<boost::pool_allocator_tag, sizeof(int)>::release_memory();
                         boost::singleton_pool<boost::pool_allocator_tag, sizeof(Unaligned)>::release_memory();
@@ -170,8 +186,7 @@
                 for (size_t n = 0; n < count; ++n)
                 {
                         {
-				mono_v pool;
-				fun(length, pool);
+				fun.test<mono_alloc>(length);
                         }
                         boost::monotonic::reset_storage();
                 }
@@ -186,8 +201,7 @@
                 for (size_t n = 0; n < count; ++n)
                 {
                         {
-				mono_v pool;
-				fun(length, pool);
+				fun.test<mono_alloc>(length);
                         }
                         storage.reset();
                 }
@@ -201,8 +215,7 @@
                 for (size_t n = 0; n < count; ++n)
                 {
                         {
-				std_v pool;
-				fun(length, pool);
+				fun.test<std_alloc>(length);
                         }
                 }
                 result.std_elapsed = timer.elapsed();