unitest_bit_alloc, unittest_alloc: fixes

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

diff --git a/src/test/objectstore/Allocator_test.cc b/src/test/objectstore/Allocator_test.cc
index 7976a21e410f93d03716b918dd4cc5322e5e3057..f2fea3a175b82c384ba24da29ebdce582870b875 100644 (file)
--- a/src/test/objectstore/Allocator_test.cc
+++ b/src/test/objectstore/Allocator_test.cc
@@ -190,6 +190,7 @@ TEST_P(AllocTest, test_alloc_failure)
                              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);
+    extents.clear();
     EXPECT_EQ(alloc->reserve(block_size * 512), 0);
     EXPECT_EQ(-ENOSPC,
              alloc->allocate(512 * (uint64_t)block_size,
@@ -220,6 +221,7 @@ TEST_P(AllocTest, test_alloc_hint_bmap)
   ASSERT_EQ(1u, extents.size());
   ASSERT_EQ(extents[0].offset, (uint64_t) zone_size);
 
+  extents.clear();
   allocated = alloc->allocate(1, 1, 1, zone_size * 2 - 1, &extents);
   EXPECT_EQ(1, allocated);
   ASSERT_EQ(1u, extents.size());
@@ -228,12 +230,14 @@ TEST_P(AllocTest, test_alloc_hint_bmap)
   /*
    * Wrap around with hint
    */
+  extents.clear();
   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);
 
+  extents.clear();
   allocated = alloc->allocate(zone_size, 1, 1, blocks - zone_size, &extents);
   ASSERT_EQ(zone_size, allocated);
   EXPECT_EQ(zone_size, (int)extents.size());

diff --git a/src/test/objectstore/BitAllocator_test.cc b/src/test/objectstore/BitAllocator_test.cc
index f68f44e0edc5a127ee52e7d47a032db8aa0e028e..a15eaa3bf46d0a585a9623455d9335a9c646edcd 100644 (file)
--- a/src/test/objectstore/BitAllocator_test.cc
+++ b/src/test/objectstore/BitAllocator_test.cc
@@ -283,9 +283,7 @@ TEST(BitAllocator, test_zone_alloc)
   bmap_test_assert(lock);
 
   int64_t blk_size = 1024;
-  AllocExtentVector extents = AllocExtentVector
-        (zone->size() / 2, AllocExtent(-1, -1));
-
+  AllocExtentVector extents;
   ExtentList *block_list = new ExtentList(&extents, blk_size);
   allocated = zone->alloc_blocks_dis(zone->size() / 2, 1, 0, 0, block_list);
   bmap_test_assert(allocated == zone->size() / 2);
@@ -293,9 +291,7 @@ TEST(BitAllocator, test_zone_alloc)
 
   {
     int64_t blk_size = 1024;
-    AllocExtentVector extents = AllocExtentVector
-      (zone->size() / 2, AllocExtent(-1, -1));
-
+    AllocExtentVector extents;
     ExtentList *block_list = new ExtentList(&extents, blk_size);
 
     zone = new BitMapZone(g_ceph_context, total_blocks, 0);
@@ -318,11 +314,11 @@ TEST(BitAllocator, test_zone_alloc)
    */
   {
     int64_t blk_size = 1;
-    AllocExtentVector extents = AllocExtentVector
-      (zone->size() / 2, AllocExtent(-1, -1));
+    AllocExtentVector extents;
 
     for (int i = 1; i <= total_blocks - BmapEntry::size(); i = i << 1) {
       for (int64_t j = 0; j <= BmapEntry::size(); j = 1 << j) {
+       extents.clear();
         ExtentList *block_list = new ExtentList(&extents, blk_size);
        zone = new BitMapZone(g_ceph_context, total_blocks, 0);
         lock = zone->lock_excl_try();
@@ -340,6 +336,7 @@ TEST(BitAllocator, test_zone_alloc)
 
     //allocation in loop
     {
+      extents.clear();
       ExtentList *block_list = new ExtentList(&extents, blk_size);
       zone = new BitMapZone(g_ceph_context, total_blocks, 0);
       lock = zone->lock_excl_try();
@@ -371,36 +368,35 @@ TEST(BitAllocator, test_zone_alloc)
     }
 
     {
+      extents.clear();
+      ExtentList *block_list = new ExtentList(&extents, blk_size);
+      zone = new BitMapZone(g_ceph_context, total_blocks, 0);
+      lock = zone->lock_excl_try();
+      bmap_test_assert(lock);
 
-        ExtentList *block_list = new ExtentList(&extents, blk_size);
-       zone = new BitMapZone(g_ceph_context, total_blocks, 0);
-        lock = zone->lock_excl_try();
-        bmap_test_assert(lock);
-
-        block_list->reset();
-        allocated = zone->alloc_blocks_dis(total_blocks + 1, total_blocks + 1, 0, 1024, block_list);
-        bmap_test_assert(allocated == 0);  
+      block_list->reset();
+      allocated = zone->alloc_blocks_dis(total_blocks + 1, total_blocks + 1, 0, 1024, block_list);
+      bmap_test_assert(allocated == 0);
 
-        block_list->reset();
-        allocated = zone->alloc_blocks_dis(total_blocks, total_blocks, 1, 1024, block_list);
-        bmap_test_assert(allocated == 0);  
+      block_list->reset();
+      allocated = zone->alloc_blocks_dis(total_blocks, total_blocks, 1, 1024, block_list);
+      bmap_test_assert(allocated == 0);
 
-        block_list->reset();
-        allocated = zone->alloc_blocks_dis(total_blocks, total_blocks, 0, 0, block_list);
-        bmap_test_assert(allocated == total_blocks);
-        bmap_test_assert(extents[0].offset == 0);
+      block_list->reset();
+      allocated = zone->alloc_blocks_dis(total_blocks, total_blocks, 0, 0, block_list);
+      bmap_test_assert(allocated == total_blocks);
+      bmap_test_assert(extents[0].offset == 0);
 
-        zone->free_blocks(extents[0].offset, allocated);        
+      zone->free_blocks(extents[0].offset, allocated);
         
-        delete block_list;  
-        block_list = new ExtentList(&extents, blk_size, total_blocks / 4 * blk_size);
-        block_list->reset();
-        allocated = zone->alloc_blocks_dis(total_blocks, total_blocks / 4, 0, 0, block_list);
-        bmap_test_assert(allocated == total_blocks);
-        for (int i = 0; i < 4; i++) {
-          bmap_test_assert(extents[i].offset == (uint64_t) i * (total_blocks / 4));
-        }
-  
+      delete block_list;
+      extents.clear();
+      block_list = new ExtentList(&extents, blk_size, total_blocks / 4 * blk_size);
+      allocated = zone->alloc_blocks_dis(total_blocks, total_blocks / 4, 0, 0, block_list);
+      bmap_test_assert(allocated == total_blocks);
+      for (int i = 0; i < 4; i++) {
+       bmap_test_assert(extents[i].offset == (uint64_t) i * (total_blocks / 4));
+      }
     }
   }
 }
@@ -432,8 +428,7 @@ TEST(BitAllocator, test_bmap_alloc)
     for (int64_t iter = 0; iter < max_iter; iter++) {
       for (int64_t j = 0; alloc_size <= total_blocks; j++) {
         int64_t blk_size = 1024;
-        auto extents = AllocExtentVector
-              (alloc->size(), AllocExtent(-1, -1));
+        AllocExtentVector extents;
         ExtentList *block_list = new ExtentList(&extents, blk_size, alloc_size);
         for (int64_t i = 0; i < total_blocks; i += alloc_size) {
           bmap_test_assert(alloc->reserve_blocks(alloc_size) == true);
@@ -455,8 +450,7 @@ TEST(BitAllocator, test_bmap_alloc)
     }
 
     int64_t blk_size = 1024;
-    auto extents = AllocExtentVector
-          (alloc->size(), AllocExtent(-1, -1));
+    AllocExtentVector extents;
 
     ExtentList *block_list = new ExtentList(&extents, blk_size);
   
@@ -497,8 +491,7 @@ bool alloc_extents_max_block(BitAllocator *alloc,
   int64_t allocated = 0;
   int64_t verified = 0;
   int64_t count = 0;
-  AllocExtentVector extents = AllocExtentVector
-        (total_alloc, AllocExtent(-1, -1));
+  AllocExtentVector extents;
 
   ExtentList *block_list = new ExtentList(&extents, blk_size, max_alloc);
 
@@ -543,18 +536,17 @@ do_work_dis(BitAllocator *alloc)
   int64_t alloced = 0;
   int64_t num_blocks = alloc->size() / NUM_THREADS;
 
-  AllocExtentVector extents = AllocExtentVector
-        (num_blocks, AllocExtent(-1, -1));
+  AllocExtentVector extents;
   ExtentList *block_list = new ExtentList(&extents, 4096);
 
   while (num_iters--) {
-      alloc_assert(alloc->reserve_blocks(num_blocks));
-      alloced = alloc->alloc_blocks_dis_res(num_blocks, 1, 0, block_list);
-      alloc_assert(alloced == num_blocks);
+    alloc_assert(alloc->reserve_blocks(num_blocks));
+    alloced = alloc->alloc_blocks_dis_res(num_blocks, 1, 0, block_list);
+    alloc_assert(alloced == num_blocks);
 
-      alloc_assert(alloc->is_allocated_dis(block_list, num_blocks));
-      alloc->free_blocks_dis(num_blocks, block_list);
-      block_list->reset();
+    alloc_assert(alloc->is_allocated_dis(block_list, num_blocks));
+    alloc->free_blocks_dis(num_blocks, block_list);
+    block_list->reset();
   }
 }