add a cache to the block manager

This commit is contained in:
Joe Thornber 2011-10-24 18:04:19 +01:00
parent 97f8d913e2
commit d02fcde793
7 changed files with 396 additions and 300 deletions

View File

@ -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:

126
block.h
View File

@ -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)
: c_(c) {
c_++;
typedef boost::shared_ptr<block_io> 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 <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();
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<validator> 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<block> ptr;
block(block_address location,
const_buffer &data,
unsigned &count,
unsigned &type_count,
block(typename block_io<BlockSize>::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<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);
virtual ~read_ref() {}
read_ref(block_manager<BlockSize> 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<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 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<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_;

408
block.tcc
View File

@ -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_(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)
block_io<BlockSize>::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<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>::zero_buffer(block_manager<BlockSize>::buffer &buffer) const
block_manager<BlockSize>::block::block(typename block_io<BlockSize>::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 <uint32_t BlockSize>
void
block_manager<BlockSize>::read_release(block *b) const
block_manager<BlockSize>::block::~block()
{
unregister_lock(b->location_, READ_LOCK);
delete b;
flush();
}
template <uint32_t BlockSize>
void
block_manager<BlockSize>::write_release(block *b)
block_manager<BlockSize>::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 <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_);
unregister_lock(b->location_, WRITE_LOCK);
delete b;
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);
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_;
}
// 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++;
}
return io_->get_nr_blocks();
}
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);
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 <uint32_t BlockSize>
void
block_manager<BlockSize>::flush() const
{
cache_.iterate_unheld(
boost::bind(&block_manager<BlockSize>::write_block, this, _1));
}
//----------------------------------------------------------------

35
cache.h
View File

@ -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);
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 <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_;
}
}
}
//----------------------------------------------------------------

View File

@ -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;

View File

@ -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);
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);
}

View File

@ -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));
}