Use a pool allocator for shared_ptrs with blocks, elections and votes

nano/core_test/CMakeLists.txt

@@ -16,6 +16,7 @@ add_executable (core_test
 	node.cpp
 	message.cpp
 	message_parser.cpp
+	memory_pool.cpp
 	processor_service.cpp
 	peer_container.cpp
 	signing.cpp

nano/core_test/core_test_main.cc

@@ -1,16 +1,18 @@
 #include "gtest/gtest.h"
 
-#include <nano/lib/blocks.hpp>
+#include <nano/node/common.hpp>
+
 namespace nano
 {
 void cleanup_test_directories_on_exit ();
 void force_nano_test_network ();
 }
+
 GTEST_API_ int main (int argc, char ** argv)
 {
 	printf ("Running main() from core_test_main.cc\n");
 	nano::force_nano_test_network ();
-	nano::block_memory_pool_cleanup_guard block_memory_pool_cleanup_guard;
+	nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard;
 	testing::InitGoogleTest (&argc, argv);
 	auto res = RUN_ALL_TESTS ();
 	nano::cleanup_test_directories_on_exit ();

nano/core_test/memory_pool.cpp

@@ -0,0 +1,79 @@
+#include <nano/lib/memory.hpp>
+#include <nano/secure/common.hpp>
+
+#include <gtest/gtest.h>
+
+#include <memory>
+#include <vector>
+
+namespace
+{
+/** This allocator records the size of all allocations that happen */
+template <class T>
+class record_allocations_new_delete_allocator
+{
+public:
+	using value_type = T;
+
+	record_allocations_new_delete_allocator (std::vector<size_t> * allocated) :
+	allocated (allocated)
+	{
+	}
+
+	template <typename U>
+	record_allocations_new_delete_allocator (const record_allocations_new_delete_allocator<U> & a)
+	{
+		allocated = a.allocated;
+	}
+
+	T * allocate (size_t num_to_allocate)
+	{
+		auto size_allocated = (sizeof (T) * num_to_allocate);
+		allocated->push_back (size_allocated);
+		return static_cast<T *> (::operator new (size_allocated));
+	}
+
+	void deallocate (T * p, size_t num_to_deallocate)
+	{
+		::operator delete (p);
+	}
+
+	std::vector<size_t> * allocated;
+};
+
+template <typename T>
+size_t get_allocated_size ()
+{
+	std::vector<size_t> allocated;
+	record_allocations_new_delete_allocator<T> alloc (&allocated);
+	std::allocate_shared<T, record_allocations_new_delete_allocator<T>> (alloc);
+	assert (allocated.size () == 1);
+	return allocated.front ();
+}
+}
+
+TEST (memory_pool, validate_cleanup)
+{
+	nano::make_shared<nano::open_block> (true);
+	nano::make_shared<nano::receive_block> (true);
+	nano::make_shared<nano::send_block> (true);
+	nano::make_shared<nano::change_block> (true);
+	nano::make_shared<nano::state_block> (true);
+	nano::make_shared<nano::vote> (true);
+
+	ASSERT_TRUE (nano::purge_singleton_pool_memory<nano::open_block> ());
+	ASSERT_TRUE (nano::purge_singleton_pool_memory<nano::receive_block> ());
+	ASSERT_TRUE (nano::purge_singleton_pool_memory<nano::send_block> ());
+	ASSERT_TRUE (nano::purge_singleton_pool_memory<nano::state_block> ());
+	ASSERT_TRUE (nano::purge_singleton_pool_memory<nano::vote> ());
+
+	// Change blocks have the same size as open_block so won't deallocate any memory
+	ASSERT_FALSE (nano::purge_singleton_pool_memory<nano::change_block> ());
+
+	ASSERT_EQ (nano::determine_shared_ptr_pool_size<nano::open_block> (), get_allocated_size<nano::open_block> () - sizeof (size_t));
+	ASSERT_EQ (nano::determine_shared_ptr_pool_size<nano::receive_block> (), get_allocated_size<nano::receive_block> () - sizeof (size_t));
+	ASSERT_EQ (nano::determine_shared_ptr_pool_size<nano::send_block> (), get_allocated_size<nano::send_block> () - sizeof (size_t));
+	ASSERT_EQ (nano::determine_shared_ptr_pool_size<nano::change_block> (), get_allocated_size<nano::change_block> () - sizeof (size_t));
+	ASSERT_EQ (nano::determine_shared_ptr_pool_size<nano::state_block> (), get_allocated_size<nano::state_block> () - sizeof (size_t));
+	ASSERT_EQ (nano::determine_shared_ptr_pool_size<nano::vote> (), get_allocated_size<nano::vote> () - sizeof (size_t));
+}

nano/core_test/message.cpp

@@ -79,7 +79,7 @@ TEST (message, confirm_ack_serialization)
 	nano::bufferstream stream2 (bytes.data (), bytes.size ());
 	bool error (false);
 	nano::message_header header (error, stream2);
-	nano::confirm_ack con2 (error, stream2, header);
+	nano::confirm_ack con2 (error, stream2, header, true);
 	ASSERT_FALSE (error);
 	ASSERT_EQ (con1, con2);
 	ASSERT_EQ (header.block_type (), nano::block_type::send);
@@ -106,7 +106,7 @@ TEST (message, confirm_ack_hash_serialization)
 	nano::bufferstream stream2 (bytes.data (), bytes.size ());
 	bool error (false);
 	nano::message_header header (error, stream2);
-	nano::confirm_ack con2 (error, stream2, header);
+	nano::confirm_ack con2 (error, stream2, header, true);
 	ASSERT_FALSE (error);
 	ASSERT_EQ (con1, con2);
 	std::vector<nano::block_hash> vote_blocks;

nano/core_test/node.cpp

@@ -707,6 +707,7 @@ TEST (node_config, v16_v17_upgrade)
 	ASSERT_FALSE (tree.get_optional_child ("tcp_incoming_connections_max"));
 	ASSERT_FALSE (tree.get_optional_child ("vote_generator_delay"));
 	ASSERT_FALSE (tree.get_optional_child ("diagnostics"));
+	ASSERT_FALSE (tree.get_optional_child ("use_memory_pool"));
 
 	config.deserialize_json (upgraded, tree);
 	// The config options should be added after the upgrade
@@ -717,6 +718,7 @@ TEST (node_config, v16_v17_upgrade)
 	ASSERT_TRUE (!!tree.get_optional_child ("tcp_incoming_connections_max"));
 	ASSERT_TRUE (!!tree.get_optional_child ("vote_generator_delay"));
 	ASSERT_TRUE (!!tree.get_optional_child ("diagnostics"));
+	ASSERT_TRUE (!!tree.get_optional_child ("use_memory_pool"));
 
 	ASSERT_TRUE (upgraded);
 	auto version (tree.get<std::string> ("version"));
@@ -751,6 +753,7 @@ TEST (node_config, v17_values)
 		nano::jsonconfig diagnostics_l;
 		diagnostics_l.put_child ("txn_tracking", txn_tracking_l);
 		tree.put_child ("diagnostics", diagnostics_l);
+		tree.put ("use_memory_pool", true);
 	}
 
 	config.deserialize_json (upgraded, tree);
@@ -764,6 +767,7 @@ TEST (node_config, v17_values)
 	ASSERT_EQ (config.diagnostics_config.txn_tracking.min_read_txn_time.count (), 0);
 	ASSERT_EQ (config.diagnostics_config.txn_tracking.min_write_txn_time.count (), 0);
 	ASSERT_TRUE (config.diagnostics_config.txn_tracking.ignore_writes_below_block_processor_max_time);
+	ASSERT_TRUE (config.use_memory_pool);
 
 	// Check config is correct with other values
 	tree.put ("tcp_io_timeout", std::numeric_limits<unsigned long>::max () - 100);
@@ -780,6 +784,7 @@ TEST (node_config, v17_values)
 	nano::jsonconfig diagnostics_l;
 	diagnostics_l.replace_child ("txn_tracking", txn_tracking_l);
 	tree.replace_child ("diagnostics", diagnostics_l);
+	tree.put ("use_memory_pool", false);
 
 	upgraded = false;
 	config.deserialize_json (upgraded, tree);
@@ -795,6 +800,7 @@ TEST (node_config, v17_values)
 	ASSERT_EQ (config.tcp_incoming_connections_max, std::numeric_limits<unsigned>::max ());
 	ASSERT_EQ (config.diagnostics_config.txn_tracking.min_write_txn_time.count (), std::numeric_limits<unsigned>::max ());
 	ASSERT_FALSE (config.diagnostics_config.txn_tracking.ignore_writes_below_block_processor_max_time);
+	ASSERT_FALSE (config.use_memory_pool);
 }
 
 // Regression test to ensure that deserializing includes changes node via get_required_child

nano/lib/CMakeLists.txt

@@ -12,14 +12,14 @@ endif ()
 
 add_library (nano_lib
 	${platform_sources}
-	errors.hpp
-	errors.cpp
 	blockbuilders.hpp
 	blockbuilders.cpp
 	blocks.hpp
 	blocks.cpp
 	config.hpp
 	config.cpp
+	errors.hpp
+	errors.cpp
 	interface.h
 	interface.cpp
 	ipc.hpp
@@ -29,11 +29,13 @@ add_library (nano_lib
 	json_error_response.hpp
 	jsonconfig.hpp
 	logger_mt.hpp
+	memory.hpp
+	memory.cpp
+	numbers.hpp
+	numbers.cpp
 	rpc_handler_interface.hpp
 	rpcconfig.hpp
 	rpcconfig.cpp
-	numbers.hpp
-	numbers.cpp
 	stats.hpp
 	stats.cpp
 	timer.hpp

nano/lib/blocks.cpp

@@ -1,10 +1,11 @@
 #include <nano/crypto_lib/random_pool.hpp>
 #include <nano/lib/blocks.hpp>
+#include <nano/lib/memory.hpp>
 #include <nano/lib/numbers.hpp>
 #include <nano/lib/utility.hpp>
 
 #include <boost/endian/conversion.hpp>
-#include <boost/pool/singleton_pool.hpp>
+#include <boost/pool/pool_alloc.hpp>
 
 /** Compare blocks, first by type, then content. This is an optimization over dynamic_cast, which is very slow on some platforms. */
 namespace
@@ -16,59 +17,26 @@ bool blocks_equal (T const & first, nano::block const & second)
 	return (first.type () == second.type ()) && (static_cast<T const &> (second)) == first;
 }
 
-template <typename tag, typename block_type>
-using pool = boost::singleton_pool<tag, sizeof (block_type)>;
-
-template <typename tag, typename block_type>
-struct pool_deleter
-{
-	void operator() (block_type * p) const
-	{
-		pool<tag, block_type>::free (p);
-	}
-};
-
-template <typename tag, typename block_type>
-std::shared_ptr<block_type> deserialize_block_from_pool (nano::stream & stream_a)
+template <typename block>
+std::shared_ptr<block> deserialize_block (nano::stream & stream_a, bool use_memory_pool)
 {
-	bool error (false);
-	auto obj_raw = static_cast<block_type *> (pool<tag, block_type>::malloc ());
-	new (obj_raw) block_type (error, stream_a);
-	if (!error)
+	auto error (false);
+	auto result = nano::make_shared<block> (use_memory_pool, error, stream_a);
+	if (error)
 	{
-		return std::shared_ptr<block_type> (obj_raw, pool_deleter<tag, block_type>{});
+		result = nullptr;
 	}
-	return nullptr;
-}
 
-struct state_block_tag
-{
-};
-struct send_block_tag
-{
-};
-struct open_block_tag
-{
-};
-struct change_or_receive_block_tag
-{
-};
-
-// For efficiency as change and receive blocks currently have the same size they share the same memory pool
-static_assert (nano::change_block::size == nano::receive_block::size, "Change and receive blocks not longer the same size, a new pool is required");
+	return result;
 }
-
-nano::block_memory_pool_cleanup_guard::~block_memory_pool_cleanup_guard ()
-{
-	purge ();
 }
 
-void nano::block_memory_pool_cleanup_guard::purge ()
+void nano::block_memory_pool_purge ()
 {
-	pool<open_block_tag, nano::open_block>::purge_memory ();
-	pool<state_block_tag, nano::state_block>::purge_memory ();
-	pool<send_block_tag, nano::send_block>::purge_memory ();
-	pool<change_or_receive_block_tag, nano::change_block>::purge_memory ();
+	nano::purge_singleton_pool_memory<nano::open_block> ();
+	nano::purge_singleton_pool_memory<nano::state_block> ();
+	nano::purge_singleton_pool_memory<nano::send_block> ();
+	nano::purge_singleton_pool_memory<nano::change_block> ();
 }
 
 std::string nano::block::to_json () const
@@ -1291,46 +1259,46 @@ std::shared_ptr<nano::block> nano::deserialize_block_json (boost::property_tree:
 	return result;
 }
 
-std::shared_ptr<nano::block> nano::deserialize_block (nano::stream & stream_a)
+std::shared_ptr<nano::block> nano::deserialize_block (nano::stream & stream_a, bool use_memory_pool)
 {
 	nano::block_type type;
 	auto error (try_read (stream_a, type));
 	std::shared_ptr<nano::block> result;
 	if (!error)
 	{
-		result = nano::deserialize_block (stream_a, type);
+		result = nano::deserialize_block (stream_a, type, use_memory_pool);
 	}
 	return result;
 }
 
-std::shared_ptr<nano::block> nano::deserialize_block (nano::stream & stream_a, nano::block_type type_a, nano::block_uniquer * uniquer_a)
+std::shared_ptr<nano::block> nano::deserialize_block (nano::stream & stream_a, nano::block_type type_a, bool use_memory_pool, nano::block_uniquer * uniquer_a)
 {
 	std::shared_ptr<nano::block> result;
 	switch (type_a)
 	{
 		case nano::block_type::receive:
 		{
-			result = deserialize_block_from_pool<change_or_receive_block_tag, nano::receive_block> (stream_a);
+			result = ::deserialize_block<nano::receive_block> (stream_a, use_memory_pool);
 			break;
 		}
 		case nano::block_type::send:
 		{
-			result = deserialize_block_from_pool<send_block_tag, nano::send_block> (stream_a);
+			result = ::deserialize_block<nano::send_block> (stream_a, use_memory_pool);
 			break;
 		}
 		case nano::block_type::open:
 		{
-			result = deserialize_block_from_pool<open_block_tag, nano::open_block> (stream_a);
+			result = ::deserialize_block<nano::open_block> (stream_a, use_memory_pool);
 			break;
 		}
 		case nano::block_type::change:
 		{
-			result = deserialize_block_from_pool<change_or_receive_block_tag, nano::change_block> (stream_a);
+			result = ::deserialize_block<nano::change_block> (stream_a, use_memory_pool);
 			break;
 		}
 		case nano::block_type::state:
 		{
-			result = deserialize_block_from_pool<state_block_tag, nano::state_block> (stream_a);
+			result = ::deserialize_block<nano::state_block> (stream_a, use_memory_pool);
 			break;
 		}
 		default:

nano/lib/blocks.hpp

@@ -356,17 +356,9 @@ class block_uniquer
 
 std::unique_ptr<seq_con_info_component> collect_seq_con_info (block_uniquer & block_uniquer, const std::string & name);
 
-std::shared_ptr<nano::block> deserialize_block (nano::stream &);
-std::shared_ptr<nano::block> deserialize_block (nano::stream &, nano::block_type, nano::block_uniquer * = nullptr);
+std::shared_ptr<nano::block> deserialize_block (nano::stream &, bool use_memory_pool);
+std::shared_ptr<nano::block> deserialize_block (nano::stream &, nano::block_type, bool use_memory_pool, nano::block_uniquer * = nullptr);
 std::shared_ptr<nano::block> deserialize_block_json (boost::property_tree::ptree const &, nano::block_uniquer * = nullptr);
 void serialize_block (nano::stream &, nano::block const &);
-
-class block_memory_pool_cleanup_guard final
-{
-public:
-	~block_memory_pool_cleanup_guard ();
-
-private:
-	static void purge ();
-};
+void block_memory_pool_purge ();
 }

nano/lib/memory.cpp

@@ -0,0 +1,14 @@
+#include <nano/lib/memory.hpp>
+
+nano::cleanup_guard::cleanup_guard (std::vector<std::function<void()>> const & cleanup_funcs_a) :
+cleanup_funcs (cleanup_funcs_a)
+{
+}
+
+nano::cleanup_guard::~cleanup_guard ()
+{
+	for (auto & func : cleanup_funcs)
+	{
+		func ();
+	}
+}