emo/thin-provisioning-tools
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add a cache to the block manager

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

96
unit-tests/block_t.cc
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);
}

25
unit-tests/cache_t.cc
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));
}