os/bluestore/bluestore_types: add contains(), clear(), empty() to extent_ref_map

Signed-off-by: Sage Weil <sage@redhat.com>

diff --git a/src/os/bluestore/bluestore_types.cc b/src/os/bluestore/bluestore_types.cc
index d8c854d112294b79e12af245eb719928e63b8754..8413f948d17a5b2591b08860566f906f2e21135b 100644 (file)
--- a/src/os/bluestore/bluestore_types.cc
+++ b/src/os/bluestore/bluestore_types.cc
@@ -269,6 +269,33 @@ void bluestore_extent_ref_map_t::put(uint64_t offset, uint32_t length,
   _check();
 }
 
+bool bluestore_extent_ref_map_t::contains(uint64_t offset, uint32_t length) const
+{
+  map<uint64_t,record_t>::const_iterator p = ref_map.lower_bound(offset);
+  if (p == ref_map.end() || p->first > offset) {
+    if (p == ref_map.begin()) {
+      return false; // nothing before
+    }
+    --p;
+    if (p->first + p->second.length <= offset) {
+      return false; // gap
+    }
+  }
+  while (length > 0) {
+    if (p == ref_map.end())
+      return false;
+    if (p->first > offset)
+      return false;
+    if (p->first + p->second.length >= offset + length)
+      return true;
+    uint64_t overlap = p->first + p->second.length - offset;
+    offset += overlap;
+    length -= overlap;
+    ++p;
+  }
+  return true;
+}
+
 void bluestore_extent_ref_map_t::encode(bufferlist& bl) const
 {
   ENCODE_START(1, 1, bl);

diff --git a/src/os/bluestore/bluestore_types.h b/src/os/bluestore/bluestore_types.h
index 329e1db223a9815a3ec84d33e9ace6b2ddebabb8..1e1abe5b020284fc41e553ef46b34f4c6b0272e9 100644 (file)
--- a/src/os/bluestore/bluestore_types.h
+++ b/src/os/bluestore/bluestore_types.h
@@ -122,10 +122,19 @@ struct bluestore_extent_ref_map_t {
   void _check() const;
   void _maybe_merge_left(map<uint64_t,record_t>::iterator& p);
 
+  void clear() {
+    ref_map.clear();
+  }
+  bool empty() const {
+    return ref_map.empty();
+  }
+
   void add(uint64_t offset, uint32_t len, unsigned ref=2);
   void get(uint64_t offset, uint32_t len);
   void put(uint64_t offset, uint32_t len, vector<bluestore_extent_t> *release);
 
+  bool contains(uint64_t offset, uint32_t len) const;
+
   void encode(bufferlist& bl) const;
   void decode(bufferlist::iterator& p);
   void dump(Formatter *f) const;
@@ -135,7 +144,18 @@ WRITE_CLASS_ENCODER(bluestore_extent_ref_map_t::record_t)
 WRITE_CLASS_ENCODER(bluestore_extent_ref_map_t)
 
 ostream& operator<<(ostream& out, const bluestore_extent_ref_map_t& rm);
-
+static inline bool operator==(const bluestore_extent_ref_map_t::record_t& l,
+                             const bluestore_extent_ref_map_t::record_t& r) {
+  return l.length == r.length && l.refs == r.refs;
+}
+static inline bool operator==(const bluestore_extent_ref_map_t& l,
+                             const bluestore_extent_ref_map_t& r) {
+  return l.ref_map == r.ref_map;
+}
+static inline bool operator!=(const bluestore_extent_ref_map_t& l,
+                             const bluestore_extent_ref_map_t& r) {
+  return !(l == r);
+}
 
 /// overlay: a byte extent backed by kv pair, logically overlaying other content
 struct bluestore_overlay_t {

diff --git a/src/test/objectstore/test_bluestore_types.cc b/src/test/objectstore/test_bluestore_types.cc
index 18e20ab3c40cd70ea5bd327a718958ba2f1d4222..4e169d3f7df83ed84783a9ee63c84cff10cbb0b6 100644 (file)
--- a/src/test/objectstore/test_bluestore_types.cc
+++ b/src/test/objectstore/test_bluestore_types.cc
@@ -17,17 +17,17 @@ TEST(bluestore_extent_ref_map_t, add)
   m.add(20, 10);
   cout << m << std::endl;
   ASSERT_EQ(1, m.ref_map.size());
-  ASSERT_EQ(20, m.ref_map[10].length);
+  ASSERT_EQ(20u, m.ref_map[10].length);
   ASSERT_EQ(2, m.ref_map[10].refs);
   m.add(40, 10);
   cout << m << std::endl;
-  ASSERT_EQ(2, m.ref_map.size());
+  ASSERT_EQ(2u, m.ref_map.size());
   m.add(30, 10);
   cout << m << std::endl;
-  ASSERT_EQ(1, m.ref_map.size());
+  ASSERT_EQ(1u, m.ref_map.size());
   m.add(50, 10, 3);
   cout << m << std::endl;
-  ASSERT_EQ(2, m.ref_map.size());
+  ASSERT_EQ(2u, m.ref_map.size());
 }
 
 TEST(bluestore_extent_ref_map_t, get)
@@ -37,44 +37,44 @@ TEST(bluestore_extent_ref_map_t, get)
   cout << m << std::endl;
   m.get(10, 10);
   cout << m << std::endl;
-  ASSERT_EQ(3, m.ref_map.size());
-  ASSERT_EQ(10, m.ref_map[0].length);
-  ASSERT_EQ(2, m.ref_map[0].refs);
-  ASSERT_EQ(10, m.ref_map[10].length);
-  ASSERT_EQ(3, m.ref_map[10].refs);
-  ASSERT_EQ(10, m.ref_map[20].length);
-  ASSERT_EQ(2, m.ref_map[20].refs);
+  ASSERT_EQ(3u, m.ref_map.size());
+  ASSERT_EQ(10u, m.ref_map[0].length);
+  ASSERT_EQ(2u, m.ref_map[0].refs);
+  ASSERT_EQ(10u, m.ref_map[10].length);
+  ASSERT_EQ(3u, m.ref_map[10].refs);
+  ASSERT_EQ(10u, m.ref_map[20].length);
+  ASSERT_EQ(2u, m.ref_map[20].refs);
   m.get(20, 5);
   cout << m << std::endl;
-  ASSERT_EQ(3, m.ref_map.size());
-  ASSERT_EQ(15, m.ref_map[10].length);
-  ASSERT_EQ(3, m.ref_map[10].refs);
-  ASSERT_EQ(5, m.ref_map[25].length);
-  ASSERT_EQ(2, m.ref_map[25].refs);
+  ASSERT_EQ(3u, m.ref_map.size());
+  ASSERT_EQ(15u, m.ref_map[10].length);
+  ASSERT_EQ(3u, m.ref_map[10].refs);
+  ASSERT_EQ(5u, m.ref_map[25].length);
+  ASSERT_EQ(2u, m.ref_map[25].refs);
   m.get(5, 20);
   cout << m << std::endl;
-  ASSERT_EQ(4, m.ref_map.size());
-  ASSERT_EQ(5, m.ref_map[0].length);
-  ASSERT_EQ(2, m.ref_map[0].refs);
-  ASSERT_EQ(5, m.ref_map[5].length);
-  ASSERT_EQ(3, m.ref_map[5].refs);
-  ASSERT_EQ(15, m.ref_map[10].length);
-  ASSERT_EQ(4, m.ref_map[10].refs);
-  ASSERT_EQ(5, m.ref_map[25].length);
-  ASSERT_EQ(2, m.ref_map[25].refs);
+  ASSERT_EQ(4u, m.ref_map.size());
+  ASSERT_EQ(5u, m.ref_map[0].length);
+  ASSERT_EQ(2u, m.ref_map[0].refs);
+  ASSERT_EQ(5u, m.ref_map[5].length);
+  ASSERT_EQ(3u, m.ref_map[5].refs);
+  ASSERT_EQ(15u, m.ref_map[10].length);
+  ASSERT_EQ(4u, m.ref_map[10].refs);
+  ASSERT_EQ(5u, m.ref_map[25].length);
+  ASSERT_EQ(2u, m.ref_map[25].refs);
   m.get(25, 3);
   cout << m << std::endl;
-  ASSERT_EQ(5, m.ref_map.size());
-  ASSERT_EQ(5, m.ref_map[0].length);
-  ASSERT_EQ(2, m.ref_map[0].refs);
-  ASSERT_EQ(5, m.ref_map[5].length);
-  ASSERT_EQ(3, m.ref_map[5].refs);
-  ASSERT_EQ(15, m.ref_map[10].length);
-  ASSERT_EQ(4, m.ref_map[10].refs);
-  ASSERT_EQ(3, m.ref_map[25].length);
-  ASSERT_EQ(3, m.ref_map[25].refs);
-  ASSERT_EQ(2, m.ref_map[28].length);
-  ASSERT_EQ(2, m.ref_map[28].refs);
+  ASSERT_EQ(5u, m.ref_map.size());
+  ASSERT_EQ(5u, m.ref_map[0].length);
+  ASSERT_EQ(2u, m.ref_map[0].refs);
+  ASSERT_EQ(5u, m.ref_map[5].length);
+  ASSERT_EQ(3u, m.ref_map[5].refs);
+  ASSERT_EQ(15u, m.ref_map[10].length);
+  ASSERT_EQ(4u, m.ref_map[10].refs);
+  ASSERT_EQ(3u, m.ref_map[25].length);
+  ASSERT_EQ(3u, m.ref_map[25].refs);
+  ASSERT_EQ(2u, m.ref_map[28].length);
+  ASSERT_EQ(2u, m.ref_map[28].refs);
 }
 
 TEST(bluestore_extent_ref_map_t, put)
@@ -127,3 +127,31 @@ TEST(bluestore_extent_ref_map_t, put)
   ASSERT_EQ(33, r[0].offset);
   ASSERT_EQ(2, r[0].length);
 }
+
+TEST(bluestore_extent_ref_map_t, contains)
+{
+  bluestore_extent_ref_map_t m;
+  m.add(10, 30, 1);
+  ASSERT_TRUE(m.contains(10, 30));
+  ASSERT_TRUE(m.contains(10, 10));
+  ASSERT_TRUE(m.contains(30, 10));
+  ASSERT_FALSE(m.contains(0, 10));
+  ASSERT_FALSE(m.contains(0, 20));
+  ASSERT_FALSE(m.contains(0, 100));
+  ASSERT_FALSE(m.contains(40, 10));
+  ASSERT_FALSE(m.contains(30, 11));
+  m.add(40, 10, 2);
+  ASSERT_TRUE(m.contains(30, 11));
+  ASSERT_TRUE(m.contains(30, 20));
+  ASSERT_TRUE(m.contains(10, 40));
+  ASSERT_FALSE(m.contains(0, 50));
+  ASSERT_FALSE(m.contains(40, 20));
+  m.add(60, 100);
+  ASSERT_TRUE(m.contains(60, 10));
+  ASSERT_TRUE(m.contains(40, 10));
+  ASSERT_FALSE(m.contains(40, 11));
+  ASSERT_FALSE(m.contains(40, 20));
+  ASSERT_FALSE(m.contains(40, 30));
+  ASSERT_FALSE(m.contains(40, 3000));
+  ASSERT_FALSE(m.contains(4000, 30));
+}