[Concurrency] Adjust the task allocator slab size to 984 bytes.

A slab capacity of 1000 bytes was overflowing the 1024 byte malloc bucket when adding in the slab header. Adjust it down to 984 bytes. Calculate this by subtracting the slab header size from 1024, plus a little slop for malloc stack logging, to ensure we don't overflow the bucket again.

rdar://87612288

Author: mikeash

stdlib/public/Concurrency/TaskPrivate.h

@@ -284,8 +284,11 @@ class alignas(sizeof(void*) * 2) ActiveTaskStatus {
   }
 };
 
-/// The size of an allocator slab.
-static constexpr size_t SlabCapacity = 1000;
+/// The size of an allocator slab. We want the full allocation to fit into a
+/// 1024-byte malloc quantum. We subtract off the slab header size, plus a
+/// little extra to stay within our limits even when there's overhead from
+/// malloc stack logging.
+static constexpr size_t SlabCapacity = 1024 - StackAllocator<0, nullptr>::slabHeaderSize() - 8;
 extern Metadata TaskAllocatorSlabMetadata;
 
 using TaskAllocator = StackAllocator<SlabCapacity, &TaskAllocatorSlabMetadata>;

stdlib/public/runtime/StackAllocator.h

@@ -109,8 +109,8 @@ class StackAllocator {
     }
 
     /// The size of the slab header.
-    static size_t headerSize() {
-      return llvm::alignTo(sizeof(Slab), llvm::Align(alignment));
+    static constexpr size_t headerSize() {
+      return (sizeof(Slab) + alignment - 1) & ~(alignment - 1);
     }
 
     /// Return \p size with the added overhead of the slab header.
@@ -276,6 +276,10 @@ class StackAllocator {
     assert(getNumAllocatedSlabs() == 0);
   }
 
+  static constexpr size_t slabHeaderSize() {
+    return Slab::headerSize();
+  }
+
   /// Allocate a memory buffer of \p size.
   void *alloc(size_t size) {
     if (guardAllocations)