diff --git a/Makefile b/Makefile index b1a6229..250f8e1 100644 --- a/Makefile +++ b/Makefile @@ -28,8 +28,8 @@ test-programs: $(TEST_PROGRAMS) .SUFFIXES: .cc .o .d %.d: %.cc - g++ -MM $(CPPFLAGS) $< > $@.$$$$; \ - sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \ + g++ -MM -MT $(subst .cc,.o,$<) $(CPPFLAGS) $< > $@.$$$$; \ + sed 's,\([^ :]*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \ rm -f $@.$$$$ .cc.o: diff --git a/block.h b/block.h index d91e6ec..e7d3144 100644 --- a/block.h +++ b/block.h @@ -1,6 +1,8 @@ #ifndef BLOCK_H #define BLOCK_H +#include "cache.h" + #include #include #include @@ -17,50 +19,58 @@ namespace persistent_data { uint32_t const MD_BLOCK_SIZE = 4096; - class count_adjuster { + typedef uint64_t block_address; + + template + class block_io : private boost::noncopyable { public: - count_adjuster(unsigned &c) - : c_(c) { - c_++; + typedef boost::shared_ptr ptr; + typedef unsigned char buffer[BlockSize]; + 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() { - c_--; - } + void read_buffer(block_address location, buffer &buf) const; + 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 class block_manager : private boost::noncopyable { public: typedef boost::shared_ptr ptr; - block_manager(std::string const &path, block_address nr_blocks, bool writeable = false); - ~block_manager(); + block_manager(std::string const &path, + 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 ptr; virtual ~validator() {} - virtual void check(block const &b) const = 0; - virtual void prepare(block &b) const = 0; + virtual void check(const_buffer &b, block_address location) 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 prepare(block &b) const {} + void check(const_buffer &b, block_address location) 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 ptr; - block(block_address location, - const_buffer &data, - unsigned &count, - unsigned &type_count, + block(typename block_io::ptr io, + block_address location, block_type bt, - typename validator::ptr v) - : location_(location), - adjuster_(count), - type_adjuster_(type_count), - validator_(v), - bt_(bt) { - ::memcpy(data_, data, sizeof(data)); + typename validator::ptr v, + bool zero = false); + ~block(); + + void check_read_lockable() const { + // FIXME: finish } + void check_write_lockable() const { + // FIXME: finish + } + + void flush(); + + typename block_io::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); - virtual ~read_ref() {} + read_ref(block_manager const &bm, + 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; - typename block::ptr block_; + friend class block_manager; // FIXME: still needed? + block_manager 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 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_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 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); + void write_block(block_ptr b) const; enum lock_type { READ_LOCK, WRITE_LOCK }; - void register_lock(block_address b, lock_type t) const; - void unregister_lock(block_address b, lock_type t) const; + struct cache_traits { + typedef typename block::ptr value_type; + typedef block_address key_type; - int fd_; - block_address nr_blocks_; - mutable unsigned lock_count_; - mutable unsigned superblock_count_; - mutable unsigned ordinary_count_; + static key_type get_key(value_type const &v) { + return v->location_; + } + }; + + typename block_io::ptr io_; + mutable base::cache cache_; + + // FIXME: we need a dirty list as well as a cache typedef std::map > held_map; mutable held_map held_locks_; diff --git a/block.tcc b/block.tcc index 4c53724..260398b 100644 --- a/block.tcc +++ b/block.tcc @@ -16,46 +16,9 @@ using namespace std; //---------------------------------------------------------------- template -block_manager::read_ref::read_ref(typename block_manager::block::ptr b) - : block_(b) -{ -} - -template -block_address -block_manager::read_ref::get_location() const -{ - return block_->location_; -} - -template -typename block_manager::const_buffer & -block_manager::read_ref::data() const -{ - return block_->data_; -} - -template -block_manager::write_ref::write_ref(typename block_manager::block::ptr b) - : read_ref(b) -{ -} - -template -typename block_manager::buffer & -block_manager::write_ref::data() -{ - return read_ref::block_->data_; -} - -//---------------------------------------------------------------- - -template -block_manager::block_manager(std::string const &path, block_address nr_blocks, bool writeable) +block_io::block_io(std::string const &path, block_address nr_blocks, bool writeable) : nr_blocks_(nr_blocks), - lock_count_(0), - superblock_count_(0), - ordinary_count_(0) + writeable_(writeable) { fd_ = ::open(path.c_str(), writeable ? (O_RDWR | O_CREAT) : O_RDONLY, 0666); if (fd_ < 0) @@ -63,106 +26,17 @@ block_manager::block_manager(std::string const &path, block_address n } template -block_manager::~block_manager() +block_io::~block_io() { ::close(fd_); } -template -typename block_manager::read_ref -block_manager::read_lock(block_address location, - typename block_manager::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 -optional::read_ref> -block_manager::read_try_lock(block_address location, - typename block_manager::validator::ptr v) const -{ - return read_lock(location, v); -} - -template -typename block_manager::write_ref -block_manager::write_lock(block_address location, - typename block_manager::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 -typename block_manager::write_ref -block_manager::write_lock_zero(block_address location, - typename block_manager::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 -typename block_manager::write_ref -block_manager::superblock(block_address location, - typename block_manager::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 -typename block_manager::write_ref -block_manager::superblock_zero(block_address location, - typename block_manager::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 void -block_manager::read_buffer(block_address b, block_manager::buffer &buffer) const +block_io::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::read_buffer(block_address b, block_manager: template void -block_manager::write_buffer(block_address b, block_manager::const_buffer &buffer) +block_io::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::write_buffer(block_address b, block_manager throw std::runtime_error("write failed"); } +//---------------------------------------------------------------- + template -void -block_manager::zero_buffer(block_manager::buffer &buffer) const +block_manager::block::block(typename block_io::ptr io, + 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 -void -block_manager::read_release(block *b) const +block_manager::block::~block() { - unregister_lock(b->location_, READ_LOCK); - delete b; + flush(); } template void -block_manager::write_release(block *b) +block_manager::block::flush() { - if (b->bt_ == BT_SUPERBLOCK) { - if (lock_count_ != 1) - throw runtime_error("superblock isn't the last block"); + if (dirty_) { + validator_->prepare(data_, location_); + io_->write_buffer(location_, data_); + } +} + +//---------------------------------------------------------------- + +template +block_manager::read_ref::read_ref(block_manager const &bm, + block_ptr b) + : bm_(bm), + block_(b), + holders_(new unsigned) +{ + *holders_ = 1; +} + +template +block_manager::read_ref::read_ref(read_ref const &rhs) + : bm_(rhs.bm_), + block_(rhs.block_), + holders_(rhs.holders_) +{ + (*holders_)++; +} + +template +block_manager::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 +typename block_manager::read_ref const & +block_manager::read_ref::operator =(read_ref const &rhs) +{ + if (this != &rhs) { + block_ = rhs.block_; + bm_ = rhs.bm_; + holders_ = rhs.holders_; + (*holders_)++; + } +} + +template +block_address +block_manager::read_ref::get_location() const +{ + return block_->location_; +} + +template +typename block_manager::const_buffer & +block_manager::read_ref::data() const +{ + return block_->data_; +} + +//-------------------------------- + +template +block_manager::write_ref::write_ref(block_manager const &bm, + block_ptr b) + : read_ref(bm, b) +{ + b->dirty_ = true; +} + +template +typename block_manager::buffer & +block_manager::write_ref::data() +{ + return read_ref::block_->data_; +} + +//---------------------------------------------------------------- + +template +block_manager::block_manager(std::string const &path, + block_address nr_blocks, + unsigned max_concurrent_blocks, + bool writeable) + : io_(new block_io(path, nr_blocks, writeable)), + cache_(max(64u, max_concurrent_blocks)) +{ +} + +template +typename block_manager::read_ref +block_manager::read_lock(block_address location, + typename block_manager::validator::ptr v) const +{ + check(location); + boost::optional 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_); - unregister_lock(b->location_, WRITE_LOCK); - delete b; +template +typename block_manager::write_ref +block_manager::write_lock(block_address location, + typename block_manager::validator::ptr v) +{ + check(location); + + boost::optional 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 +typename block_manager::write_ref +block_manager::write_lock_zero(block_address location, + typename block_manager::validator::ptr v) +{ + check(location); + + boost::optional 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 +typename block_manager::write_ref +block_manager::superblock(block_address location, + typename block_manager::validator::ptr v) +{ + check(location); + + boost::optional 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 +typename block_manager::write_ref +block_manager::superblock_zero(block_address location, + typename block_manager::validator::ptr v) +{ + check(location); + + boost::optional 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 void block_manager::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 block_address block_manager::get_nr_blocks() const { - return nr_blocks_; -} - -// FIXME: how do we unregister if block construction throws? -template -void -block_manager::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++; - } + return io_->get_nr_blocks(); } template void -block_manager::unregister_lock(block_address b, lock_type t) const +block_manager::write_block(block_ptr b) const { - typename held_map::iterator it = held_locks_.find(b); - if (it == held_locks_.end()) - throw std::runtime_error("lock not held"); + b->flush(); +} - if (it->second.first != t) - throw std::runtime_error("lock type mismatch when unlocking"); - - it->second.second--; - if (it->second.second == 0) - held_locks_.erase(it); +template +void +block_manager::flush() const +{ + cache_.iterate_unheld( + boost::bind(&block_manager::write_block, this, _1)); } //---------------------------------------------------------------- diff --git a/cache.h b/cache.h index 12b5e6e..604d43b 100644 --- a/cache.h +++ b/cache.h @@ -37,6 +37,9 @@ namespace base { boost::optional get(key_type const &k); void put(value_type const &k); + template + 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::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); - try { - value_ptr_cmp cmp; - lookup_algo::insert_equal(&lookup_header_, &lookup_header_, node, cmp); - current_entries_++; - - } catch (...) { - lru_algo::unlink(node); - throw; - } + value_ptr_cmp cmp; + lookup_algo::insert_equal(&lookup_header_, &lookup_header_, node, cmp); + current_entries_++; } 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 + template + void + cache::iterate_unheld(T fn) const { + value_entry *n = lru_header_.lru_.next_; + while (n != &lru_header_) { + fn(n->v_); + n = n->lru_.next_; + } + } } //---------------------------------------------------------------- diff --git a/metadata.cc b/metadata.cc index 41443ab..851d81d 100644 --- a/metadata.cc +++ b/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; diff --git a/unit-tests/block_t.cc b/unit-tests/block_t.cc index b00e617..97ced05 100644 --- a/unit-tests/block_t.cc +++ b/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 void check_all_bytes(typename block_manager::read_ref const &rr, int v) { - auto data = rr.data(); + typename block_manager::const_buffer &data = rr.data(); for (unsigned b = 0; b < BlockSize; b++) BOOST_CHECK_EQUAL(data[b], v); } template class zero_validator : public block_manager::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); - auto rr = bm.read_lock(0); + bm4096 bm("./test.data", 64, 1); + bm4096::read_ref rr = bm.read_lock(0); BOOST_CHECK_EQUAL(sizeof(rr.data()), 4096); } { - block_manager<64 * 1024> bm("./test.data", 64); - auto rr = bm.read_lock(0); + block_manager<64 * 1024> bm("./test.data", 64, true); + 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>()); - auto bm = create_bm(64); + bm4096::block_manager::validator::ptr v(new zero_validator<4096>()); + 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); - block_manager<4096>::block_manager::validator::ptr v(new zero_validator<4096>()); + bm4096::ptr bm = create_bm(64); + 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(); - auto superblock = bm->superblock(0); + bm4096::ptr bm = create_bm(); + 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(); - { auto superblock = bm->superblock(0); } - { auto superblock = bm->superblock(0); } + bm4096::ptr bm = create_bm(); + { bm4096::write_ref superblock = bm->superblock(0); } + { bm4096::write_ref superblock = bm->superblock(0); } } BOOST_AUTO_TEST_CASE(superblocks_can_change_address) { - auto bm = create_bm(); - { auto superblock = bm->superblock(0); } - { auto superblock = bm->superblock(1); } + bm4096::ptr bm = create_bm(); + { bm4096::write_ref superblock = bm->superblock(0); } + { 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(); - auto wr1 = bm->write_lock(0); - auto wr2(wr1); + bm4096::ptr bm = create_bm(); + bm4096::write_ref wr1 = bm->write_lock(0); + bm4096::write_ref wr2(wr1); } +#if 0 BOOST_AUTO_TEST_CASE(flush_throws_if_held_locks) { - auto bm = create_bm(); - auto wr = bm->write_lock(0); + bm4096::ptr bm = create_bm(); + 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(); - auto wr = bm->write_lock(0); + bm4096::ptr bm = create_bm(); + 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(); - auto rr = bm->read_lock(0); + bm4096::ptr bm = create_bm(); + 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); } diff --git a/unit-tests/cache_t.cc b/unit-tests/cache_t.cc index e42bf1d..c96cbc4 100644 --- a/unit-tests/cache_t.cc +++ b/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 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 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 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 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)); }