Enhance SimpleAllocator with size validation

Summary:
- Added size validation to `SimpleAllocator` constructor to ensure minimum allocation size of `sizeof(void*)`
- Updated documentation in `CacheLocality.h` to clarify that allocations smaller than `sizeof(void*)` are rounded up
- Added test case `CoreAllocator.MinimumAllocationSize` to verify correct behavior for small allocations

X-link: facebook/folly#2558

Reviewed By: dmm-fb

Differential Revision: D93888606

Pulled By: yfeldblum

fbshipit-source-id: c67d1dd48f05f9e0319d9be29c43b40e71fac5af

Author: wangqin0

third-party/folly/src/folly/concurrency/CacheLocality.cpp

@@ -582,7 +582,18 @@ class SimpleAllocator {
   // To support array aggregate initialization without an implicit constructor.
   struct Ctor {};
 
-  SimpleAllocator(Ctor, size_t sz) : sz_(sz) {}
+  SimpleAllocator(Ctor, size_t sz) : sz_(sz) {
+    static_assert(
+        sizeof(void*) <= 64,
+        "SimpleAllocator assumes sizeof(void*) fits in maximum size class");
+    if (sz_ < sizeof(void*)) {
+      folly::throw_exception<std::invalid_argument>(fmt::format(
+          "SimpleAllocator size {} is too small (minimum: {})",
+          sz_,
+          sizeof(void*)));
+    }
+  }
+
   ~SimpleAllocator() {
     std::lock_guard g(m_);
     for (auto& block : blocks_) {

third-party/folly/src/folly/concurrency/CacheLocality.h

@@ -424,6 +424,9 @@ class LLCAccessSpreader {
  * AccessSpreader can allocate memory in smaller-than cacheline increments, and
  * be assured that it won't cause more false sharing than it otherwise would.
  *
+ * Allocations smaller than sizeof(void*) (typically 8 bytes) are automatically
+ * rounded up to ensure correct internal bookkeeping.
+ *
  * Note that allocation and deallocation takes a per-size-class lock.
  *
  * Memory allocated with coreMalloc() must be freed with coreFree().

third-party/folly/src/folly/concurrency/test/CacheLocalityTest.cpp

@@ -1237,3 +1237,26 @@ TEST(CoreAllocator, Basic) {
   }
   mems.clear();
 }
+
+TEST(CoreAllocator, MinimumAllocationSize) {
+  // coreMalloc should handle sizes smaller than sizeof(void*) by rounding up
+  constexpr size_t kNumStripes = 32;
+
+  // Test that small allocations (< 8 bytes) work correctly
+  // The Allocator class should round these up to 8 bytes
+  auto res1 = coreMalloc(1, kNumStripes, 0);
+  EXPECT_NE(nullptr, res1);
+  memset(res1, 0xFF, 1); // Should not crash
+  coreFree(res1);
+
+  auto res4 = coreMalloc(4, kNumStripes, 0);
+  EXPECT_NE(nullptr, res4);
+  memset(res4, 0xFF, 4); // Should not crash
+  coreFree(res4);
+
+  // Verify that 8-byte allocation works (minimum valid size)
+  auto res8 = coreMalloc(8, kNumStripes, 0);
+  EXPECT_NE(nullptr, res8);
+  memset(res8, 0xFF, 8);
+  coreFree(res8);
+}