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

[block_manager] Hard code block size to 4k.

Browse Source 
We're never going to use anything other than 4k, and by hard coding it we
avoid making block_manager a template.
This commit is contained in:
Joe Thornber
2020-04-30 14:30:01 +01:00
parent 3e5de399a7
commit e801cc607b
57 changed files with 390 additions and 448 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
unit-tests/array_block_t.cc
View File

@@ -36,8 +36,8 @@ namespace {
uint64_t MAX_VALUE = 1000ull;
block_address const NR_BLOCKS = 1024;
typedef bcache::noop_validator noop_validator;
typedef block_manager<>::read_ref read_ref;
typedef block_manager<>::write_ref write_ref;
typedef block_manager::read_ref read_ref;
typedef block_manager::write_ref write_ref;
// FIXME: lift to utils?
class simple_ref_counter {
@@ -86,7 +86,7 @@ namespace {
transaction_manager::ptr
create_tm() {
block_manager<>::ptr bm = create_bm<4096>(NR_BLOCKS);
block_manager::ptr bm = create_bm(NR_BLOCKS);
space_map::ptr sm(new core_map(NR_BLOCKS));
transaction_manager::ptr tm(new transaction_manager(bm, sm));
return tm;

4
unit-tests/array_t.cc
View File

@@ -37,7 +37,7 @@ namespace {
class ArrayTests : public Test {
public:
ArrayTests()
: bm_(new block_manager<>("./test.data", NR_BLOCKS, 4, block_manager<>::READ_WRITE)),
: bm_(new block_manager("./test.data", NR_BLOCKS, 4, block_manager::READ_WRITE)),
sm_(new core_map(NR_BLOCKS)),
tm_(bm_, sm_) {
}
@@ -78,7 +78,7 @@ namespace {
array64::ptr a_;
private:
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
};

4
unit-tests/bitset_t.cc
View File

@@ -55,7 +55,7 @@ namespace {
class BitsetTests : public Test {
public:
BitsetTests()
: bm_(new block_manager<>("./test.data", NR_BLOCKS, 4, block_manager<>::READ_WRITE)),
: bm_(new block_manager("./test.data", NR_BLOCKS, 4, block_manager::READ_WRITE)),
sm_(new core_map(NR_BLOCKS)),
tm_(bm_, sm_) {
}
@@ -71,7 +71,7 @@ namespace {
}
private:
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
};

73
unit-tests/block_t.cc
View File

@@ -29,7 +29,7 @@ using namespace testing;
namespace {
template <uint32_t BlockSize>
void check_all_bytes(typename block_manager<BlockSize>::read_ref const &rr, int v) {
void check_all_bytes(typename block_manager::read_ref const &rr, int v) {
unsigned char const *data = reinterpret_cast<unsigned char const *>(rr.data());
for (unsigned b = 0; b < BlockSize; b++)
ASSERT_THAT(data[b], Eq(static_cast<unsigned char>(v)));
@@ -68,27 +68,27 @@ namespace {
MOCK_CONST_METHOD2(prepare, void(void *, block_address));
};
typedef block_manager<4096> bm4096;
typedef block_manager bm4096;
}
//----------------------------------------------------------------
TEST(BlockTests, bad_path)
{
ASSERT_THROW(bm4096("/bogus/bogus/bogus", 1234, 4, block_manager<>::READ_WRITE),
ASSERT_THROW(bm4096("/bogus/bogus/bogus", 1234, 4, block_manager::READ_WRITE),
runtime_error);
}
TEST(BlockTests, out_of_range_access)
{
bm4096::ptr bm = create_bm<4096>(1024);
bm4096::ptr bm = create_bm(1024);
ASSERT_THROW(bm->read_lock(1024), runtime_error);
}
TEST(BlockTests, read_lock_all_blocks)
{
block_address const nr = 64;
bm4096::ptr bm = create_bm<4096>(nr);
bm4096::ptr bm = create_bm(nr);
for (unsigned i = 0; i < nr; i++)
bm->read_lock(i);
}
@@ -96,7 +96,7 @@ TEST(BlockTests, read_lock_all_blocks)
TEST(BlockTests, write_lock_all_blocks)
{
block_address const nr = 64;
bm4096::ptr bm = create_bm<4096>(nr);
bm4096::ptr bm = create_bm(nr);
for (unsigned i = 0; i < nr; i++)
bm->write_lock(i);
}
@@ -104,7 +104,7 @@ TEST(BlockTests, write_lock_all_blocks)
TEST(BlockTests, writes_persist)
{
block_address const nr = 64;
bm4096::ptr bm = create_bm<4096>(nr);
bm4096::ptr bm = create_bm(nr);
for (unsigned i = 0; i < nr; i++) {
bm4096::write_ref wr = bm->write_lock(i);
::memset(wr.data(), i, 4096);
@@ -118,52 +118,21 @@ TEST(BlockTests, writes_persist)
TEST(BlockTests, write_lock_zero_zeroes)
{
bm4096::ptr bm = create_bm<4096>(64);
bm4096::ptr bm = create_bm(64);
check_all_bytes<4096>(bm->write_lock_zero(23), 0);
}
TEST(BlockTests, different_block_sizes)
{
{
bm4096::ptr bm = create_bm<4096>(64);
{
bm4096::write_ref wr = bm->write_lock(0);
memset(wr.data(), 23, 4096);
}
{
bm4096::write_ref wr = bm->write_lock_zero(0);
check_all_bytes<4096>(wr, 0);
}
}
{
block_manager<64 * 1024>::ptr bm = create_bm<64 * 1024>(64);
{
block_manager<64 * 1024>::write_ref wr = bm->write_lock(0);
memset(wr.data(), 72, 64 * 1024);
}
{
block_manager<64 * 1024>::write_ref wr = bm->write_lock_zero(0);
check_all_bytes<64 * 1024>(wr, 0);
}
}
}
TEST(BlockTests, read_validator_works)
{
bcache::validator::ptr v(new zero_validator<4096>());
bm4096::ptr bm = create_bm<4096>(64);
bm4096::ptr bm = create_bm(64);
bm->write_lock_zero(0);
bm->read_lock(0, v);
}
TEST(BlockTests, write_validator_works)
{
bm4096::ptr bm = create_bm<4096>(64);
bm4096::ptr bm = create_bm(64);
bcache::validator::ptr v(new zero_validator<4096>());
{
@@ -177,21 +146,21 @@ TEST(BlockTests, write_validator_works)
TEST(BlockTests, cannot_have_two_superblocks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::write_ref superblock = bm->superblock(0);
ASSERT_THROW(bm->superblock(1), runtime_error);
}
TEST(BlockTests, can_have_subsequent_superblocks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
{ bm4096::write_ref superblock = bm->superblock(0); }
{ bm4096::write_ref superblock = bm->superblock(0); }
}
TEST(BlockTests, superblocks_can_change_address)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
{ bm4096::write_ref superblock = bm->superblock(0); }
{ bm4096::write_ref superblock = bm->superblock(1); }
}
@@ -203,7 +172,7 @@ TEST(BlockTests, superblocks_can_change_address)
// correct thing to do is (log the error? put the tm into a 'bad' state?).
TEST(BlockTests, superblock_must_be_last)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
{
bm4096::read_ref rr = bm->read_lock(63);
{
@@ -214,21 +183,21 @@ TEST(BlockTests, superblock_must_be_last)
TEST(BlockTests, references_can_be_copied)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::write_ref wr1 = bm->write_lock(0);
bm4096::write_ref wr2(wr1);
}
TEST(BlockTests, no_concurrent_write_locks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::write_ref wr = bm->write_lock(0);
ASSERT_THROW(bm->write_lock(0), runtime_error);
}
TEST(BlockTests, concurrent_read_locks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::read_ref rr = bm->read_lock(0);
bm->read_lock(0);
}
@@ -238,7 +207,7 @@ TEST(BlockTests, concurrent_read_locks)
// think I'm ever going to add the extra checking to the C++ code.
TEST(BlockTests, no_concurrent_read_and_write_locks)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm4096::write_ref wr = bm->write_lock(0);
ASSERT_THROW(bm->read_lock(0), runtime_error);
}
@@ -246,14 +215,14 @@ TEST(BlockTests, no_concurrent_read_and_write_locks)
TEST(BlockTests, read_then_write)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm->read_lock(0);
bm->write_lock(0);
}
TEST(BlockTests, write_then_read)
{
bm4096::ptr bm = create_bm<4096>();
bm4096::ptr bm = create_bm();
bm->write_lock(0);
bm->read_lock(0);
}
@@ -264,7 +233,7 @@ namespace {
class ValidatorTests : public Test {
public:
ValidatorTests()
: bm(create_bm<4096>()),
: bm(create_bm()),
vmock(new validator_mock),
vmock2(new validator_mock) {
}

6
unit-tests/btree_counter_t.cc
View File

@@ -23,7 +23,7 @@ namespace {
class BTreeCounterTests : public Test {
public:
BTreeCounterTests()
: bm_(create_bm<BLOCK_SIZE>(NR_BLOCKS)),
: bm_(create_bm(NR_BLOCKS)),
sm_(setup_core_map()),
tm_(bm_, sm_) {
}
@@ -36,7 +36,7 @@ namespace {
}
with_temp_directory dir_;
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
uint64_traits::ref_counter rc_;
@@ -51,7 +51,7 @@ namespace {
}
void commit() {
block_manager<>::write_ref superblock(bm_->superblock(SUPERBLOCK));
block_manager::write_ref superblock(bm_->superblock(SUPERBLOCK));
}
};
}

6
unit-tests/btree_damage_visitor_t.cc
View File

@@ -256,7 +256,7 @@ namespace {
class DamageTests : public Test {
public:
DamageTests()
: bm_(create_bm<BLOCK_SIZE>(NR_BLOCKS)),
: bm_(create_bm(NR_BLOCKS)),
sm_(setup_core_map()),
tm_(bm_, sm_) {
}
@@ -290,7 +290,7 @@ namespace {
//--------------------------------
with_temp_directory dir_;
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
thing_traits::ref_counter rc_;
@@ -308,7 +308,7 @@ namespace {
}
void commit() {
block_manager<>::write_ref superblock(bm_->superblock(SUPERBLOCK));
block_manager::write_ref superblock(bm_->superblock(SUPERBLOCK));
}
virtual void discover_layout() = 0;

4
unit-tests/btree_t.cc
View File

@@ -34,7 +34,7 @@ namespace {
class BtreeTests : public Test {
public:
BtreeTests()
: bm_(new block_manager<>("./test.data", NR_BLOCKS, 4, block_manager<>::READ_WRITE)),
: bm_(new block_manager("./test.data", NR_BLOCKS, 4, block_manager::READ_WRITE)),
sm_(new core_map(NR_BLOCKS)),
tm_(bm_, sm_) {
}
@@ -48,7 +48,7 @@ namespace {
}
private:
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
};

8
unit-tests/space_map_t.cc
View File

@@ -36,7 +36,7 @@ namespace {
class SpaceMapTests : public Test {
public:
SpaceMapTests()
: bm_(new block_manager<>("./test.data", NR_BLOCKS, MAX_LOCKS, block_manager<>::READ_WRITE)),
: bm_(new block_manager("./test.data", NR_BLOCKS, MAX_LOCKS, block_manager::READ_WRITE)),
sm_(new core_map(NR_BLOCKS)),
tm_(bm_, sm_) {
}
@@ -240,7 +240,7 @@ namespace {
}
}
block_manager<>::ptr bm_;
block_manager::ptr bm_;
space_map::ptr sm_;
transaction_manager tm_;
};
@@ -277,8 +277,8 @@ TEST_F(SpaceMapTests, test_sm_metadata)
TEST_F(SpaceMapTests, test_metadata_and_disk)
{
block_manager<>::ptr bm(
new block_manager<>("./test.data", NR_BLOCKS, MAX_LOCKS, block_manager<>::READ_WRITE));
block_manager::ptr bm(
new block_manager("./test.data", NR_BLOCKS, MAX_LOCKS, block_manager::READ_WRITE));
space_map::ptr core_sm(new core_map(NR_BLOCKS));
transaction_manager::ptr tm(new transaction_manager(bm, core_sm));
persistent_space_map::ptr metadata_sm = persistent_data::create_metadata_sm(*tm, NR_BLOCKS);

6
unit-tests/test_utils.cc
View File

@@ -12,14 +12,14 @@ using namespace test;
//----------------------------------------------------------------
void test::zero_block(block_manager<>::ptr bm, block_address b)
void test::zero_block(block_manager::ptr bm, block_address b)
{
block_manager<>::write_ref wr = bm->write_lock(b);
block_manager::write_ref wr = bm->write_lock(b);
memset(wr.data(), 0, 4096);
}
transaction_manager::ptr
test::open_temporary_tm(block_manager<>::ptr bm)
test::open_temporary_tm(block_manager::ptr bm)
{
space_map::ptr sm(new core_map(bm->get_nr_blocks()));
transaction_manager::ptr tm(new transaction_manager(bm, sm));

13
unit-tests/test_utils.h
View File

@@ -28,23 +28,22 @@ namespace test {
unsigned const MAX_HELD_LOCKS = 16;
template <uint32_t BlockSize>
typename block_manager<BlockSize>::ptr
inline block_manager::ptr
create_bm(block_address nr = 1024) {
std::string const path("./test.data");
int r = system("rm -f ./test.data");
if (r < 0)
throw std::runtime_error("couldn't rm -f ./test.data");
return typename block_manager<BlockSize>::ptr(
new block_manager<BlockSize>(path, nr, MAX_HELD_LOCKS,
block_manager<BlockSize>::CREATE));
return typename block_manager::ptr(
new block_manager(path, nr, MAX_HELD_LOCKS,
block_manager::CREATE));
}
// Don't use this to update the metadata.
transaction_manager::ptr open_temporary_tm(block_manager<>::ptr bm);
transaction_manager::ptr open_temporary_tm(block_manager::ptr bm);
void zero_block(block_manager<>::ptr bm, block_address b);
void zero_block(block_manager::ptr bm, block_address b);
//--------------------------------

8
unit-tests/transaction_manager_t.cc
View File

@@ -32,8 +32,8 @@ namespace {
transaction_manager::ptr
create_tm() {
block_manager<>::ptr bm(
new block_manager<>("./test.data", NR_BLOCKS, MAX_HELD_LOCKS, block_manager<>::READ_WRITE));
block_manager::ptr bm(
new block_manager("./test.data", NR_BLOCKS, MAX_HELD_LOCKS, block_manager::READ_WRITE));
space_map::ptr sm(new core_map(NR_BLOCKS));
transaction_manager::ptr tm(new transaction_manager(bm, sm));
tm->get_sm()->inc(0);
@@ -47,7 +47,7 @@ namespace {
new bcache::noop_validator);
}
typedef block_manager<>::write_ref write_ref;
typedef block_manager::write_ref write_ref;
}
//----------------------------------------------------------------
@@ -61,7 +61,7 @@ TEST(TransactionManagerTests, commit_succeeds)
TEST(TransactionManagerTests, shadowing)
{
transaction_manager::ptr tm = create_tm();
block_manager<>::write_ref superblock = tm->begin(0, mk_noop_validator());
block_manager::write_ref superblock = tm->begin(0, mk_noop_validator());
space_map::ptr sm = tm->get_sm();
sm->inc(1);