[various data structures] Reuse validators rather than always creating a new one.

persistent-data/data-structures/array.h

@@ -31,6 +31,7 @@ namespace persistent_data {
 	namespace array_detail {
 		uint32_t const ARRAY_CSUM_XOR = 595846735;
 
+		// FIXME: this isn't used!
 		struct array_block_validator : public block_manager<>::validator {
 			virtual void check(buffer<> const &b, block_address location) const {
 				array_block_disk const *data = reinterpret_cast<array_block_disk const *>(&b);
@@ -135,7 +136,8 @@ namespace persistent_data {
 			  nr_entries_(0),
 			  block_rc_(tm->get_sm(), *this),
 			  block_tree_(tm, block_rc_),
-			  rc_(rc) {
+			  rc_(rc),
+			  validator_(new block_manager<>::noop_validator()) {
 		}
 
 		array(tm_ptr tm,
@@ -147,7 +149,8 @@ namespace persistent_data {
 			  nr_entries_(nr_entries),
 			  block_rc_(tm->get_sm(), *this),
 			  block_tree_(tm, root, block_rc_),
-			  rc_(rc) {
+			  rc_(rc),
+			  validator_(new block_manager<>::noop_validator()) {
 		}
 
 		unsigned get_nr_entries() const {
@@ -253,11 +256,6 @@ namespace persistent_data {
 
 		//--------------------------------
 
-		block_manager<>::validator::ptr validator() const {
-			return block_manager<>::validator::ptr(
-				new block_manager<>::noop_validator());
-		}
-
 		block_address lookup_block_address(unsigned array_index) const {
 			uint64_t key[1] = {array_index};
 			boost::optional<uint64_t> addr = block_tree_.lookup(key);
@@ -272,7 +270,7 @@ namespace persistent_data {
 
 		wblock new_ablock(unsigned ablock_index) {
 			uint64_t key[1] = {ablock_index};
-			write_ref b = tm_->new_block(validator());
+			write_ref b = tm_->new_block(validator_);
 			block_address location = b.get_location();
 
 			wblock wb(b, rc_);
@@ -283,13 +281,13 @@ namespace persistent_data {
 
 		rblock get_ablock(unsigned ablock_index) const {
 			block_address addr = lookup_block_address(ablock_index);
-			return rblock(tm_->read_lock(addr, validator()), rc_);
+			return rblock(tm_->read_lock(addr, validator_), rc_);
 		}
 
 		wblock shadow_ablock(unsigned ablock_index) {
 			uint64_t key[1] = {ablock_index};
 			block_address addr = lookup_block_address(ablock_index);
-			std::pair<write_ref, bool> p = tm_->shadow(addr, validator());
+			std::pair<write_ref, bool> p = tm_->shadow(addr, validator_);
 			wblock wb = wblock(p.first, rc_);
 
 			if (p.second)
@@ -301,7 +299,7 @@ namespace persistent_data {
 		}
 
 		void dec_ablock_entries(block_address addr) {
-			rblock b(tm_->read_lock(addr, validator()), rc_);
+			rblock b(tm_->read_lock(addr, validator_), rc_);
 			b.dec_all_entries();
 		}
 
@@ -311,6 +309,7 @@ namespace persistent_data {
 		block_ref_counter block_rc_;
 		btree<1, block_traits> block_tree_;
 		typename ValueTraits::ref_counter rc_;
+		block_manager<>::validator::ptr validator_;
 	};
 }
 

persistent-data/data-structures/btree.h

@@ -184,8 +184,10 @@ namespace persistent_data {
 
 		class ro_spine : private noncopyable {
 		public:
-			ro_spine(transaction_manager::ptr tm)
-				: tm_(tm) {
+			ro_spine(transaction_manager::ptr tm,
+				 typename block_manager<>::validator::ptr v)
+				: tm_(tm),
+				  validator_(v) {
 			}
 
 			void step(block_address b);
@@ -197,6 +199,7 @@ namespace persistent_data {
 
 		private:
 			transaction_manager::ptr tm_;
+			typename block_manager<>::validator::ptr validator_;
 			std::list<block_manager<>::read_ref> spine_;
 		};
 
@@ -205,8 +208,11 @@ namespace persistent_data {
 			typedef transaction_manager::read_ref read_ref;
 			typedef transaction_manager::write_ref write_ref;
 
-			shadow_spine(transaction_manager::ptr tm)
-				: tm_(tm) {
+			shadow_spine(transaction_manager::ptr tm,
+				     typename block_manager<>::validator::ptr v)
+
+				: tm_(tm),
+				  validator_(v) {
 			}
 
 			// true if the children of the shadow need incrementing
@@ -253,6 +259,7 @@ namespace persistent_data {
 
 		private:
 			transaction_manager::ptr tm_;
+			typename block_manager<>::validator::ptr validator_;
 			std::list<block_manager<>::write_ref> spine_;
 			block_address root_;
 		};
@@ -354,6 +361,7 @@ namespace persistent_data {
 		block_address root_;
 		no_op_ref_counter<uint64_t> internal_rc_;
 		typename ValueTraits::ref_counter rc_;
+		typename block_manager<>::validator::ptr validator_;
 	};
 };
 

persistent-data/data-structures/btree.tcc

@@ -55,11 +55,6 @@ namespace {
 			n->csum = to_disk<base::le32>(sum.get_sum());
 		}
 	};
-
-	block_manager<>::validator::ptr
-	btree_validator() {
-		return block_manager<>::validator::ptr(new btree_node_validator);
-	}
 }
 
 //----------------------------------------------------------------
@@ -67,7 +62,7 @@ namespace {
 inline void
 ro_spine::step(block_address b)
 {
-	spine_.push_back(tm_->read_lock(b, btree_validator()));
+	spine_.push_back(tm_->read_lock(b, validator_));
 	if (spine_.size() > 2)
 		spine_.pop_front();
 }
@@ -75,7 +70,7 @@ ro_spine::step(block_address b)
 inline bool
 shadow_spine::step(block_address b)
 {
-	pair<write_ref, bool> p = tm_->shadow(b, btree_validator());
+	pair<write_ref, bool> p = tm_->shadow(b, validator_);
 	try {
 		step(p.first);
 	} catch (...) {
@@ -368,11 +363,12 @@ btree(typename transaction_manager::ptr tm,
       typename ValueTraits::ref_counter rc)
 	: tm_(tm),
 	  destroy_(false),
-	  rc_(rc)
+	  rc_(rc),
+	  validator_(new btree_node_validator)
 {
 	using namespace btree_detail;
 
-	write_ref root = tm_->new_block(btree_validator());
+	write_ref root = tm_->new_block(validator_);
 
 	leaf_node n = to_node<ValueTraits>(root);
 	n.set_type(btree_detail::LEAF);
@@ -391,7 +387,8 @@ btree(typename transaction_manager::ptr tm,
 	: tm_(tm),
 	  destroy_(false),
 	  root_(root),
-	  rc_(rc)
+	  rc_(rc),
+	  validator_(new btree_node_validator)
 {
 }
 
@@ -423,7 +420,7 @@ btree<Levels, ValueTraits>::lookup(key const &key) const
 {
 	using namespace btree_detail;
 
-        ro_spine spine(tm_);
+        ro_spine spine(tm_, validator_);
 	block_address root = root_;
 
         for (unsigned level = 0; level < Levels - 1; ++level) {
@@ -466,7 +463,7 @@ insert(key const &key,
 
 	block_address block = root_;
 	int index = 0;		// FIXME: ???
-	shadow_spine spine(tm_);
+	shadow_spine spine(tm_, validator_);
 
 	for (unsigned level = 0; level < Levels - 1; ++level) {
 		bool need_insert = insert_location<uint64_traits>(spine, block, key[level], &index);
@@ -592,13 +589,13 @@ split_beneath(btree_detail::shadow_spine &spine,
 	node_type type;
 	unsigned nr_left, nr_right;
 
-	write_ref left = tm_->new_block(btree_validator());
+	write_ref left = tm_->new_block(validator_);
 	node_ref<ValueTraits> l = to_node<ValueTraits>(left);
 	l.set_nr_entries(0);
 	l.set_max_entries();
 	l.set_value_size(sizeof(typename ValueTraits::disk_type));
 
-	write_ref right = tm_->new_block(btree_validator());
+	write_ref right = tm_->new_block(validator_);
 	node_ref<ValueTraits> r = to_node<ValueTraits>(right);
 	r.set_nr_entries(0);
 	r.set_max_entries();
@@ -652,7 +649,7 @@ split_sibling(btree_detail::shadow_spine &spine,
 	node_ref<ValueTraits> l = spine.template get_node<ValueTraits>();
 	block_address left = spine.get_block();
 
-	write_ref right = tm_->new_block(btree_validator());
+	write_ref right = tm_->new_block(validator_);
 	node_ref<ValueTraits> r = to_node<ValueTraits>(right);
 
 	unsigned nr_left = l.get_nr_entries() / 2;