add a cache to the block manager

Makefile

@@ -28,8 +28,8 @@ test-programs: $(TEST_PROGRAMS)
 .SUFFIXES: .cc .o .d
 
 %.d: %.cc
-	g++ -MM $(CPPFLAGS) $< > $@.$$$$;                  \
+	g++ -MM -MT $(subst .cc,.o,$<) $(CPPFLAGS) $< > $@.$$$$;                  \
-	sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
+	sed 's,\([^ :]*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
 	rm -f $@.$$$$
 
 .cc.o:

block.h

@@ -1,6 +1,8 @@
 #ifndef BLOCK_H
 #define BLOCK_H
 
+#include "cache.h"
+
 #include <stdint.h>
 #include <map>
 #include <vector>
@@ -17,50 +19,58 @@ namespace persistent_data {
 
 	uint32_t const MD_BLOCK_SIZE = 4096;
 
-	class count_adjuster {
+	typedef uint64_t block_address;
+
+	template <uint32_t BlockSize>
+	class block_io : private boost::noncopyable {
 	public:
-		count_adjuster(unsigned &c)
+		typedef boost::shared_ptr<block_io> ptr;
-			: c_(c) {
+		typedef unsigned char buffer[BlockSize];
-			c_++;
+		typedef unsigned char const const_buffer[BlockSize];
+
+		block_io(std::string const &path, block_address nr_blocks, bool writeable = false);
+		~block_io();
+
+		block_address get_nr_blocks() const {
+			return nr_blocks_;
 		}
 
-		~count_adjuster() {
+		void read_buffer(block_address location, buffer &buf) const;
-			c_--;
+		void write_buffer(block_address location, const_buffer &buf);
-		}
 
 	private:
-		unsigned &c_;
+		int fd_;
+		block_address nr_blocks_;
+		bool writeable_;
 	};
 
-	typedef uint64_t block_address;
-
 	template <uint32_t BlockSize = MD_BLOCK_SIZE>
 	class block_manager : private boost::noncopyable {
 	public:
 		typedef boost::shared_ptr<block_manager> ptr;
 
-		block_manager(std::string const &path, block_address nr_blocks, bool writeable = false);
+		block_manager(std::string const &path,
-		~block_manager();
+			      block_address nr_blocks,
+			      unsigned max_concurrent_locks,
+			      bool writeable = false);
 
 		typedef unsigned char buffer[BlockSize];
 		typedef unsigned char const const_buffer[BlockSize];
 
-		class block;
-
 		class validator {
 		public:
 			typedef boost::shared_ptr<validator> ptr;
 
 			virtual ~validator() {}
 
-			virtual void check(block const &b) const = 0;
+			virtual void check(const_buffer &b, block_address location) const = 0;
-			virtual void prepare(block &b) const = 0;
+			virtual void prepare(buffer &b, block_address location) const = 0;
 		};
 
 		class noop_validator : public validator {
 		public:
-			void check(block const &b) const {}
+			void check(const_buffer &b, block_address location) const {}
-			void prepare(block &b) const {}
+			void prepare(buffer &b, block_address location) const {}
 		};
 
 		enum block_type {
@@ -71,46 +81,57 @@ namespace persistent_data {
 		struct block {
 			typedef boost::shared_ptr<block> ptr;
 
-			block(block_address location,
+			block(typename block_io<BlockSize>::ptr io,
-			      const_buffer &data,
+			      block_address location,
-			      unsigned &count,
-			      unsigned &type_count,
 			      block_type bt,
-			      typename validator::ptr v)
+			      typename validator::ptr v,
-				: location_(location),
+			      bool zero = false);
-				  adjuster_(count),
+			~block();
-				  type_adjuster_(type_count),
+
-				  validator_(v),
+			void check_read_lockable() const {
-				  bt_(bt) {
+				// FIXME: finish
-				::memcpy(data_, data, sizeof(data));
 			}
 
+			void check_write_lockable() const {
+				// FIXME: finish
+			}
+
+			void flush();
+
+			typename block_io<BlockSize>::ptr io_;
 			block_address location_;
-			count_adjuster adjuster_;
-			count_adjuster type_adjuster_;
 			buffer data_;
 			typename validator::ptr validator_;
 			block_type bt_;
+			bool dirty_;
 		};
+		typedef typename block::ptr block_ptr;
 
 		class read_ref {
 		public:
-			read_ref(typename block::ptr b);
+			read_ref(block_manager<BlockSize> const &bm,
-			virtual ~read_ref() {}
+				 block_ptr b);
+			read_ref(read_ref const &rhs);
+			virtual ~read_ref();
+
+			read_ref const &operator =(read_ref const &rhs);
 
 			block_address get_location() const;
 			const_buffer &data() const;
 
 		protected:
-			friend class block_manager;
+			friend class block_manager; // FIXME: still needed?
-			typename block::ptr block_;
+			block_manager<BlockSize> const &bm_;
+			block_ptr block_;
+			unsigned *holders_;
 		};
 
 		// Inherited from read_ref, since you can read a block that's write
 		// locked.
 		class write_ref : public read_ref {
 		public:
-			write_ref(typename block::ptr b);
+			write_ref(block_manager<BlockSize> const &bm,
+				  typename block::ptr b);
 
 			using read_ref::data;
 			buffer &data();
@@ -122,11 +143,6 @@ namespace persistent_data {
 			  typename validator::ptr v =
 			  typename validator::ptr(new noop_validator())) const;
 
-		boost::optional<read_ref>
-		read_try_lock(block_address location,
-			      typename validator::ptr v =
-			      typename validator::ptr(new noop_validator())) const;
-
 		write_ref
 		write_lock(block_address location,
 			   typename validator::ptr v =
@@ -156,28 +172,30 @@ namespace persistent_data {
 
 		block_address get_nr_blocks() const;
 
+		void flush() const;
+
 	private:
 		void check(block_address b) const;
-
+		void write_block(block_ptr b) const;
-		void read_buffer(block_address location, buffer &buf) const;
-		void write_buffer(block_address location, const_buffer &buf);
-		void zero_buffer(buffer &buf) const;
-		void read_release(block *b) const;
-		void write_release(block *b);
 
 		enum lock_type {
 			READ_LOCK,
 			WRITE_LOCK
 		};
 
-		void register_lock(block_address b, lock_type t) const;
+		struct cache_traits {
-		void unregister_lock(block_address b, lock_type t) const;
+			typedef typename block::ptr value_type;
+			typedef block_address key_type;
 
-		int fd_;
+			static key_type get_key(value_type const &v) {
-		block_address nr_blocks_;
+				return v->location_;
-		mutable unsigned lock_count_;
+			}
-		mutable unsigned superblock_count_;
+		};
-		mutable unsigned ordinary_count_;
+
+		typename block_io<BlockSize>::ptr io_;
+		mutable base::cache<cache_traits> cache_;
+
+		// FIXME: we need a dirty list as well as a cache
 
 		typedef std::map<block_address, std::pair<lock_type, unsigned> > held_map;
 		mutable held_map held_locks_;

block.tcc

@@ -16,46 +16,9 @@ using namespace std;
 //----------------------------------------------------------------
 
 template <uint32_t BlockSize>
-block_manager<BlockSize>::read_ref::read_ref(typename block_manager::block::ptr b)
+block_io<BlockSize>::block_io(std::string const &path, block_address nr_blocks, bool writeable)
-	: block_(b)
-{
-}
-
-template <uint32_t BlockSize>
-block_address
-block_manager<BlockSize>::read_ref::get_location() const
-{
-	return block_->location_;
-}
-
-template <uint32_t BlockSize>
-typename block_manager<BlockSize>::const_buffer &
-block_manager<BlockSize>::read_ref::data() const
-{
-	return block_->data_;
-}
-
-template <uint32_t BlockSize>
-block_manager<BlockSize>::write_ref::write_ref(typename block_manager::block::ptr b)
-	: read_ref(b)
-{
-}
-
-template <uint32_t BlockSize>
-typename block_manager<BlockSize>::buffer &
-block_manager<BlockSize>::write_ref::data()
-{
-	return read_ref::block_->data_;
-}
-
-//----------------------------------------------------------------
-
-template <uint32_t BlockSize>
-block_manager<BlockSize>::block_manager(std::string const &path, block_address nr_blocks, bool writeable)
 	: nr_blocks_(nr_blocks),
-	  lock_count_(0),
+	  writeable_(writeable)
-	  superblock_count_(0),
-	  ordinary_count_(0)
 {
 	fd_ = ::open(path.c_str(), writeable ? (O_RDWR | O_CREAT) : O_RDONLY, 0666);
 	if (fd_ < 0)
@@ -63,106 +26,17 @@ block_manager<BlockSize>::block_manager(std::string const &path, block_address n
 }
 
 template <uint32_t BlockSize>
-block_manager<BlockSize>::~block_manager()
+block_io<BlockSize>::~block_io()
 {
 	::close(fd_);
 }
 
-template <uint32_t BlockSize>
-typename block_manager<BlockSize>::read_ref
-block_manager<BlockSize>::read_lock(block_address location,
-				    typename block_manager<BlockSize>::validator::ptr v) const
-{
-	check(location);
-
-	buffer buf;
-	read_buffer(location, buf);
-	typename block::ptr b(new block(location, buf, lock_count_, ordinary_count_, BT_NORMAL, v),
-			      bind(&block_manager::read_release, this, _1));
-	register_lock(location, READ_LOCK);
-	return read_ref(b);
-}
-
-template <uint32_t BlockSize>
-optional<typename block_manager<BlockSize>::read_ref>
-block_manager<BlockSize>::read_try_lock(block_address location,
-					typename block_manager<BlockSize>::validator::ptr v) const
-{
-	return read_lock(location, v);
-}
-
-template <uint32_t BlockSize>
-typename block_manager<BlockSize>::write_ref
-block_manager<BlockSize>::write_lock(block_address location,
-				     typename block_manager<BlockSize>::validator::ptr v)
-{
-	check(location);
-
-	buffer buf;
-	read_buffer(location, buf);
-	typename block::ptr b(new block(location, buf, lock_count_, ordinary_count_, BT_NORMAL, v),
-			      bind(&block_manager::write_release, this, _1));
-	register_lock(location, WRITE_LOCK);
-	return write_ref(b);
-}
-
-template <uint32_t BlockSize>
-typename block_manager<BlockSize>::write_ref
-block_manager<BlockSize>::write_lock_zero(block_address location,
-					  typename block_manager<BlockSize>::validator::ptr v)
-{
-	check(location);
-
-	buffer buf;
-	zero_buffer(buf);
-	typename block::ptr b(new block(location, buf, lock_count_, ordinary_count_, BT_NORMAL, v),
-			      bind(&block_manager::write_release, this, _1));
-	register_lock(location, WRITE_LOCK);
-	return write_ref(b);
-}
-
-template <uint32_t BlockSize>
-typename block_manager<BlockSize>::write_ref
-block_manager<BlockSize>::superblock(block_address location,
-				     typename block_manager<BlockSize>::validator::ptr v)
-{
-	if (superblock_count_ > 0)
-		throw runtime_error("already have superblock");
-
-	check(location);
-
-	buffer buf;
-	read_buffer(location, buf);
-	typename block::ptr b(new block(location, buf, lock_count_, superblock_count_, BT_SUPERBLOCK, v),
-			      bind(&block_manager::write_release, this, _1));
-	register_lock(location, WRITE_LOCK);
-	return write_ref(b);
-}
-
-template <uint32_t BlockSize>
-typename block_manager<BlockSize>::write_ref
-block_manager<BlockSize>::superblock_zero(block_address location,
-					  typename block_manager<BlockSize>::validator::ptr v)
-{
-	if (superblock_count_ > 0)
-		throw runtime_error("already have superblock");
-
-	check(location);
-
-	buffer buf;
-	zero_buffer(buf);
-	typename block::ptr b(new block(location, buf, lock_count_, superblock_count_, true, v),
-			      bind(&block_manager::write_release, this, _1));
-	register_lock(location, WRITE_LOCK);
-	return write_ref(b);
-}
-
 template <uint32_t BlockSize>
 void
-block_manager<BlockSize>::read_buffer(block_address b, block_manager<BlockSize>::buffer &buffer) const
+block_io<BlockSize>::read_buffer(block_address location, buffer &buffer) const
 {
 	off_t r;
-	r = ::lseek(fd_, BlockSize * b, SEEK_SET);
+	r = ::lseek(fd_, BlockSize * location, SEEK_SET);
 	if (r == (off_t) -1)
 		throw std::runtime_error("lseek failed");
 
@@ -183,10 +57,10 @@ block_manager<BlockSize>::read_buffer(block_address b, block_manager<BlockSize>:
 
 template <uint32_t BlockSize>
 void
-block_manager<BlockSize>::write_buffer(block_address b, block_manager<BlockSize>::const_buffer &buffer)
+block_io<BlockSize>::write_buffer(block_address location, const_buffer &buffer)
 {
 	off_t r;
-	r = ::lseek(fd_, BlockSize * b, SEEK_SET);
+	r = ::lseek(fd_, BlockSize * location, SEEK_SET);
 	if (r == (off_t) -1)
 		throw std::runtime_error("lseek failed");
 
@@ -205,43 +79,237 @@ block_manager<BlockSize>::write_buffer(block_address b, block_manager<BlockSize>
 		throw std::runtime_error("write failed");
 }
 
+//----------------------------------------------------------------
+
 template <uint32_t BlockSize>
-void
+block_manager<BlockSize>::block::block(typename block_io<BlockSize>::ptr io,
-block_manager<BlockSize>::zero_buffer(block_manager<BlockSize>::buffer &buffer) const
+				       block_address location,
+				       block_type bt,
+				       typename validator::ptr v,
+				       bool zero)
+	: io_(io),
+	  location_(location),
+	  validator_(v),
+	  bt_(bt),
+	  dirty_(false)
 {
-	::memset(buffer, 0, BlockSize);
+	if (zero) {
+		memset(&data_, 0, sizeof(data_));
+		dirty_ = true;
+	} else {
+		io_->read_buffer(location_, data_);
+		validator_->check(data_, location_);
+	}
 }
 
-// FIXME: we don't need this anymore
 template <uint32_t BlockSize>
-void
+block_manager<BlockSize>::block::~block()
-block_manager<BlockSize>::read_release(block *b) const
 {
-	unregister_lock(b->location_, READ_LOCK);
+	flush();
-	delete b;
 }
 
 template <uint32_t BlockSize>
 void
-block_manager<BlockSize>::write_release(block *b)
+block_manager<BlockSize>::block::flush()
 {
-	if (b->bt_ == BT_SUPERBLOCK) {
+	if (dirty_) {
-		if (lock_count_ != 1)
+		validator_->prepare(data_, location_);
-			throw runtime_error("superblock isn't the last block");
+		io_->write_buffer(location_, data_);
+	}
+}
+
+//----------------------------------------------------------------
+
+template <uint32_t BlockSize>
+block_manager<BlockSize>::read_ref::read_ref(block_manager<BlockSize> const &bm,
+					     block_ptr b)
+	: bm_(bm),
+	  block_(b),
+	  holders_(new unsigned)
+{
+	*holders_ = 1;
+}
+
+template <uint32_t BlockSize>
+block_manager<BlockSize>::read_ref::read_ref(read_ref const &rhs)
+	: bm_(rhs.bm_),
+	  block_(rhs.block_),
+	  holders_(rhs.holders_)
+{
+	(*holders_)++;
+}
+
+template <uint32_t BlockSize>
+block_manager<BlockSize>::read_ref::~read_ref()
+{
+	if (!--(*holders_)) {
+		if (block_->bt_ == BT_SUPERBLOCK) {
+			bm_.flush();
+			bm_.cache_.put(block_);
+			bm_.flush();
+		} else
+			bm_.cache_.put(block_);
+
+		delete holders_;
+	}
+}
+
+template <uint32_t BlockSize>
+typename block_manager<BlockSize>::read_ref const &
+block_manager<BlockSize>::read_ref::operator =(read_ref const &rhs)
+{
+	if (this != &rhs) {
+		block_ = rhs.block_;
+		bm_ = rhs.bm_;
+		holders_ = rhs.holders_;
+		(*holders_)++;
+	}
+}
+
+template <uint32_t BlockSize>
+block_address
+block_manager<BlockSize>::read_ref::get_location() const
+{
+	return block_->location_;
+}
+
+template <uint32_t BlockSize>
+typename block_manager<BlockSize>::const_buffer &
+block_manager<BlockSize>::read_ref::data() const
+{
+	return block_->data_;
+}
+
+//--------------------------------
+
+template <uint32_t BlockSize>
+block_manager<BlockSize>::write_ref::write_ref(block_manager<BlockSize> const &bm,
+					       block_ptr b)
+	: read_ref(bm, b)
+{
+	b->dirty_ = true;
+}
+
+template <uint32_t BlockSize>
+typename block_manager<BlockSize>::buffer &
+block_manager<BlockSize>::write_ref::data()
+{
+	return read_ref::block_->data_;
+}
+
+//----------------------------------------------------------------
+
+template <uint32_t BlockSize>
+block_manager<BlockSize>::block_manager(std::string const &path,
+					block_address nr_blocks,
+					unsigned max_concurrent_blocks,
+					bool writeable)
+	: io_(new block_io<BlockSize>(path, nr_blocks, writeable)),
+	  cache_(max(64u, max_concurrent_blocks))
+{
+}
+
+template <uint32_t BlockSize>
+typename block_manager<BlockSize>::read_ref
+block_manager<BlockSize>::read_lock(block_address location,
+				    typename block_manager<BlockSize>::validator::ptr v) const
+{
+	check(location);
+	boost::optional<block_ptr> cached_block = cache_.get(location);
+
+	if (cached_block) {
+		(*cached_block)->check_read_lockable();
+		return read_ref(*this, *cached_block);
 	}
 
-	b->validator_->prepare(*b);
+	block_ptr b(new block(io_, location, BT_NORMAL, v));
+	cache_.insert(b);
+	return read_ref(*this, b);
+}
 
-	write_buffer(b->location_, b->data_);
+template <uint32_t BlockSize>
-	unregister_lock(b->location_, WRITE_LOCK);
+typename block_manager<BlockSize>::write_ref
-	delete b;
+block_manager<BlockSize>::write_lock(block_address location,
+				     typename block_manager<BlockSize>::validator::ptr v)
+{
+	check(location);
+
+	boost::optional<block_ptr> cached_block = cache_.get(location);
+
+	if (cached_block) {
+		(*cached_block)->check_write_lockable();
+		return write_ref(*this, *cached_block);
+	}
+
+	block_ptr b(new block(io_, location, BT_NORMAL, v));
+	cache_.insert(b);
+	return write_ref(*this, b);
+}
+
+template <uint32_t BlockSize>
+typename block_manager<BlockSize>::write_ref
+block_manager<BlockSize>::write_lock_zero(block_address location,
+					  typename block_manager<BlockSize>::validator::ptr v)
+{
+	check(location);
+
+	boost::optional<block_ptr> cached_block = cache_.get(location);
+	if (cached_block) {
+		(*cached_block)->check_write_lockable();
+		memset(&(*cached_block)->data_, 0, BlockSize);
+		return write_ref(*this, *cached_block);
+	}
+
+	block_ptr b(new block(io_, location, BT_NORMAL, v, true));
+	cache_.insert(b);
+	return write_ref(*this, b);
+}
+
+template <uint32_t BlockSize>
+typename block_manager<BlockSize>::write_ref
+block_manager<BlockSize>::superblock(block_address location,
+				     typename block_manager<BlockSize>::validator::ptr v)
+{
+	check(location);
+
+	boost::optional<block_ptr> cached_block = cache_.get(location);
+
+	if (cached_block) {
+		(*cached_block)->check_write_lockable();
+		(*cached_block)->bt_ = BT_SUPERBLOCK;
+		return write_ref(*this, *cached_block);
+	}
+
+	block_ptr b(new block(io_, location, BT_SUPERBLOCK, v));
+	cache_.insert(b);
+	return write_ref(*this, b);
+}
+
+template <uint32_t BlockSize>
+typename block_manager<BlockSize>::write_ref
+block_manager<BlockSize>::superblock_zero(block_address location,
+					  typename block_manager<BlockSize>::validator::ptr v)
+{
+	check(location);
+
+	boost::optional<block_ptr> cached_block = cache_.get(location);
+
+	if (cached_block) {
+		(*cached_block)->check_write_lockable();
+		memset(&(*cached_block)->data_, 0, BlockSize);
+		return write_ref(*this, *cached_block);
+	}
+
+	block_ptr b(new block(io_, location, BT_SUPERBLOCK, v, true));
+	cache_.insert(b);
+	return write_ref(*this, b);
 }
 
 template <uint32_t BlockSize>
 void
 block_manager<BlockSize>::check(block_address b) const
 {
-	if (b >= nr_blocks_)
+	if (b >= io_->get_nr_blocks())
 		throw std::runtime_error("block address out of bounds");
 }
 
@@ -249,42 +317,22 @@ template <uint32_t BlockSize>
 block_address
 block_manager<BlockSize>::get_nr_blocks() const
 {
-	return nr_blocks_;
+	return io_->get_nr_blocks();
-}
-
-// FIXME: how do we unregister if block construction throws?
-template <uint32_t BlockSize>
-void
-block_manager<BlockSize>::register_lock(block_address b, lock_type t) const
-{
-	typename held_map::iterator it = held_locks_.find(b);
-	if (it == held_locks_.end())
-		held_locks_.insert(make_pair(b, make_pair(t, 1)));
-	else {
-		if (it->second.first != t)
-			throw std::runtime_error("lock type mismatch when locking");
-
-		if (it->second.first == WRITE_LOCK)
-			throw std::runtime_error("cannot hold concurrent write locks");
-
-		it->second.second++;
-	}
 }
 
 template <uint32_t BlockSize>
 void
-block_manager<BlockSize>::unregister_lock(block_address b, lock_type t) const
+block_manager<BlockSize>::write_block(block_ptr b) const
 {
-	typename held_map::iterator it = held_locks_.find(b);
+	b->flush();
-	if (it == held_locks_.end())
+}
-		throw std::runtime_error("lock not held");
 
-	if (it->second.first != t)
+template <uint32_t BlockSize>
-		throw std::runtime_error("lock type mismatch when unlocking");
+void
-
+block_manager<BlockSize>::flush() const
-	it->second.second--;
+{
-	if (it->second.second == 0)
+	cache_.iterate_unheld(
-		held_locks_.erase(it);
+		boost::bind(&block_manager<BlockSize>::write_block, this, _1));
 }
 
 //----------------------------------------------------------------

cache.h

@@ -37,6 +37,9 @@ namespace base {
 		boost::optional<value_type> get(key_type const &k);
 		void put(value_type const &k);
 
+		template <typename T>
+		void iterate_unheld(T fn) const;
+
 	private:
 		void make_space();
 
@@ -45,11 +48,11 @@ namespace base {
 			// default constructor also, which is a shame.
 			// so we can construct the headers.
 			value_entry()
-				: ref_count_(0) {
+				: ref_count_(1) {
 			}
 
 			explicit value_entry(value_type v)
-				: ref_count_(0),
+				: ref_count_(1),
 				  v_(v) {
 			}
 
@@ -186,18 +189,12 @@ namespace base {
 	cache<ValueTraits>::insert(value_type const &v) {
 		make_space();
 
+		// FIXME: use an auto_ptr to avoid the explicit try/catch
 		value_entry *node = new value_entry(v);
 		try {
-			lru_algo::link_after(&lru_header_, node);
+			value_ptr_cmp cmp;
-			try {
+			lookup_algo::insert_equal(&lookup_header_, &lookup_header_, node, cmp);
-				value_ptr_cmp cmp;
+			current_entries_++;
-				lookup_algo::insert_equal(&lookup_header_, &lookup_header_, node, cmp);
-				current_entries_++;
-
-			} catch (...) {
-				lru_algo::unlink(node);
-				throw;
-			}
 
 		} catch (...) {
 			delete node;
@@ -228,6 +225,9 @@ namespace base {
 		if (node == &lookup_header_)
 			throw std::runtime_error("invalid put");
 
+		if (node->ref_count_ == 0)
+			throw std::runtime_error("invalid put");
+
 		if (!--node->ref_count_)
 			lru_algo::link_after(&lru_header_, node);
 	}
@@ -246,6 +246,17 @@ namespace base {
 			current_entries_--;
 		}
 	}
+
+	template <typename ValueTraits>
+	template <typename T>
+	void
+	cache<ValueTraits>::iterate_unheld(T fn) const {
+		value_entry *n = lru_header_.lru_.next_;
+		while (n != &lru_header_) {
+			fn(n->v_);
+			n = n->lru_.next_;
+		}
+	}
 }
 
 //----------------------------------------------------------------

metadata.cc

@@ -64,7 +64,7 @@ namespace {
 	transaction_manager::ptr
 	open_tm(string const &dev_path) {
 		block_address nr_blocks = get_nr_blocks(dev_path);
-		block_manager<>::ptr bm(new block_manager<>(dev_path, nr_blocks));
+		block_manager<>::ptr bm(new block_manager<>(dev_path, nr_blocks, 8));
 		space_map::ptr sm(new core_map(nr_blocks));
 		transaction_manager::ptr tm(new transaction_manager(bm, sm));
 		return tm;

unit-tests/block_t.cc

@@ -8,49 +8,54 @@ using namespace std;
 //----------------------------------------------------------------
 
 namespace {
+	unsigned const MAX_HELD_LOCKS = 16;
+
 	block_manager<4096>::ptr create_bm(block_address nr = 1024) {
-		return block_manager<4096>::ptr(new block_manager<4096>("./test.data", nr));
+		return block_manager<4096>::ptr(new block_manager<4096>("./test.data", nr, MAX_HELD_LOCKS, true));
 	}
 
 	template <uint32_t BlockSize>
 	void check_all_bytes(typename block_manager<BlockSize>::read_ref const &rr, int v) {
-		auto data = rr.data();
+		typename block_manager<BlockSize>::const_buffer &data = rr.data();
 		for (unsigned b = 0; b < BlockSize; b++)
 			BOOST_CHECK_EQUAL(data[b], v);
 	}
 
 	template <uint32_t BlockSize>
 	class zero_validator : public block_manager<BlockSize>::validator {
-		void check(block_manager<4096>::block const &blk) const {
+		void check(block_manager<4096>::const_buffer &data, block_address location) const {
 			for (unsigned b = 0; b < BlockSize; b++)
-				if (blk.data_[b] != 0)
+				if (data[b] != 0)
  					throw runtime_error("validator check zero");
 		}
 
-		void prepare(block_manager<4096>::block &blk) const {
+		void prepare(block_manager<4096>::buffer &data, block_address location) const {
+			cerr << "zeroing" << endl;
 			for (unsigned b = 0; b < BlockSize; b++)
-				blk.data_[b] = 0;
+				data[b] = 0;
 		}
 	};
+
+	typedef block_manager<4096> bm4096;
 }
 
 //----------------------------------------------------------------
 
 BOOST_AUTO_TEST_CASE(bad_path)
 {
-	BOOST_CHECK_THROW(block_manager<4096>("/bogus/bogus/bogus", 1234), runtime_error);
+	BOOST_CHECK_THROW(bm4096("/bogus/bogus/bogus", 1234, 4), runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(out_of_range_access)
 {
-	auto bm = create_bm(1024);
+	bm4096::ptr bm = create_bm(1024);
 	BOOST_CHECK_THROW(bm->read_lock(1024), runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(read_lock_all_blocks)
 {
 	block_address const nr = 64;
-	auto bm = create_bm(nr);
+	bm4096::ptr bm = create_bm(nr);
 	for (unsigned i = 0; i < nr; i++)
 		bm->read_lock(i);
 }
@@ -58,7 +63,7 @@ BOOST_AUTO_TEST_CASE(read_lock_all_blocks)
 BOOST_AUTO_TEST_CASE(write_lock_all_blocks)
 {
 	block_address const nr = 64;
-	auto bm = create_bm(nr);
+	bm4096::ptr bm = create_bm(nr);
 	for (unsigned i = 0; i < nr; i++)
 		bm->write_lock(i);
 }
@@ -66,86 +71,87 @@ BOOST_AUTO_TEST_CASE(write_lock_all_blocks)
 BOOST_AUTO_TEST_CASE(writes_persist)
 {
 	block_address const nr = 64;
-	auto bm = create_bm(nr);
+	bm4096::ptr bm = create_bm(nr);
 	for (unsigned i = 0; i < nr; i++) {
-		auto wr = bm->write_lock(i);
+		bm4096::write_ref wr = bm->write_lock(i);
 		::memset(wr.data(), i, 4096);
 	}
 
 	for (unsigned i = 0; i < nr; i++) {
-		auto rr = bm->read_lock(i);
+		bm4096::read_ref rr = bm->read_lock(i);
 		check_all_bytes<4096>(rr, i % 256);
 	}
 }
 
 BOOST_AUTO_TEST_CASE(write_lock_zero_zeroes)
 {
-	auto bm = create_bm(64);
+	bm4096::ptr bm = create_bm(64);
 	check_all_bytes<4096>(bm->write_lock_zero(23), 0);
 }
 
 BOOST_AUTO_TEST_CASE(different_block_sizes)
 {
 	{
-		block_manager<4096> bm("./test.data", 64);
+		bm4096 bm("./test.data", 64, 1);
-		auto rr = bm.read_lock(0);
+		bm4096::read_ref rr = bm.read_lock(0);
 		BOOST_CHECK_EQUAL(sizeof(rr.data()), 4096);
 	}
 
 	{
-		block_manager<64 * 1024> bm("./test.data", 64);
+		block_manager<64 * 1024> bm("./test.data", 64, true);
-		auto rr = bm.read_lock(0);
+		block_manager<64 * 1024>::read_ref rr = bm.read_lock(0);
 		BOOST_CHECK_EQUAL(sizeof(rr.data()), 64 * 1024);
 	}
 }
 
 BOOST_AUTO_TEST_CASE(read_validator_works)
 {
-	block_manager<4096>::block_manager::validator::ptr v(new zero_validator<4096>());
+	bm4096::block_manager::validator::ptr v(new zero_validator<4096>());
-	auto bm = create_bm(64);
+	bm4096::ptr bm = create_bm(64);
 	bm->write_lock_zero(0);
 	bm->read_lock(0, v);
 }
 
 BOOST_AUTO_TEST_CASE(write_validator_works)
 {
-	auto bm = create_bm(64);
+	bm4096::ptr bm = create_bm(64);
-	block_manager<4096>::block_manager::validator::ptr v(new zero_validator<4096>());
+	bm4096::block_manager::validator::ptr v(new zero_validator<4096>());
 
 	{
-		auto wr = bm->write_lock(0, v);
+		bm4096::write_ref wr = bm->write_lock(0, v);
 		::memset(wr.data(), 23, sizeof(wr.data()));
 	}
 
+	bm->flush();		// force the prepare method to be called
 	check_all_bytes<4096>(bm->read_lock(0), 0);
 }
 
 BOOST_AUTO_TEST_CASE(cannot_have_two_superblocks)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
-	auto superblock = bm->superblock(0);
+	bm4096::write_ref superblock = bm->superblock(0);
 	BOOST_CHECK_THROW(bm->superblock(1), runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(can_have_subsequent_superblocks)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
-	{ auto superblock = bm->superblock(0); }
+	{ bm4096::write_ref superblock = bm->superblock(0); }
-	{ auto superblock = bm->superblock(0); }
+	{ bm4096::write_ref superblock = bm->superblock(0); }
 }
 
 BOOST_AUTO_TEST_CASE(superblocks_can_change_address)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
-	{ auto superblock = bm->superblock(0); }
+	{ bm4096::write_ref superblock = bm->superblock(0); }
-	{ auto superblock = bm->superblock(1); }
+	{ bm4096::write_ref superblock = bm->superblock(1); }
 }
 
 BOOST_AUTO_TEST_CASE(superblock_must_be_last)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
 	{
-		auto rr = bm->read_lock(63);
+		bm4096::read_ref rr = bm->read_lock(63);
 		{
 			BOOST_CHECK_THROW(bm->superblock(0), runtime_error);
 		}
@@ -154,42 +160,44 @@ BOOST_AUTO_TEST_CASE(superblock_must_be_last)
 
 BOOST_AUTO_TEST_CASE(references_can_be_copied)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
-	auto wr1 = bm->write_lock(0);
+	bm4096::write_ref wr1 = bm->write_lock(0);
-	auto wr2(wr1);
+	bm4096::write_ref wr2(wr1);
 }
 
+#if 0
 BOOST_AUTO_TEST_CASE(flush_throws_if_held_locks)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
-	auto wr = bm->write_lock(0);
+	bm4096::write_ref wr = bm->write_lock(0);
 	BOOST_CHECK_THROW(bm->flush(), runtime_error);
 }
+#endif
 
 BOOST_AUTO_TEST_CASE(no_concurrent_write_locks)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
-	auto wr = bm->write_lock(0);
+	bm4096::write_ref wr = bm->write_lock(0);
 	BOOST_CHECK_THROW(bm->write_lock(0), runtime_error);
 }
 
 BOOST_AUTO_TEST_CASE(concurrent_read_locks)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
-	auto rr = bm->read_lock(0);
+	bm4096::read_ref rr = bm->read_lock(0);
 	bm->read_lock(0);
 }
 
 BOOST_AUTO_TEST_CASE(read_then_write)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
 	bm->read_lock(0);
 	bm->write_lock(0);
 }
 
 BOOST_AUTO_TEST_CASE(write_then_read)
 {
-	auto bm = create_bm();
+	bm4096::ptr bm = create_bm();
 	bm->write_lock(0);
 	bm->read_lock(0);
 }

unit-tests/cache_t.cc

@@ -18,7 +18,7 @@ namespace {
 			  desc_("default constructed") {
 		}
 
-		Thing(unsigned n)
+		explicit Thing(unsigned n)
 			: key_(n),
 			  desc_("foo bar") {
 		}
@@ -58,21 +58,35 @@ BOOST_AUTO_TEST_CASE(cache_caches)
 	unsigned const COUNT = 16;
 	cache<ThingTraits> c(COUNT);
 
-	for (unsigned i = 0; i < COUNT; i++)
+	for (unsigned i = 0; i < COUNT; i++) {
 		c.insert(Thing(i));
+		c.put(Thing(i));
+	}
 
 	for (unsigned i = 0; i < COUNT; i++)
 		BOOST_ASSERT(c.get(i));
 }
 
+BOOST_AUTO_TEST_CASE(new_entries_have_a_ref_count_of_one)
+{
+	cache<ThingTraits> c(16);
+
+	c.insert(Thing(0));
+	c.put(Thing(0));
+
+	BOOST_CHECK_THROW(c.put(Thing(0)), runtime_error);
+}
+
 BOOST_AUTO_TEST_CASE(cache_drops_elements)
 {
 	unsigned const COUNT = 1024;
 	unsigned const CACHE_SIZE = 16;
 	cache<ThingTraits> c(CACHE_SIZE);
 
-	for (unsigned i = 0; i < COUNT; i++)
+	for (unsigned i = 0; i < COUNT; i++) {
 		c.insert(Thing(i));
+		c.put(Thing(i));
+	}
 
 	for (unsigned i = 0; i < COUNT - CACHE_SIZE; i++)
 		BOOST_ASSERT(!c.get(i));
@@ -87,10 +101,8 @@ BOOST_AUTO_TEST_CASE(held_entries_count_towards_the_cache_limit)
 	cache<ThingTraits> c(CACHE_SIZE);
 
 	unsigned i;
-	for (i = 0; i < CACHE_SIZE; i++) {
+	for (i = 0; i < CACHE_SIZE; i++)
 		c.insert(Thing(i));
-		c.get(i);
-	}
 
 	BOOST_CHECK_THROW(c.insert(Thing(i)), runtime_error);
 }
@@ -103,7 +115,6 @@ BOOST_AUTO_TEST_CASE(put_works)
 	unsigned i;
 	for (i = 0; i < CACHE_SIZE; i++) {
 		c.insert(Thing(i));
-		c.get(i);
 		c.put(Thing(i));
 	}