diff --git a/persistent-data/data-structures/btree_damage_visitor.h b/persistent-data/data-structures/btree_damage_visitor.h index 7e4a335..ae57ee2 100644 --- a/persistent-data/data-structures/btree_damage_visitor.h +++ b/persistent-data/data-structures/btree_damage_visitor.h @@ -11,13 +11,13 @@ namespace persistent_data { struct damage { typedef boost::shared_ptr ptr; - damage(range lost_keys, + damage(run lost_keys, std::string const &desc) : lost_keys_(lost_keys), desc_(desc) { } - range lost_keys_; + run lost_keys_; std::string desc_; }; @@ -36,18 +36,18 @@ namespace persistent_data { damage_begin_(0) { } - typedef range range64; - typedef boost::optional maybe_range64; + typedef run run64; + typedef boost::optional maybe_run64; void bad_node() { damaged_ = true; } - maybe_range64 good_internal(block_address begin) { - maybe_range64 r; + maybe_run64 good_internal(block_address begin) { + maybe_run64 r; if (damaged_) { - r = maybe_range64(range64(damage_begin_, begin)); + r = maybe_run64(run64(damage_begin_, begin)); damaged_ = false; } @@ -57,11 +57,11 @@ namespace persistent_data { // remember 'end' is the one-past-the-end value, so // take the last key in the leaf and add one. - maybe_range64 good_leaf(block_address begin, block_address end) { - maybe_range64 r; + maybe_run64 good_leaf(block_address begin, block_address end) { + maybe_run64 r; if (damaged_) { - r = maybe_range64(range64(damage_begin_, begin)); + r = maybe_run64(run64(damage_begin_, begin)); damaged_ = false; } @@ -69,11 +69,11 @@ namespace persistent_data { return r; } - maybe_range64 end() { + maybe_run64 end() { if (damaged_) - return maybe_range64(damage_begin_); + return maybe_run64(damage_begin_); else - return maybe_range64(); + return maybe_run64(); } private: @@ -133,8 +133,8 @@ namespace persistent_data { class btree_damage_visitor : public btree::visitor { public: typedef btree_detail::node_location node_location; - typedef range range64; - typedef boost::optional maybe_range64; + typedef run run64; + typedef boost::optional maybe_run64; btree_damage_visitor(block_counter &counter, ValueVisitor &value_visitor, @@ -389,13 +389,13 @@ namespace persistent_data { } void good_internal(block_address b) { - maybe_range64 mr = dt_.good_internal(b); + maybe_run64 mr = dt_.good_internal(b); if (mr) issue_damage(path_tracker_.current_path(), *mr); } void good_leaf(block_address b, block_address e) { - maybe_range64 mr = dt_.good_leaf(b, e); + maybe_run64 mr = dt_.good_leaf(b, e); if (mr) issue_damage(path_tracker_.current_path(), *mr); @@ -405,7 +405,7 @@ namespace persistent_data { maybe_issue_damage(path_tracker_.current_path()); } - void issue_damage(btree_path const &path, range64 const &r) { + void issue_damage(btree_path const &path, run64 const &r) { damage d(r, build_damage_desc()); clear_damage_desc(); damage_visitor_.visit(path, d); @@ -426,7 +426,7 @@ namespace persistent_data { } void maybe_issue_damage(btree_path const &path) { - maybe_range64 mr = dt_.end(); + maybe_run64 mr = dt_.end(); if (mr) issue_damage(path, *mr); } diff --git a/persistent-data/run.h b/persistent-data/run.h index a5694e2..5b4ed69 100644 --- a/persistent-data/run.h +++ b/persistent-data/run.h @@ -8,16 +8,16 @@ namespace base { template - class range { + class run { public: typedef boost::optional maybe; - explicit range(maybe begin = maybe(), maybe end = maybe()) + explicit run(maybe begin = maybe(), maybe end = maybe()) : begin_(begin), end_(end) { } - bool operator ==(range const &r) const { + bool operator ==(run const &r) const { return (begin_ == r.begin_ && end_ == r.end_); } @@ -37,7 +37,7 @@ namespace base { template std::ostream & - operator <<(std::ostream &out, range const &r) { + operator <<(std::ostream &out, run const &r) { if (r.begin_) out << "[" << *r.begin_; else diff --git a/thin-provisioning/device_tree.cc b/thin-provisioning/device_tree.cc index fa32969..140536c 100644 --- a/thin-provisioning/device_tree.cc +++ b/thin-provisioning/device_tree.cc @@ -53,7 +53,7 @@ namespace thin_provisioning { } missing_devices::missing_devices(std::string const &desc, - range const &keys) + run const &keys) : desc_(desc), keys_(keys) { } diff --git a/thin-provisioning/device_tree.h b/thin-provisioning/device_tree.h index 8962899..e270b71 100644 --- a/thin-provisioning/device_tree.h +++ b/thin-provisioning/device_tree.h @@ -39,11 +39,11 @@ namespace thin_provisioning { }; struct missing_devices : public damage { - missing_devices(std::string const &desc, range const &keys); + missing_devices(std::string const &desc, run const &keys); virtual void visit(damage_visitor &v) const; std::string desc_; - range keys_; + run keys_; }; class damage_visitor { diff --git a/thin-provisioning/mapping_tree.cc b/thin-provisioning/mapping_tree.cc index d69f30a..9d06278 100644 --- a/thin-provisioning/mapping_tree.cc +++ b/thin-provisioning/mapping_tree.cc @@ -95,7 +95,7 @@ namespace thin_provisioning { //-------------------------------- - missing_devices::missing_devices(std::string const &desc, range const &keys) + missing_devices::missing_devices(std::string const &desc, run const &keys) : desc_(desc), keys_(keys) { @@ -110,7 +110,7 @@ namespace thin_provisioning { //-------------------------------- missing_mappings::missing_mappings(std::string const &desc, uint64_t thin_dev, - range const &keys) + run const &keys) : desc_(desc), thin_dev_(thin_dev), keys_(keys) diff --git a/thin-provisioning/mapping_tree.h b/thin-provisioning/mapping_tree.h index c07c643..361b4df 100644 --- a/thin-provisioning/mapping_tree.h +++ b/thin-provisioning/mapping_tree.h @@ -73,21 +73,21 @@ namespace thin_provisioning { }; struct missing_devices : public damage { - missing_devices(std::string const &desc, range const &keys); + missing_devices(std::string const &desc, run const &keys); virtual void visit(damage_visitor &v) const; std::string desc_; - range keys_; + run keys_; }; struct missing_mappings : public damage { missing_mappings(std::string const &desc, uint64_t thin_dev, - range const &keys); + run const &keys); virtual void visit(damage_visitor &v) const; std::string desc_; uint64_t thin_dev_; - range keys_; + run keys_; }; class damage_visitor { diff --git a/thin-provisioning/metadata_checker.h b/thin-provisioning/metadata_checker.h index 8a5d846..b2121d6 100644 --- a/thin-provisioning/metadata_checker.h +++ b/thin-provisioning/metadata_checker.h @@ -66,31 +66,31 @@ namespace thin_provisioning { bool operator ==(super_block_corruption const &rhs) const; }; - typedef base::range range64; + typedef base::run run64; struct missing_device_details : public metadata_damage { - missing_device_details(range64 missing); + missing_device_details(run64 missing); virtual void visit(metadata_damage_visitor &visitor) const; bool operator ==(missing_device_details const &rhs) const; - range64 missing_; + run64 missing_; }; struct missing_devices : public metadata_damage { - missing_devices(range64 missing); + missing_devices(run64 missing); virtual void visit(metadata_damage_visitor &visitor) const; bool operator ==(missing_devices const &rhs) const; - range64 missing_; + run64 missing_; }; struct missing_mappings : public metadata_damage { - missing_mappings(uint64_t dev, range64 missing); + missing_mappings(uint64_t dev, run64 missing); virtual void visit(metadata_damage_visitor &visitor) const; bool operator ==(missing_mappings const &rhs) const; uint64_t dev_; - range64 missing_; + run64 missing_; }; struct bad_metadata_ref_count : public metadata_damage { @@ -120,19 +120,19 @@ namespace thin_provisioning { }; struct missing_metadata_ref_counts : public metadata_damage { - missing_metadata_ref_counts(range64 missing); + missing_metadata_ref_counts(run64 missing); virtual void visit(metadata_damage_visitor &visitor) const; bool operator ==(missing_metadata_ref_counts const &rhs) const; - range64 missing_; + run64 missing_; }; struct missing_data_ref_counts : public metadata_damage { - missing_data_ref_counts(range64 missing); + missing_data_ref_counts(run64 missing); virtual void visit(metadata_damage_visitor &visitor) const; bool operator ==(missing_data_ref_counts const &rhs) const; - range64 missing_; + run64 missing_; }; class metadata_damage_visitor { diff --git a/thin-provisioning/rmap_visitor.h b/thin-provisioning/rmap_visitor.h index 8341b7e..98fb9fc 100644 --- a/thin-provisioning/rmap_visitor.h +++ b/thin-provisioning/rmap_visitor.h @@ -16,7 +16,7 @@ namespace thin_provisioning { // iv) get the rmaps with get_rmap(); class rmap_visitor { public: - typedef range region; + typedef run region; rmap_visitor(); diff --git a/thin-provisioning/thin_rmap.cc b/thin-provisioning/thin_rmap.cc index 30e198d..ee24314 100644 --- a/thin-provisioning/thin_rmap.cc +++ b/thin-provisioning/thin_rmap.cc @@ -7,7 +7,7 @@ #include "version.h" #include "persistent-data/data-structures/btree_damage_visitor.h" -#include "persistent-data/range.h" +#include "persistent-data/run.h" #include "persistent-data/space-maps/core.h" #include "thin-provisioning/file_utils.h" #include "thin-provisioning/superblock.h" diff --git a/unit-tests/btree_damage_visitor_t.cc b/unit-tests/btree_damage_visitor_t.cc index 6afb42a..3b6c2f0 100644 --- a/unit-tests/btree_damage_visitor_t.cc +++ b/unit-tests/btree_damage_visitor_t.cc @@ -6,7 +6,9 @@ #include "persistent-data/endian_utils.h" #include "persistent-data/space-maps/core.h" #include "persistent-data/transaction_manager.h" +#include "persistent-data/run.h" +using namespace base; using namespace std; using namespace persistent_data; using namespace test; @@ -71,7 +73,7 @@ namespace { bool leaf; unsigned depth; block_address b; - range keys; + run keys; }; ostream &operator <<(ostream &out, node_info const &ni) { @@ -227,12 +229,12 @@ namespace { ni->b = n.get_location(); if (n.get_nr_entries()) - ni->keys = range(n.key_at(0)); + ni->keys = run(n.key_at(0)); else { if (loc.key) - ni->keys = range(*loc.key); + ni->keys = run(*loc.key); else - ni->keys = range(); + ni->keys = run(); } if (last_node_at_depth_.size() > loc.depth) { @@ -349,7 +351,7 @@ namespace { } } - void expect_value_range(uint64_t begin, uint64_t end) { + void expect_value_run(uint64_t begin, uint64_t end) { while (begin < end) { btree_path path; path.push_back(begin); @@ -359,7 +361,7 @@ namespace { } void expect_nr_values(unsigned nr) { - expect_value_range(0, nr); + expect_value_run(0, nr); } void expect_value(uint64_t n) { @@ -368,7 +370,7 @@ namespace { EXPECT_CALL(value_visitor_, visit(Eq(path), Eq(thing(n, n + 1234)))).Times(1); } - void expect_damage(range keys) { + void expect_damage(base::run const &keys) { EXPECT_CALL(damage_visitor_, visit(EmptyPath(), DamagedKeys(keys))).Times(1); } @@ -426,13 +428,13 @@ namespace { } void expect_values_except(unsigned nr_sub_trees, unsigned nr_values, - btree_path const &path, range keys) { + btree_path const &path, base::run keys) { for (unsigned i = 0; i < nr_sub_trees; i++) expect_sub_tree_values_except(i, nr_values, path, keys); } void expect_sub_tree_values_except(unsigned sub_tree, unsigned nr_values, - btree_path const &path, range keys) { + btree_path const &path, base::run keys) { for (unsigned i = 0; i < nr_values; i++) { uint64_t key[2] = {sub_tree, i}; @@ -446,7 +448,7 @@ namespace { } } - void expect_damage(btree_path path, range keys) { + void expect_damage(btree_path path, base::run keys) { EXPECT_CALL(damage_visitor_, visit(Eq(path), DamagedKeys(keys))).Times(1); } @@ -485,7 +487,7 @@ TEST_F(BTreeDamageVisitorTests, tree_with_a_trashed_root) trash_block(tree_->get_root()); expect_no_values(); - expect_damage(range(0ull)); + expect_damage(base::run(0ull)); run(); } @@ -508,8 +510,8 @@ TEST_F(BTreeDamageVisitorTests, populated_tree_with_a_damaged_leaf_node) node_info n = layout_->random_node(is_leaf); trash_block(n.b); - expect_value_range(0, *n.keys.begin_); - expect_value_range(*n.keys.end_, 10000); + expect_value_run(0, *n.keys.begin_); + expect_value_run(*n.keys.end_, 10000); expect_damage(n.keys); run(); @@ -529,9 +531,9 @@ TEST_F(BTreeDamageVisitorTests, populated_tree_with_a_sequence_of_damaged_leaf_n block_address begin = *nodes[0].keys.begin_; block_address end = *nodes[COUNT - 1].keys.end_; - expect_value_range(0, *nodes[0].keys.begin_); - expect_value_range(*nodes[COUNT - 1].keys.end_, 10000); - expect_damage(range(begin, end)); + expect_value_run(0, *nodes[0].keys.begin_); + expect_value_run(*nodes[COUNT - 1].keys.end_, 10000); + expect_damage(base::run(begin, end)); run(); } @@ -546,8 +548,8 @@ TEST_F(BTreeDamageVisitorTests, damaged_first_leaf) block_address end = *n.keys.end_; trash_block(n.b); - expect_damage(range(0ull, end)); - expect_value_range(end, 10000); + expect_damage(base::run(0ull, end)); + expect_value_run(end, 10000); run(); } @@ -563,8 +565,8 @@ TEST_F(BTreeDamageVisitorTests, damaged_last_leaf) block_address begin = *n.keys.begin_; trash_block(n.b); - expect_value_range(0, begin); - expect_damage(range(begin)); + expect_value_run(0, begin); + expect_damage(base::run(begin)); run(); } @@ -581,11 +583,11 @@ TEST_F(BTreeDamageVisitorTests, damaged_internal) trash_block(n.b); - expect_value_range(0, *begin); - expect_damage(range(begin, end)); + expect_value_run(0, *begin); + expect_damage(base::run(begin, end)); if (end) - expect_value_range(*end, 10000); + expect_value_run(*end, 10000); run(); } @@ -609,7 +611,7 @@ TEST_F(BTreeDamageVisitor2Tests, tree_with_a_trashed_root) expect_no_values(); btree_path path; - expect_damage(path, range(0ull)); + expect_damage(path, base::run(0ull)); run(); } diff --git a/unit-tests/damage_tracker_t.cc b/unit-tests/damage_tracker_t.cc index a191294..a2f54a4 100644 --- a/unit-tests/damage_tracker_t.cc +++ b/unit-tests/damage_tracker_t.cc @@ -12,8 +12,8 @@ using namespace testing; //---------------------------------------------------------------- namespace { - typedef range range64; - typedef damage_tracker::maybe_range64 mr64; + typedef run run64; + typedef damage_tracker::maybe_run64 mr64; class DamageTrackerTests : public Test { public: @@ -21,7 +21,7 @@ namespace { ASSERT_THAT(mr, Eq(mr64())); } - void assert_damage(mr64 const &mr, range64 const &expected) const { + void assert_damage(mr64 const &mr, run64 const &expected) const { ASSERT_THAT(mr, Eq(mr64(expected))); } @@ -40,27 +40,27 @@ TEST_F(DamageTrackerTests, good_leaf) TEST_F(DamageTrackerTests, bad_node) { dt.bad_node(); - assert_damage(dt.end(), range64(0ull)); + assert_damage(dt.end(), run64(0ull)); } TEST_F(DamageTrackerTests, good_bad) { dt.good_leaf(0, 10); dt.bad_node(); - assert_damage(dt.end(), range64(10ull)); + assert_damage(dt.end(), run64(10ull)); } TEST_F(DamageTrackerTests, bad_good) { dt.bad_node(); - assert_damage(dt.good_leaf(10, 20), range64(0ull, 10ull)); + assert_damage(dt.good_leaf(10, 20), run64(0ull, 10ull)); } TEST_F(DamageTrackerTests, good_bad_good) { dt.good_leaf(0, 10); dt.bad_node(); - assert_damage(dt.good_leaf(20, 30), range64(10ull, 20ull)); + assert_damage(dt.good_leaf(20, 30), run64(10ull, 20ull)); assert_no_damage(dt.end()); } @@ -69,14 +69,14 @@ TEST_F(DamageTrackerTests, bad_good_bad) dt.bad_node(); dt.good_leaf(10, 20); dt.bad_node(); - assert_damage(dt.end(), range64(20ull)); + assert_damage(dt.end(), run64(20ull)); } TEST_F(DamageTrackerTests, gi_bl_gl) { dt.good_internal(0); dt.bad_node(); - assert_damage(dt.good_leaf(10, 20), range64(0ull, 10ull)); + assert_damage(dt.good_leaf(10, 20), run64(0ull, 10ull)); assert_no_damage(dt.end()); } @@ -86,16 +86,16 @@ TEST_F(DamageTrackerTests, gi_gl_bl_bi) dt.good_leaf(0, 10); dt.bad_node(); dt.bad_node(); - assert_damage(dt.end(), range64(10ull)); + assert_damage(dt.end(), run64(10ull)); } TEST_F(DamageTrackerTests, gi_bi_gi_bl_gl) { dt.good_internal(0); dt.bad_node(); - assert_damage(dt.good_internal(10), range64(0ull, 10ull)); + assert_damage(dt.good_internal(10), run64(0ull, 10ull)); dt.bad_node(); - assert_damage(dt.good_leaf(15, 20), range64(10ull, 15ull)); + assert_damage(dt.good_leaf(15, 20), run64(10ull, 15ull)); } //----------------------------------------------------------------