add a cache to the block manager
This commit is contained in:
Joe Thornber
parent
97f8d913e2
commit
d02fcde793
4
Makefile
4
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:
|
||||
|
||||
126
block.h
126
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)
|
||||
: 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
408
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_(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
35
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);
|
||||
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_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
@ -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));
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user