[Boost-commit] svn:boost r78265 - in sandbox/pool: boost/pool libs/pool/test

Subject: [Boost-commit] svn:boost r78265 - in sandbox/pool: boost/pool libs/pool/test
From: svart.riddare_at_[hidden]
Date: 2012-04-30 07:59:54

Author: edupuis
Date: 2012-04-30 07:59:53 EDT (Mon, 30 Apr 2012)
New Revision: 78265
URL: http://svn.boost.org/trac/boost/changeset/78265

Log:
Added boost::static_pool class and related tests.
Added:
   sandbox/pool/boost/pool/static_pool.hpp   (contents, props changed)
   sandbox/pool/libs/pool/test/test_static_pool.cpp   (contents, props changed)
Text files modified: 
   sandbox/pool/boost/pool/poolfwd.hpp                  |     6 ++++++                                  
   sandbox/pool/libs/pool/test/Jamfile.v2               |     3 +++                                     
   sandbox/pool/libs/pool/test/test_poisoned_macros.cpp |     3 +++                                     
   3 files changed, 12 insertions(+), 0 deletions(-)

Modified: sandbox/pool/boost/pool/poolfwd.hpp
==============================================================================
--- sandbox/pool/boost/pool/poolfwd.hpp	(original)
+++ sandbox/pool/boost/pool/poolfwd.hpp	2012-04-30 07:59:53 EDT (Mon, 30 Apr 2012)
@@ -47,6 +47,12 @@
 class object_pool;
 
 //
+// Location: <boost/pool/static_pool.hpp>
+//
+template<typename UserAllocator = default_user_allocator_new_delete>
+class static_pool;
+
+//
 // Location: <boost/pool/singleton_pool.hpp>
 //
 template <typename Tag, unsigned RequestedSize,

Added: sandbox/pool/boost/pool/static_pool.hpp
==============================================================================
--- (empty file)
+++ sandbox/pool/boost/pool/static_pool.hpp	2012-04-30 07:59:53 EDT (Mon, 30 Apr 2012)
@@ -0,0 +1,94 @@
+// Copyright (C) 2012 Étienne Dupuis
+//
+// 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 for updates, documentation, and revision history.
+
+#ifndef BOOST_STATIC_POOL_HPP
+#define BOOST_STATIC_POOL_HPP
+/*!
+\file
+\brief  Provides a template type boost::static_pool<T, UserAllocator>
+that can be used for fast and efficient memory allocation of objects of type T.
+It also provides automatic destruction of non-deallocated objects.
+*/
+
+#include <boost/pool/poolfwd.hpp>
+
+// boost::pool
+#include <boost/pool/pool.hpp>
+
+namespace boost
+{
+
+
+// DOCUMENTATION TO BE INSERTED
+
+template<typename UserAllocator>
+class static_pool: protected pool<UserAllocator>
+{
+  public:  // Overridden functions
+    explicit static_pool(const size_type nrequested_size, const size_t nrequested_items)
+		:
+		pool<UserAllocator>(nrequested_size, nrequested_items)
+    { 
+			free(pool<UserAllocator>::malloc());
+		}
+
+    void * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
+		{ 
+			return store().empty() ? NULL : store().malloc();
+		}
+
+		void * ordered_malloc()
+		{
+			return store().empty() ? NULL : store().malloc();
+		}
+
+		void * ordered_malloc(size_type n)
+		{
+			const size_type partition_size = alloc_size();
+			const size_type total_req_size = n * requested_size;
+			const size_type num_chunks = total_req_size / partition_size +
+				((total_req_size % partition_size) ? true : false);
+
+			return store().malloc_n(num_chunks, partition_size);
+		}
+
+  public:  // Inherited functions
+		void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const chunk)
+		{ 
+			return pool<UserAllocator>::free(chunk);
+		}
+
+		void ordered_free(void * const chunk)
+		{
+			return pool<UserAllocator>::ordered_free(chunk);
+		}
+
+		void free BOOST_PREVENT_MACRO_SUBSTITUTION(void * const chunks, const size_type n)
+    {
+			return pool<UserAllocator>::free(chunks, n);
+    }
+
+    void ordered_free(void * const chunks, const size_type n)
+		{
+			return pool<UserAllocator>::ordered_free(chunks, n);
+		}
+
+    size_type get_requested_size() const
+    { 
+			return pool<UserAllocator>::get_requestedSize();
+		}
+       
+    bool is_from(void * const chunk) const
+    { 
+			return pool<UserAllocator>::is_from(chunk);
+		}
+};
+
+} // namespace boost
+
+#endif

Modified: sandbox/pool/libs/pool/test/Jamfile.v2
==============================================================================
--- sandbox/pool/libs/pool/test/Jamfile.v2	(original)
+++ sandbox/pool/libs/pool/test/Jamfile.v2	2012-04-30 07:59:53 EDT (Mon, 30 Apr 2012)
@@ -26,6 +26,7 @@
 test-suite pool :
     [ run test_simple_seg_storage.cpp ]
     [ run test_pool_alloc.cpp ]
+    [ run test_static_pool.cpp ]
     [ run pool_msvc_compiler_bug_test.cpp ]
     [ run test_msvc_mem_leak_detect.cpp ]
     [ run test_bug_3349.cpp ]
@@ -42,6 +43,7 @@
 #
     [ run test_simple_seg_storage.cpp  : : : [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1" : <build>no ] : test_simple_seg_storage_valgrind ]
     [ run test_pool_alloc.cpp  : : : [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1" : <build>no  ] : test_pool_alloc_valgrind ]
+    [ run test_static_pool.cpp  : : : [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1" : <build>no  ] : test_static_pool_valgrind ]
     [ run pool_msvc_compiler_bug_test.cpp  : : : [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1"  : <build>no ] : pool_msvc_compiler_bug_test_valgrind ]
     [ run test_msvc_mem_leak_detect.cpp  : : : [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1" : <build>no  ] : test_msvc_mem_leak_detect_valgrind ]
     [ run test_bug_3349.cpp  : : : [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1" : <build>no  ] : test_bug_3349_valgrind ]
@@ -57,6 +59,7 @@
 #
     [ run test_simple_seg_storage.cpp  : : : <define>BOOST_POOL_VALGRIND=1 [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1"  : <build>no ] : test_simple_seg_storage_valgrind_2 ]
     [ run test_pool_alloc.cpp  : : : <define>BOOST_POOL_VALGRIND=1 [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1"  : <build>no  ] : test_pool_alloc_valgrind_2 ]
+    [ run test_static_pool.cpp  : : : <define>BOOST_POOL_VALGRIND=1 [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1"  : <build>no  ] : test_static_pool_valgrind_2 ]
     [ run pool_msvc_compiler_bug_test.cpp  : : : <define>BOOST_POOL_VALGRIND=1 [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1"  : <build>no ] : pool_msvc_compiler_bug_test_valgrind_2 ]
     [ run test_msvc_mem_leak_detect.cpp  : : : <define>BOOST_POOL_VALGRIND=1 [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1"  : <build>no ] : test_msvc_mem_leak_detect_valgrind_2 ]
     [ run test_bug_3349.cpp  : : : <define>BOOST_POOL_VALGRIND=1 [ check-target-builds valgrind_config_check : <testing.launcher>"valgrind --error-exitcode=1"  : <build>no ] : test_bug_3349_valgrind_2 ]

Modified: sandbox/pool/libs/pool/test/test_poisoned_macros.cpp
==============================================================================
--- sandbox/pool/libs/pool/test/test_poisoned_macros.cpp	(original)
+++ sandbox/pool/libs/pool/test/test_poisoned_macros.cpp	2012-04-30 07:59:53 EDT (Mon, 30 Apr 2012)
@@ -33,6 +33,9 @@
 template class boost::pool<boost::default_user_allocator_new_delete>;
 template class boost::pool<boost::default_user_allocator_malloc_free>;
 
+template class boost::static_pool<boost::default_user_allocator_new_delete>;
+template class boost::static_pool<boost::default_user_allocator_malloc_free>;
+
 template class boost::pool_allocator<int, boost::default_user_allocator_new_delete>;
 template class boost::pool_allocator<int, boost::default_user_allocator_malloc_free>;
 template class boost::fast_pool_allocator<int, boost::default_user_allocator_new_delete>;

Added: sandbox/pool/libs/pool/test/test_static_pool.cpp
==============================================================================
--- (empty file)
+++ sandbox/pool/libs/pool/test/test_static_pool.cpp	2012-04-30 07:59:53 EDT (Mon, 30 Apr 2012)
@@ -0,0 +1,119 @@
+/* Copyright (C) 2011 Étienne Dupuis
+ * 
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#include <M:/Boost/Sandbox/pool/boost/pool/static_pool.hpp>
+
+#include <boost/assert.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+// Allocator that checks whether malloc() is called only once
+
+struct user_allocator_once
+{
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
+
+  static char * malloc BOOST_PREVENT_MACRO_SUBSTITUTION(const size_type bytes)
+  {
+		BOOST_TEST(reset);
+		reset = false;
+
+    return new (std::nothrow) char[bytes];
+  }
+
+  static void free BOOST_PREVENT_MACRO_SUBSTITUTION(char * const block)
+  {
+    delete [] block;
+  }
+
+	static bool reset;
+};
+
+bool user_allocator_once::reset = false;
+
+// Main set of test
+
+static void test_static_pool()
+{
+	static const int pool_size = 24;                     // Initial size of pool
+	static const int num_iterations = pool_size + 8;     // Number of mallocs we will try on pool
+	static const int consecutive_elements = 5;           // Number of consecutive elements we will request
+
+	void *p[num_iterations];
+
+	user_allocator_once::reset = true;
+	boost::static_pool<user_allocator_once> pool(sizeof(int), pool_size);
+
+	for (int n = 0; n < 2; n++)
+	{
+		// TEST #1
+		for (int k = 0; k < num_iterations; k++)
+		{
+			p[k] = pool.malloc();
+			BOOST_TEST((p[k] != NULL) == (k < pool_size));
+		}
+
+		for (int k = 0; k < num_iterations; k++)
+			BOOST_ASSERT(!p[k] || pool.is_from(p[k]));
+
+		for (int k = 0; k < num_iterations; k++)
+			p[k] ? pool.ordered_free(p[k]) : (void)(0);
+
+		// TEST #2
+		for (int k = 0; k < num_iterations; k++)
+		{
+			p[k] = pool.ordered_malloc(consecutive_elements);
+			BOOST_TEST((p[k] != NULL) == (k < pool_size / consecutive_elements));
+		}
+
+		for (int k = 0; k < num_iterations; k++)
+			p[k] ? pool.ordered_free(p[k], consecutive_elements) : (void)(0);
+
+		// TEST #3
+		for (int k = 0; k < num_iterations; k++)
+		{
+			p[k] = pool.malloc();
+			BOOST_TEST((p[k] != NULL) == (k < pool_size));
+		}
+
+		for (int k = 0; k < num_iterations; k++)
+			p[k] ? pool.free(p[k]) : (void)(0);
+
+		// TEST #4
+
+		srand(NULL);
+
+		int allocated = 0;
+		for (int k = 0; k < pool_size / 2; k++)
+			p[allocated++] = pool.malloc();
+
+		for (int k = 0; k < 100 * num_iterations; k++)
+		{
+			if ((rand() & 8) && (allocated < pool_size))
+			{
+				p[allocated++] = pool.malloc();
+			}
+			else if (allocated > 0)
+			{
+				void *_p = p[--allocated];
+				BOOST_TEST(_p && pool.is_from(_p));
+				pool.free(_p);
+			}
+		}
+
+		while (allocated > 0)
+			pool.free(p[--allocated]);
+	}
+}
+
+// Main
+
+int main()
+{
+	test_static_pool();
+	return 0;
+}