Fix ThreadCachedArena zombies_ alignment mismatch

Summary:
Fixing the crash seen during shutdown: P2279276864

ThreadCachedArena stores maxAlign_ and passes it to per-thread arenas via allocateThreadLocalArena(), but the zombies_ arena was constructed with only minBlockSize — using the default maxAlign. When maxAlign_ != kDefaultMaxAlign, the two arenas have different blockGoodAllocSize() values, and Arena::merge asserts on thread exit during zombify().

Fix: pass maxAlign to the zombies_ arena constructor so it matches per-thread arenas.

This is a latent bug that surfaces whenever ThreadCachedArena is constructed with non-default alignment, e.g. from Unicorn's NodeArena.

Reviewed By: luciang

Differential Revision: D101491707

fbshipit-source-id: 90691bf83ec2f79e889bf8ac7ddbea482041fdc6

Author: agrawaldevesh

folly/memory/ThreadCachedArena.cpp

@@ -23,7 +23,7 @@ namespace folly {
 ThreadCachedArena::ThreadCachedArena(size_t minBlockSize, size_t maxAlign)
     : minBlockSize_(minBlockSize),
       maxAlign_(maxAlign),
-      zombies_(std::in_place, minBlockSize) {}
+      zombies_(std::in_place, minBlockSize, SysArena::kNoSizeLimit, maxAlign) {}
 
 SysArena* ThreadCachedArena::allocateThreadLocalArena() {
   auto arena = new SysArena(minBlockSize_, SysArena::kNoSizeLimit, maxAlign_);

folly/memory/test/ThreadCachedArenaTest.cpp

@@ -151,6 +151,35 @@ TEST(ThreadCachedArena, MultiThreaded) {
   mainTester.verify();
 }
 
+TEST(ThreadCachedArena, MultiThreadedCustomAlign) {
+  static const size_t requestedBlockSize = 64;
+  // Use a larger-than-default alignment to exercise the maxAlign path.
+  // This triggers Arena::merge between zombies_ (constructed at arena init)
+  // and per-thread arenas (constructed on first allocation per thread).
+  static const size_t customAlign = 64;
+  ThreadCachedArena arena(requestedBlockSize, customAlign);
+  ArenaTester mainTester(arena);
+
+  static const size_t numThreads = 20;
+  for (size_t i = 0; i < 2; i++) {
+    std::vector<std::thread> threads;
+    threads.reserve(numThreads);
+    for (size_t j = 0; j < numThreads; j++) {
+      threads.emplace_back([&arena, &mainTester]() {
+        ArenaTester tester(arena);
+        tester.allocate(500, 1 << 10);
+        tester.verify();
+        mainTester.merge(std::move(tester));
+      });
+    }
+    for (auto& t : threads) {
+      t.join();
+    }
+  }
+
+  mainTester.verify();
+}
+
 TEST(ThreadCachedArena, ThreadCachedArenaAllocator) {
   using Map = std::unordered_map<
       int,