os/bluestore: drop useless count arg to allocate

The vector<> has a size.

Signed-off-by: Sage Weil <sage@redhat.com>
(cherry picked from commit 0aa402fba19f5c83806304b2ecef6902c481eff4)

diff --git a/src/os/bluestore/Allocator.h b/src/os/bluestore/Allocator.h
index 71549bc3fe73319eda01f748777ce1e2426d3bb2..051b7254fc9a499e567727c20bb496ca492e3824 100644 (file)
--- a/src/os/bluestore/Allocator.h
+++ b/src/os/bluestore/Allocator.h
@@ -37,11 +37,11 @@ public:
    */
   virtual int64_t allocate(uint64_t want_size, uint64_t alloc_unit,
                           uint64_t max_alloc_size, int64_t hint,
-                          AllocExtentVector *extents, int *count) = 0;
+                          AllocExtentVector *extents) = 0;
 
   int allocate(uint64_t want_size, uint64_t alloc_unit,
-               int64_t hint, AllocExtentVector *extents, int *count) {
-    return allocate(want_size, alloc_unit, want_size, hint, extents, count);
+               int64_t hint, AllocExtentVector *extents) {
+    return allocate(want_size, alloc_unit, want_size, hint, extents);
   }
 
   virtual int release(

diff --git a/src/os/bluestore/BitMapAllocator.cc b/src/os/bluestore/BitMapAllocator.cc
index 7c0877662d93f7987782c5f2786773ee58e1eb56..e289ff2de32b0ba36bc030a974d4f81ea87f1331 100644 (file)
--- a/src/os/bluestore/BitMapAllocator.cc
+++ b/src/os/bluestore/BitMapAllocator.cc
@@ -107,7 +107,7 @@ void BitMapAllocator::unreserve(uint64_t unused)
 
 int64_t BitMapAllocator::allocate(
   uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-  int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents, int *count)
+  int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents)
 {
 
   assert(!(alloc_unit % m_block_size));
@@ -122,23 +122,21 @@ int64_t BitMapAllocator::allocate(
      << dendl;
 
   return allocate_dis(want_size, alloc_unit / m_block_size,
-                      max_alloc_size, hint / m_block_size, extents, count);
+                      max_alloc_size, hint / m_block_size, extents);
 }
 
 int64_t BitMapAllocator::allocate_dis(
   uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-  int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents, int *count)
+  int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents)
 {
   ExtentList block_list = ExtentList(extents, m_block_size, max_alloc_size);
   int64_t nblks = (want_size + m_block_size - 1) / m_block_size;
   int64_t num = 0;
-  *count = 0;
 
   num = m_bit_alloc->alloc_blocks_dis_res(nblks, alloc_unit, hint, &block_list);
   if (num == 0) {
     return -ENOSPC;
   }
-  *count = block_list.get_extent_count();
 
   return num * m_block_size;
 }

diff --git a/src/os/bluestore/BitMapAllocator.h b/src/os/bluestore/BitMapAllocator.h
index bc8a302912846c1408b86dce8f8e9f275c4e78f6..0b39a3e79c6f35f3af84daf81e01e777b6ef715e 100644 (file)
--- a/src/os/bluestore/BitMapAllocator.h
+++ b/src/os/bluestore/BitMapAllocator.h
@@ -22,8 +22,7 @@ class BitMapAllocator : public Allocator {
 
   int64_t allocate_dis(
     uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents,
-    int *count);
+    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents);
 
 public:
   BitMapAllocator();
@@ -35,8 +34,7 @@ public:
 
   int64_t allocate(
     uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents,
-    int *count);
+    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents);
 
   int release(
     uint64_t offset, uint64_t length);

diff --git a/src/os/bluestore/BlueFS.cc b/src/os/bluestore/BlueFS.cc
index 2b68791637813c8921782c33c37be2b9b05f33ed..fa3a4fa6b6eb6c6211583090d02b7c01078fcaae 100644 (file)
--- a/src/os/bluestore/BlueFS.cc
+++ b/src/os/bluestore/BlueFS.cc
@@ -177,17 +177,16 @@ int BlueFS::reclaim_blocks(unsigned id, uint64_t want,
   assert(alloc[id]);
   int r = alloc[id]->reserve(want);
   assert(r == 0); // caller shouldn't ask for more than they can get
-  int count = 0;
   int64_t got = alloc[id]->allocate(want, g_conf->bluefs_alloc_size, 0,
-                                   extents, &count);
+                                   extents);
   assert(got > 0);
   if (got < (int64_t)want)
     alloc[id]->unreserve(want - got);
 
-  for (int i = 0; i < count; i++) {
-    block_all[id].erase((*extents)[i].offset, (*extents)[i].length);
-    block_total[id] -= (*extents)[i].length;
-    log_t.op_alloc_rm(id, (*extents)[i].offset, (*extents)[i].length);
+  for (auto& p : *extents) {
+    block_all[id].erase(p.offset, p.length);
+    block_total[id] -= p.length;
+    log_t.op_alloc_rm(id, p.offset, p.length);
   }
 
   r = _flush_and_sync_log(l);
@@ -1763,10 +1762,9 @@ int BlueFS::_allocate(uint8_t id, uint64_t len,
     hint = ev->back().end();
   }
 
-  int count = 0;
   AllocExtentVector extents;
   int64_t alloc_len = alloc[id]->allocate(left, min_alloc_size, hint,
-                          &extents, &count);
+                          &extents);
   if (alloc_len < (int64_t)left) {
     derr << __func__ << " allocate failed on 0x" << std::hex << left
         << " min_alloc_size 0x" << min_alloc_size << std::dec << dendl;
@@ -1775,8 +1773,8 @@ int BlueFS::_allocate(uint8_t id, uint64_t len,
     return -ENOSPC;
   }
 
-  for (int i = 0; i < count; i++) {
-    bluefs_extent_t e = bluefs_extent_t(id, extents[i].offset, extents[i].length);
+  for (auto& p : extents) {
+    bluefs_extent_t e = bluefs_extent_t(id, p.offset, p.length);
     if (!ev->empty() &&
        ev->back().bdev == e.bdev &&
        ev->back().end() == (uint64_t) e.offset) {

diff --git a/src/os/bluestore/BlueStore.cc b/src/os/bluestore/BlueStore.cc
index f72cfdd17159a7de65542592467bdcbc0085fb2a..33d6a780f0ca679f4a8e2a2da4fe20a9f2ff96ae 100644 (file)
--- a/src/os/bluestore/BlueStore.cc
+++ b/src/os/bluestore/BlueStore.cc
@@ -3620,10 +3620,9 @@ int BlueStore::_balance_bluefs_freespace(vector<bluestore_pextent_t> *extents)
     int r = alloc->reserve(gift);
     assert(r == 0);
 
-    int count = 0;
     AllocExtentVector exts;
     int64_t alloc_len = alloc->allocate(gift, g_conf->bluefs_alloc_size,
-                                       0, 0, &exts, &count);
+                                       0, 0, &exts);
 
     if (alloc_len < (int64_t)gift) {
       derr << __func__ << " allocate failed on 0x" << std::hex << gift
@@ -3632,10 +3631,8 @@ int BlueStore::_balance_bluefs_freespace(vector<bluestore_pextent_t> *extents)
       assert(0 == "allocate failed, wtf");
       return -ENOSPC;
     }
-    assert(count > 0);
-    
-    for (int i = 0; i < count; i++) {
-      bluestore_pextent_t e = bluestore_pextent_t(exts[i]);
+    for (auto& p : exts) {
+      bluestore_pextent_t e = bluestore_pextent_t(p);
       dout(1) << __func__ << " gifting " << e << " to bluefs" << dendl;
       extents->push_back(e);
     }
@@ -7875,10 +7872,9 @@ int BlueStore::_do_alloc_write(
       }
     }
 
-    int count = 0;
     AllocExtentVector extents;
     int64_t got = alloc->allocate(final_length, min_alloc_size, max_alloc_size,
-                            hint, &extents, &count);
+                            hint, &extents);
     assert(got == (int64_t)final_length);
     need -= got;
     txc->statfs_delta.allocated() += got;

diff --git a/src/os/bluestore/StupidAllocator.cc b/src/os/bluestore/StupidAllocator.cc
index 1cea965da38d22ea2745a80cc1ccb195f46a8280..5118ee37db87a6863f197b61911a4aa4d6ae34fe 100644 (file)
--- a/src/os/bluestore/StupidAllocator.cc
+++ b/src/os/bluestore/StupidAllocator.cc
@@ -205,8 +205,7 @@ int64_t StupidAllocator::allocate(
   uint64_t alloc_unit,
   uint64_t max_alloc_size,
   int64_t hint,
-  mempool::bluestore_alloc::vector<AllocExtent> *extents,
-  int *count)
+  mempool::bluestore_alloc::vector<AllocExtent> *extents)
 {
   uint64_t allocated_size = 0;
   uint64_t offset = 0;
@@ -216,7 +215,6 @@ int64_t StupidAllocator::allocate(
   if (max_alloc_size == 0) {
     max_alloc_size = want_size;
   }
-  *count = 0;
 
   ExtentList block_list = ExtentList(extents, 1, max_alloc_size);
 
@@ -234,7 +232,6 @@ int64_t StupidAllocator::allocate(
     hint = offset + length;
   }
 
-  *count = block_list.get_extent_count();
   if (allocated_size == 0) {
     return -ENOSPC;
   }

diff --git a/src/os/bluestore/StupidAllocator.h b/src/os/bluestore/StupidAllocator.h
index b5bf17295fbdf048ad77da72390ce0149adb46ac..867079597ce8a29bb9a790dccb86ccdaa4cfd0d0 100644 (file)
--- a/src/os/bluestore/StupidAllocator.h
+++ b/src/os/bluestore/StupidAllocator.h
@@ -32,8 +32,7 @@ public:
 
   int64_t allocate(
     uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents,
-    int *count);
+    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents);
 
   int64_t allocate_int(
     uint64_t want_size, uint64_t alloc_unit, int64_t hint,

diff --git a/src/test/objectstore/Allocator_test.cc b/src/test/objectstore/Allocator_test.cc
index 0b75f9c4f46d972b5d0d56a069a30125cc917122..78d5fa316ecd5a0b0539d6629964cb9470852801 100644 (file)
--- a/src/test/objectstore/Allocator_test.cc
+++ b/src/test/objectstore/Allocator_test.cc
@@ -51,18 +51,14 @@ TEST_P(AllocTest, test_alloc_min_alloc)
 {
   int64_t block_size = 1024;
   int64_t blocks = BitMapZone::get_total_blocks() * 2 * block_size;
-  int count = 0;
-  uint64_t alloc_len = 0;
 
   {
     init_alloc(blocks, block_size);
     alloc->init_add_free(block_size, block_size);
     EXPECT_EQ(alloc->reserve(block_size), 0);
-    AllocExtentVector extents = AllocExtentVector 
-                        (1, AllocExtent(0, 0));
-    EXPECT_EQ(alloc->allocate(block_size, block_size, 
-                                   0, (int64_t) 0, &extents, &count, &alloc_len), 0);
-    EXPECT_EQ(alloc_len, (uint64_t) block_size);
+    AllocExtentVector extents;
+    EXPECT_EQ(block_size, alloc->allocate(block_size, block_size, 
+                                         0, (int64_t) 0, &extents));
   }
 
   /*
@@ -71,15 +67,12 @@ TEST_P(AllocTest, test_alloc_min_alloc)
   {
     alloc->init_add_free(0, block_size * 4);
     EXPECT_EQ(alloc->reserve(block_size * 4), 0);
-    AllocExtentVector extents = AllocExtentVector 
-                        (4, AllocExtent(0, 0));
-  
-    EXPECT_EQ(alloc->allocate(4 * (uint64_t)block_size, (uint64_t) block_size, 
-                                   0, (int64_t) 0, &extents, &count, &alloc_len), 0);
-    EXPECT_EQ(alloc_len, 4 * (uint64_t) block_size);
+    AllocExtentVector extents;  
+    EXPECT_EQ(4*block_size,
+             alloc->allocate(4 * (uint64_t)block_size, (uint64_t) block_size, 
+                             0, (int64_t) 0, &extents));
+    EXPECT_EQ(1u, extents.size());
     EXPECT_EQ(extents[0].length, 4 * block_size);
-    EXPECT_EQ(0U, extents[1].length);
-    EXPECT_EQ(count, 1);
   }
 
   /*
@@ -89,16 +82,14 @@ TEST_P(AllocTest, test_alloc_min_alloc)
     alloc->init_add_free(0, block_size * 2);
     alloc->init_add_free(3 * block_size, block_size * 2);
     EXPECT_EQ(alloc->reserve(block_size * 4), 0);
-    AllocExtentVector extents = AllocExtentVector 
-                        (4, AllocExtent(0, 0));
+    AllocExtentVector extents;
   
-    EXPECT_EQ(alloc->allocate(4 * (uint64_t)block_size, (uint64_t) block_size, 
-                                   0, (int64_t) 0, &extents, &count, &alloc_len), 0);
-    EXPECT_EQ(alloc_len, 4 * (uint64_t) block_size);
+    EXPECT_EQ(4*block_size,
+             alloc->allocate(4 * (uint64_t)block_size, (uint64_t) block_size, 
+                             0, (int64_t) 0, &extents));
+    EXPECT_EQ(2u, extents.size());
     EXPECT_EQ(extents[0].length, 2 * block_size);
     EXPECT_EQ(extents[1].length, 2 * block_size);
-    EXPECT_EQ(0U, extents[2].length);
-    EXPECT_EQ(count, 2);
   }
   alloc->shutdown();
 }
@@ -107,8 +98,6 @@ TEST_P(AllocTest, test_alloc_min_max_alloc)
 {
   int64_t block_size = 1024;
   int64_t blocks = BitMapZone::get_total_blocks() * 2 * block_size;
-  int count = 0;
-  uint64_t alloc_len = 0;
 
   init_alloc(blocks, block_size);
 
@@ -119,16 +108,14 @@ TEST_P(AllocTest, test_alloc_min_max_alloc)
   {
     alloc->init_add_free(0, block_size * 4);
     EXPECT_EQ(alloc->reserve(block_size * 4), 0);
-    AllocExtentVector extents = AllocExtentVector 
-                        (4, AllocExtent(0, 0));
-  
-    EXPECT_EQ(alloc->allocate(4 * (uint64_t)block_size, (uint64_t) block_size, 
-                                   block_size, (int64_t) 0, &extents, &count, &alloc_len), 0);
-    EXPECT_EQ(alloc_len, 4 * (uint64_t) block_size);
-    for (int i = 0; i < 4; i++) {
-      EXPECT_EQ(extents[i].length, block_size);
+    AllocExtentVector extents;  
+    EXPECT_EQ(4*block_size,
+             alloc->allocate(4 * (uint64_t)block_size, (uint64_t) block_size, 
+                             block_size, (int64_t) 0, &extents));
+    for (auto e : extents) {
+      EXPECT_EQ(e.length, block_size);
     }
-    EXPECT_EQ(count, 4);
+    EXPECT_EQ(4u, extents.size());
   }
 
 
@@ -139,16 +126,14 @@ TEST_P(AllocTest, test_alloc_min_max_alloc)
   {
     alloc->init_add_free(0, block_size * 4);
     EXPECT_EQ(alloc->reserve(block_size * 4), 0);
-    AllocExtentVector extents = AllocExtentVector 
-                        (2, AllocExtent(0, 0));
-  
-    EXPECT_EQ(alloc->allocate(4 * (uint64_t)block_size, (uint64_t) block_size, 
-                                   2 * block_size, (int64_t) 0, &extents, &count, &alloc_len), 0);
-    EXPECT_EQ(alloc_len, 4 * (uint64_t) block_size);
-    for (int i = 0; i < 2; i++) {
-      EXPECT_EQ(extents[i].length, block_size * 2);
+    AllocExtentVector extents;  
+    EXPECT_EQ(4*block_size,
+             alloc->allocate(4 * (uint64_t)block_size, (uint64_t) block_size, 
+                             2 * block_size, (int64_t) 0, &extents));
+    EXPECT_EQ(2u, extents.size());
+    for (auto& e : extents) {
+      EXPECT_EQ(e.length, block_size * 2);
     }
-    EXPECT_EQ(count, 2);
   }
 
   /*
@@ -157,17 +142,15 @@ TEST_P(AllocTest, test_alloc_min_max_alloc)
   {
     alloc->init_add_free(0, block_size * 1024);
     EXPECT_EQ(alloc->reserve(block_size * 1024), 0);
-    AllocExtentVector extents = AllocExtentVector 
-                        (1024, AllocExtent(0, 0));
-  
-    EXPECT_EQ(alloc->allocate(1024 * (uint64_t)block_size, (uint64_t) block_size * 4, 
-                                   block_size * 4, (int64_t) 0, &extents, &count, &alloc_len), 0);
- 
-    EXPECT_EQ(alloc_len, 1024 * (uint64_t) block_size);
-    for (int i = 0; i < count; i++) {
-      EXPECT_EQ(extents[i].length, block_size * 4);
+    AllocExtentVector extents;  
+    EXPECT_EQ(1024 * block_size,
+             alloc->allocate(1024 * (uint64_t)block_size,
+                             (uint64_t) block_size * 4, 
+                             block_size * 4, (int64_t) 0, &extents));
+    for (auto& e : extents) {
+      EXPECT_EQ(e.length, block_size * 4);
     }
-    EXPECT_EQ(count, 1024 / 4);
+    EXPECT_EQ(1024u/4, extents.size());
   }
 
   /*
@@ -176,16 +159,14 @@ TEST_P(AllocTest, test_alloc_min_max_alloc)
   {
     alloc->init_add_free(0, block_size * 16);
     EXPECT_EQ(alloc->reserve(block_size * 16), 0);
-    AllocExtentVector extents = AllocExtentVector 
-                        (8, AllocExtent(0, 0));
-  
-    EXPECT_EQ(alloc->allocate(16 * (uint64_t)block_size, (uint64_t) block_size, 
-                                   2 * block_size, (int64_t) 0, &extents, &count, &alloc_len), 0);
-
-    EXPECT_EQ(count, 8);
-    EXPECT_EQ(alloc_len, 16 * (uint64_t) block_size);
-    for (int i = 0; i < 8; i++) {
-      EXPECT_EQ(extents[i].length, 2 * block_size);
+    AllocExtentVector extents;  
+    EXPECT_EQ(16 * block_size,
+             alloc->allocate(16 * (uint64_t)block_size, (uint64_t) block_size, 
+                             2 * block_size, (int64_t) 0, &extents));
+
+    EXPECT_EQ(extents.size(), 8u);
+    for (auto& e : extents) {
+      EXPECT_EQ(e.length, 2 * block_size);
     }
     EXPECT_EQ(alloc->release_extents(&extents, count), 0);
   }
@@ -195,8 +176,6 @@ TEST_P(AllocTest, test_alloc_failure)
 {
   int64_t block_size = 1024;
   int64_t blocks = BitMapZone::get_total_blocks() * block_size;
-  int count = 0;
-  uint64_t alloc_len = 0;
 
   init_alloc(blocks, block_size);
   {
@@ -204,18 +183,18 @@ TEST_P(AllocTest, test_alloc_failure)
     alloc->init_add_free(block_size * 512, block_size * 256);
 
     EXPECT_EQ(alloc->reserve(block_size * 512), 0);
-    AllocExtentVector extents = AllocExtentVector 
-                        (4, AllocExtent(0, 0));
-  
-    EXPECT_EQ(alloc->allocate(512 * (uint64_t)block_size, (uint64_t) block_size * 256, 
-                                   block_size * 256, (int64_t) 0, &extents, &count, &alloc_len), 0);
-    EXPECT_EQ(512 * (uint64_t)block_size, alloc_len);
+    AllocExtentVector extents;  
+    EXPECT_EQ(512 * block_size,
+             alloc->allocate(512 * (uint64_t)block_size,
+                             (uint64_t) block_size * 256, 
+                             block_size * 256, (int64_t) 0, &extents));
     alloc->init_add_free(0, block_size * 256);
     alloc->init_add_free(block_size * 512, block_size * 256);
     EXPECT_EQ(alloc->reserve(block_size * 512), 0);
-    EXPECT_EQ(alloc->allocate(512 * (uint64_t)block_size, (uint64_t) block_size * 512,
-                                   block_size * 512, (int64_t) 0, &extents, &count, &alloc_len), -ENOSPC);
-    EXPECT_EQ(alloc_len, (uint64_t) 0);
+    EXPECT_EQ(-ENOSPC,
+             alloc->allocate(512 * (uint64_t)block_size,
+                             (uint64_t) block_size * 512,
+                             block_size * 512, (int64_t) 0, &extents));
   }
 }
 
@@ -225,44 +204,39 @@ TEST_P(AllocTest, test_alloc_hint_bmap)
     return;
   }
   int64_t blocks = BitMapArea::get_level_factor(2) * 4;
-  int count = 0;
   int64_t allocated = 0;
   int64_t zone_size = 1024;
-  uint64_t alloc_len = 0;
-  g_conf->set_val("bluestore_bitmapallocator_blocks_per_zone", std::to_string(zone_size));
+  g_conf->set_val("bluestore_bitmapallocator_blocks_per_zone",
+                 std::to_string(zone_size));
 
   init_alloc(blocks, 1);
   alloc->init_add_free(0, blocks);
 
-  auto extents = AllocExtentVector
-          (zone_size * 4, AllocExtent(-1, -1));
+  AllocExtentVector extents;
   alloc->reserve(blocks);
 
-  allocated = alloc->allocate(1, 1, 1, zone_size, &extents, &count, &alloc_len);
-  ASSERT_EQ(0, allocated);
-  ASSERT_EQ((uint64_t) 1, alloc_len);
-  ASSERT_EQ(1, count);
+  allocated = alloc->allocate(1, 1, 1, zone_size, &extents);
+  ASSERT_EQ(1, allocated);
+  ASSERT_EQ(1u, extents.size());
   ASSERT_EQ(extents[0].offset, (uint64_t) zone_size);
 
-  allocated = alloc->allocate(1, 1, 1, zone_size * 2 - 1, &extents, &count, &alloc_len);
-  ASSERT_EQ((uint64_t) 1, alloc_len);
-  EXPECT_EQ(0, allocated);
-  ASSERT_EQ(1, count);
+  allocated = alloc->allocate(1, 1, 1, zone_size * 2 - 1, &extents);
+  EXPECT_EQ(1, allocated);
+  ASSERT_EQ(1u, extents.size());
   EXPECT_EQ((int64_t) extents[0].offset, zone_size * 2 - 1);
 
   /*
    * Wrap around with hint
    */
-  allocated = alloc->allocate(zone_size * 2, 1, 1,  blocks - zone_size * 2, &extents, &count, &alloc_len);
-  EXPECT_EQ(0, allocated);
-  ASSERT_EQ((uint64_t) zone_size * 2, alloc_len);
-  EXPECT_EQ(zone_size * 2, count);
+  allocated = alloc->allocate(zone_size * 2, 1, 1,  blocks - zone_size * 2,
+                             &extents);
+  ASSERT_EQ(zone_size * 2, allocated);
+  EXPECT_EQ(zone_size * 2, (int)extents.size());
   EXPECT_EQ((int64_t)extents[0].offset, blocks - zone_size * 2);
 
-  allocated = alloc->allocate(zone_size, 1, 1, blocks - zone_size, &extents, &count, &alloc_len);
-  EXPECT_EQ(0, allocated);
-  ASSERT_EQ((uint64_t) zone_size, alloc_len);
-  EXPECT_EQ(zone_size, count);
+  allocated = alloc->allocate(zone_size, 1, 1, blocks - zone_size, &extents);
+  ASSERT_EQ(zone_size, allocated);
+  EXPECT_EQ(zone_size, (int)extents.size());
   EXPECT_EQ(extents[0].offset, (uint64_t) 0);
 }