[libc-commits] [libc] [libc] Make hash_test hermetic (PR #212428)

[via libc-commits]

llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-libc

Author: Pavel Labath (labath)

<details>
<summary>Changes</summary>

Aligned allocation is now supported, but the test burns through our 1MB never-freeing bump pointer allocation buffer. I tweak the test to reuse the buffer between loop iterations, reducing its memory usage by about 300x :P.

---
Full diff: https://github.com/llvm/llvm-project/pull/212428.diff


2 Files Affected:

- (modified) libc/test/src/__support/CMakeLists.txt (-2) 
- (modified) libc/test/src/__support/hash_test.cpp (+9-13) 


``````````diff
diff --git a/libc/test/src/__support/CMakeLists.txt b/libc/test/src/__support/CMakeLists.txt
index 4e6784691d5e5..d6d06fafd7d27 100644
--- a/libc/test/src/__support/CMakeLists.txt
+++ b/libc/test/src/__support/CMakeLists.txt
@@ -246,8 +246,6 @@ add_libc_test(
     libc.src.string.memset
   COMPILE_OPTIONS
     ${libc_opt_high_flag}
-  UNIT_TEST_ONLY
-    # Aligned Allocation is not supported in hermetic builds.
 )
 
 add_libc_test(
diff --git a/libc/test/src/__support/hash_test.cpp b/libc/test/src/__support/hash_test.cpp
index 417a43a58b340..2389611d41b2d 100644
--- a/libc/test/src/__support/hash_test.cpp
+++ b/libc/test/src/__support/hash_test.cpp
@@ -16,17 +16,14 @@
 
 template <class T> struct AlignedMemory {
   T *data;
-  size_t offset;
   std::align_val_t alignment;
-  AlignedMemory(size_t size, size_t alignment, size_t offset)
-      : offset(offset), alignment{alignment} {
+  AlignedMemory(size_t size, size_t alignment) : alignment{alignment} {
     size_t sz = size * sizeof(T);
     size_t aligned = sz + ((-sz) & (alignment - 1)) + alignment;
     LIBC_NAMESPACE::AllocChecker ac;
     data = static_cast<T *>(operator new(aligned, this->alignment, ac));
-    data += offset % alignment;
   }
-  ~AlignedMemory() { operator delete(data - offset, alignment); }
+  ~AlignedMemory() { operator delete(data, alignment); }
 };
 
 size_t sizes[] = {0, 1, 23, 59, 1024, 5261};
@@ -35,20 +32,19 @@ uint8_t values[] = {0, 1, 23, 59, 102, 255};
 // Hash value should not change with different alignments.
 TEST(LlvmLibcHashTest, SanityCheck) {
   for (size_t sz : sizes) {
+    size_t alloc_sz = sz + 64;
+    AlignedMemory<char> mem(alloc_sz, 64);
     for (uint8_t val : values) {
+      LIBC_NAMESPACE::memset(mem.data, val, alloc_sz);
       uint64_t hash;
       {
-        AlignedMemory<char> mem(sz, 64, 0);
-        LIBC_NAMESPACE::memset(mem.data, val, sz);
         LIBC_NAMESPACE::internal::HashState state{0x1234567890abcdef};
         state.update(mem.data, sz);
         hash = state.finish();
       }
       for (size_t offset = 1; offset < 64; ++offset) {
-        AlignedMemory<char> mem(sz, 64, offset);
-        LIBC_NAMESPACE::memset(mem.data, val, sz);
         LIBC_NAMESPACE::internal::HashState state{0x1234567890abcdef};
-        state.update(mem.data, sz);
+        state.update(mem.data + offset, sz);
         ASSERT_EQ(hash, state.finish());
       }
     }
@@ -70,7 +66,7 @@ TEST(LlvmLibcHashTest, Avalanche) {
   for (size_t sz : sizes) {
     for (uint8_t val : values) {
       uint64_t hash;
-      AlignedMemory<char> mem(sz, 64, 0);
+      AlignedMemory<char> mem(sz, 64);
       LIBC_NAMESPACE::memset(mem.data, val, sz);
       {
         LIBC_NAMESPACE::internal::HashState state{0xabcdef1234567890};
@@ -99,7 +95,7 @@ TEST(LlvmLibcHashTest, Avalanche) {
 TEST(LlvmLibcHashTest, UniformLSB) {
   LIBC_NAMESPACE::srand(0xffffffff);
   for (size_t sz : sizes) {
-    AlignedMemory<size_t> counters(sz, sizeof(size_t), 0);
+    AlignedMemory<size_t> counters(sz, sizeof(size_t));
     LIBC_NAMESPACE::memset(counters.data, 0, sz * sizeof(size_t));
     for (size_t i = 0; i < 200 * sz; ++i) {
       int randomness[8] = {LIBC_NAMESPACE::rand(), LIBC_NAMESPACE::rand(),
@@ -126,7 +122,7 @@ TEST(LlvmLibcHashTest, UniformLSB) {
 // the hash table.
 TEST(LlvmLibcHashTest, UniformMSB) {
   size_t sz = 1 << 7;
-  AlignedMemory<size_t> counters(sz, sizeof(size_t), 0);
+  AlignedMemory<size_t> counters(sz, sizeof(size_t));
   LIBC_NAMESPACE::memset(counters.data, 0, sz * sizeof(size_t));
   for (size_t i = 0; i < 200 * sz; ++i) {
     LIBC_NAMESPACE::internal::HashState state{0xa1b2c3d4e5f6a7b8};

``````````

</details>


https://github.com/llvm/llvm-project/pull/212428