Handle 64K page size in alloc unit test and rcuvector unit test.

2 files changed, 42 insertions, 27 deletions

diff --git a/vespalib/src/tests/alloc/alloc_test.cpp b/vespalib/src/tests/alloc/alloc_test.cpp
index da41d75b479..c65bb770f37 100644
--- a/vespalib/src/tests/alloc/alloc_test.cpp
+++ b/vespalib/src/tests/alloc/alloc_test.cpp
@@ -4,6 +4,7 @@
 #include <vespa/vespalib/util/alloc.h>
 #include <vespa/vespalib/util/memory_allocator.h>
 #include <vespa/vespalib/util/exceptions.h>
+#include <vespa/vespalib/util/round_up_to_page_size.h>
 #include <vespa/vespalib/util/size_literals.h>
 #include <cstddef>
 #include <sys/mman.h>
@@ -19,17 +20,23 @@ using namespace vespalib::alloc;
 #endif
 #endif
 
+namespace {
+
+size_t page_sz = round_up_to_page_size(1);
+
+}
+
 template <typename T>
 void
 testSwap(T & a, T & b)
 {
     void * tmpA(a.get());
     void * tmpB(b.get());
-    EXPECT_EQUAL(4_Ki, a.size());
-    EXPECT_EQUAL(8_Ki, b.size());
+    EXPECT_EQUAL(page_sz, a.size());
+    EXPECT_EQUAL(2 * page_sz, b.size());
     std::swap(a, b);
-    EXPECT_EQUAL(4_Ki, b.size());
-    EXPECT_EQUAL(8_Ki, a.size());
+    EXPECT_EQUAL(page_sz, b.size());
+    EXPECT_EQUAL(2 * page_sz, a.size());
     EXPECT_EQUAL(tmpA, b.get());
     EXPECT_EQUAL(tmpB, a.get());
 }
@@ -76,24 +83,24 @@ TEST("test basics") {
     }
     {
         Alloc h = Alloc::allocMMap(100);
-        EXPECT_EQUAL(4_Ki, h.size());
+        EXPECT_EQUAL(page_sz, h.size());
         EXPECT_TRUE(h.get() != nullptr);
     }
     {
-        Alloc a = Alloc::allocHeap(4_Ki), b = Alloc::allocHeap(8_Ki);
+        Alloc a = Alloc::allocHeap(page_sz), b = Alloc::allocHeap(2 * page_sz);
         testSwap(a, b);
     }
     {
-        Alloc a = Alloc::allocMMap(4_Ki), b = Alloc::allocMMap(8_Ki);
+        Alloc a = Alloc::allocMMap(page_sz), b = Alloc::allocMMap(2 * page_sz);
         testSwap(a, b);
     }
     {
-        Alloc a = Alloc::allocAlignedHeap(4_Ki, 1_Ki), b = Alloc::allocAlignedHeap(8_Ki, 1_Ki);
+        Alloc a = Alloc::allocAlignedHeap(page_sz, 1_Ki), b = Alloc::allocAlignedHeap(2 * page_sz, 1_Ki);
         testSwap(a, b);
     }
     {
-        Alloc a = Alloc::allocHeap(4_Ki);
-        Alloc b = Alloc::allocMMap(8_Ki);
+        Alloc a = Alloc::allocHeap(page_sz);
+        Alloc b = Alloc::allocMMap(2 * page_sz);
         testSwap(a, b);
     }
     {
@@ -228,7 +235,7 @@ TEST("mmap alloc can be extended if room") {
     Alloc buf = Alloc::allocMMap(100);
 
     TEST_DO(ensureRoomForExtension(buf, reserved));
-    TEST_DO(verifyExtension(buf, 4_Ki, 4_Ki*2));
+    TEST_DO(verifyExtension(buf, page_sz, page_sz * 2));
 }
 
 TEST("mmap alloc can not be extended if no room") {
@@ -236,7 +243,7 @@ TEST("mmap alloc can not be extended if no room") {
     Alloc reserved = Alloc::allocMMap(100);
     Alloc buf = Alloc::allocMMap(100);
 
-    TEST_DO(verifyNoExtensionWhenNoRoom(buf, reserved, 4_Ki));
+    TEST_DO(verifyNoExtensionWhenNoRoom(buf, reserved, page_sz));
 }
 #endif
 #endif
@@ -256,16 +263,16 @@ TEST("heap alloc cannot be shrunk to zero") {
 }
 
 TEST("mmap alloc can be shrinked") {
-    Alloc buf = Alloc::allocMMap(4097);
+    Alloc buf = Alloc::allocMMap(page_sz + 1);
     void * oldPtr = buf.get();
-    EXPECT_EQUAL(8_Ki, buf.size());
-    EXPECT_TRUE(buf.resize_inplace(4095));
+    EXPECT_EQUAL(2 * page_sz, buf.size());
+    EXPECT_TRUE(buf.resize_inplace(page_sz - 1));
     EXPECT_EQUAL(oldPtr, buf.get());
-    EXPECT_EQUAL(4_Ki, buf.size());
+    EXPECT_EQUAL(page_sz, buf.size());
 }
 
 TEST("mmap alloc cannot be shrunk to zero") {
-    Alloc buf = Alloc::allocMMap(4097);
+    Alloc buf = Alloc::allocMMap(page_sz + 1);
     EXPECT_FALSE(buf.resize_inplace(0));
 }
 
diff --git a/vespalib/src/tests/util/rcuvector/rcuvector_test.cpp b/vespalib/src/tests/util/rcuvector/rcuvector_test.cpp
index 14802a60ff1..e36d7da7b6a 100644
--- a/vespalib/src/tests/util/rcuvector/rcuvector_test.cpp
+++ b/vespalib/src/tests/util/rcuvector/rcuvector_test.cpp
@@ -3,6 +3,7 @@
 #include <vespa/vespalib/testkit/testapp.h>
 #include <vespa/vespalib/test/memory_allocator_observer.h>
 #include <vespa/vespalib/util/rcuvector.h>
+#include <vespa/vespalib/util/round_up_to_page_size.h>
 #include <vespa/vespalib/util/size_literals.h>
 
 using namespace vespalib;
@@ -240,15 +241,20 @@ TEST("test shrink() with buffer copying")
 
 struct ShrinkFixture {
     GenerationHolder g;
+    size_t initial_capacity;
+    size_t initial_size;
     RcuVectorBase<int> vec;
     int *oldPtr;
-    ShrinkFixture() : g(), vec(4_Ki, 50, 0, g, alloc::Alloc::allocMMap()), oldPtr()
+    ShrinkFixture() : g(),
+                      initial_capacity(4 * page_ints()),
+                      initial_size(initial_capacity / 1024 * 1000),
+                      vec(initial_capacity, 50, 0, g, alloc::Alloc::allocMMap()), oldPtr()
     {
-        for (size_t i = 0; i < 4000; ++i) {
+        for (size_t i = 0; i < initial_size; ++i) {
             vec.push_back(7);
         }
-        EXPECT_EQUAL(4000u, vec.size());
-        EXPECT_EQUAL(4_Ki, vec.capacity());
+        EXPECT_EQUAL(initial_size, vec.size());
+        EXPECT_EQUAL(initial_capacity, vec.capacity());
         assertEmptyHoldList();
         oldPtr = &vec[0];
     }
@@ -258,22 +264,24 @@ struct ShrinkFixture {
     void assertEmptyHoldList() {
         EXPECT_EQUAL(0u, g.getHeldBytes());
     }
+    static size_t page_ints() { return round_up_to_page_size(1) / sizeof(int); }
 };
 
 TEST_F("require that shrink() does not increase allocated memory", ShrinkFixture)
 {
-    f.vec.shrink(2732);
-    EXPECT_EQUAL(2732u, f.vec.size());
-    EXPECT_EQUAL(4_Ki, f.vec.capacity());
+    size_t shrink_size = f.initial_capacity * 2 / 3 + 2;
+    f.vec.shrink(shrink_size);
+    EXPECT_EQUAL(shrink_size, f.vec.size());
+    EXPECT_EQUAL(f.initial_capacity, f.vec.capacity());
     TEST_DO(f.assertOldEqualNewBuffer());
     TEST_DO(f.assertEmptyHoldList());
 }
 
 TEST_F("require that shrink() can shrink mmap allocation", ShrinkFixture)
 {
-    f.vec.shrink(2048);
-    EXPECT_EQUAL(2048u, f.vec.size());
-    EXPECT_EQUAL(3072u, f.vec.capacity());
+    f.vec.shrink(2 * f.page_ints());
+    EXPECT_EQUAL(2 * f.page_ints(), f.vec.size());
+    EXPECT_EQUAL(3 * f.page_ints(), f.vec.capacity());
     TEST_DO(f.assertOldEqualNewBuffer());
     TEST_DO(f.assertEmptyHoldList());
 }