PartitionAlloc: Use Options struct to initialize partitions

This is needed to simplify initialization interface, especially when
PCScan is added.

Bug: 11297512
Change-Id: I674f5b2f237bfb08e4dcbfd83e1fa3854acf9886
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2421676
Commit-Queue: Anton Bikineev <bikineev@chromium.org>
Reviewed-by: Bartek Nowierski <bartekn@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Benoit L <lizeb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#810374}

base/allocator/allocator_shim_default_dispatch_to_partition_alloc.cc

@@ -76,7 +76,8 @@ base::ThreadSafePartitionRoot& Allocator() {
   }
 
   auto* new_root = new (g_allocator_buffer) base::ThreadSafePartitionRoot(
-      false /* enforce_alignment */, true /* enable_thread_cache */);
+      {base::PartitionOptions::Alignment::kRegular,
+       base::PartitionOptions::ThreadCache::kEnabled});
   g_root_.store(new_root, std::memory_order_release);
 
   // Semantically equivalent to base::Lock::Release().
@@ -105,8 +106,9 @@ void* PartitionCalloc(const AllocatorDispatch*,
 
 base::ThreadSafePartitionRoot* AlignedAllocator() {
   // Since the general-purpose allocator uses the thread cache, this one cannot.
-  static base::NoDestructor<base::ThreadSafePartitionRoot> aligned_allocator{
-      true /* enforce_alignment */, false /* enable_thread_cache */};
+  static base::NoDestructor<base::ThreadSafePartitionRoot> aligned_allocator(
+      base::PartitionOptions{base::PartitionOptions::Alignment::kAlignedAlloc,
+                             base::PartitionOptions::ThreadCache::kDisabled});
   return aligned_allocator.get();
 }
 

base/allocator/partition_allocator/partition_alloc.cc

@@ -258,8 +258,7 @@ void InitBucketIndexLookup(PartitionRoot<thread_safe>* root) {
 }
 
 template <bool thread_safe>
-void PartitionRoot<thread_safe>::Init(bool enforce_alignment,
-                                      bool enable_thread_cache) {
+void PartitionRoot<thread_safe>::Init(PartitionOptions opts) {
   ScopedGuard guard{lock_};
   if (initialized)
     return;
@@ -272,12 +271,13 @@ void PartitionRoot<thread_safe>::Init(bool enforce_alignment,
 
   // If alignment needs to be enforced, disallow adding cookies and/or tags at
   // the beginning of the slot.
-  allow_extras = !enforce_alignment;
+  allow_extras = (opts.alignment != PartitionOptions::Alignment::kAlignedAlloc);
 #if !defined(OS_POSIX)
   // TLS in ThreadCache not supported on other OSes.
   with_thread_cache = false;
 #else
-  with_thread_cache = enable_thread_cache;
+  with_thread_cache =
+      (opts.thread_cache == PartitionOptions::ThreadCache::kEnabled);
 
   if (with_thread_cache)
     internal::ThreadCache::Init(this);
@@ -874,29 +874,21 @@ PartitionAllocator<thread_safe>::~PartitionAllocator() {
 }
 
 template <bool thread_safe>
-void PartitionAllocator<thread_safe>::init(
-    PartitionAllocatorAlignment alignment,
-    bool with_thread_cache) {
+void PartitionAllocator<thread_safe>::init(PartitionOptions opts) {
 #if BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
-  PA_CHECK(!with_thread_cache)
+  PA_CHECK(opts.thread_cache == PartitionOptions::ThreadCache::kDisabled)
       << "Cannot use a thread cache when PartitionAlloc is malloc().";
 #endif
-  partition_root_.Init(
-      alignment ==
-          PartitionAllocatorAlignment::kAlignedAlloc /* enforce_alignment */,
-      with_thread_cache);
+  partition_root_.Init(opts);
   PartitionAllocMemoryReclaimer::Instance()->RegisterPartition(
       &partition_root_);
 }
 
 template PartitionAllocator<internal::ThreadSafe>::~PartitionAllocator();
-template void PartitionAllocator<internal::ThreadSafe>::init(
-    PartitionAllocatorAlignment alignment,
-    bool with_thread_cache);
+template void PartitionAllocator<internal::ThreadSafe>::init(PartitionOptions);
 template PartitionAllocator<internal::NotThreadSafe>::~PartitionAllocator();
 template void PartitionAllocator<internal::NotThreadSafe>::init(
-    PartitionAllocatorAlignment alignment,
-    bool with_thread_cache);
+    PartitionOptions);
 
 #if DCHECK_IS_ON()
 void DCheckIfManagedByPartitionAllocNormalBuckets(const void* ptr) {

base/allocator/partition_allocator/partition_alloc.h

@@ -367,6 +367,31 @@ constexpr size_t kOrderSubIndexMask[BITS_PER_SIZE_T + 1] = {
 
 }  // namespace
 
+// Options struct used to configure PartitionRoot and PartitionAllocator.
+struct PartitionOptions {
+  enum class Alignment {
+    // By default all allocations will be aligned to 8B (16B if
+    // BUILDFLAG_INTERNAL_USE_PARTITION_ALLOC_AS_MALLOC is true).
+    kRegular,
+
+    // In addition to the above alignment enforcement, this option allows using
+    // AlignedAlloc() which can align at a larger boundary.  This option comes
+    // at a cost of disallowing cookies on Debug builds and tags/ref-counts for
+    // CheckedPtr. It also causes all allocations to go outside of GigaCage, so
+    // that CheckedPtr can easily tell if a pointer comes with a tag/ref-count
+    // or not.
+    kAlignedAlloc,
+  };
+
+  enum class ThreadCache {
+    kDisabled,
+    kEnabled,
+  };
+
+  Alignment alignment = Alignment::kRegular;
+  ThreadCache thread_cache = ThreadCache::kDisabled;
+};
+
 // Never instantiate a PartitionRoot directly, instead use
 // PartitionAllocator.
 template <bool thread_safe>
@@ -429,9 +454,7 @@ struct BASE_EXPORT PartitionRoot {
   Bucket sentinel_bucket;
 
   PartitionRoot() = default;
-  PartitionRoot(bool enable_tag_pointers, bool enable_thread_cache) {
-    Init(enable_tag_pointers, enable_thread_cache);
-  }
+  explicit PartitionRoot(PartitionOptions opts) { Init(opts); }
   ~PartitionRoot();
 
   // Public API
@@ -444,7 +467,7 @@ struct BASE_EXPORT PartitionRoot {
   //
   // Moving it a layer lower couples PartitionRoot and PartitionBucket, but
   // preserves the layering of the includes.
-  void Init(bool enforce_alignment, bool enable_thread_cache);
+  void Init(PartitionOptions);
 
   ALWAYS_INLINE static bool IsValidPage(Page* page);
   ALWAYS_INLINE static PartitionRoot* FromPage(Page* page);
@@ -1144,28 +1167,13 @@ ALWAYS_INLINE size_t PartitionRoot<thread_safe>::ActualSize(size_t size) {
 #endif
 }
 
-enum class PartitionAllocatorAlignment {
-  // By default all allocations will be aligned to 8B (16B if
-  // BUILDFLAG_INTERNAL_USE_PARTITION_ALLOC_AS_MALLOC is true).
-  kRegular,
-
-  // In addition to the above alignment enforcement, this option allows using
-  // AlignedAlloc() which can align at a larger boundary.
-  // This option comes at a cost of disallowing cookies on Debug builds and tags
-  // for CheckedPtr. It also causes all allocations to go outside of GigaCage,
-  // so that CheckedPtr can easily tell if a pointer comes with a tag or not.
-  kAlignedAlloc,
-};
-
 namespace internal {
 template <bool thread_safe>
 struct BASE_EXPORT PartitionAllocator {
   PartitionAllocator() = default;
   ~PartitionAllocator();
 
-  void init(PartitionAllocatorAlignment alignment =
-                PartitionAllocatorAlignment::kRegular,
-            bool with_thread_cache = false);
+  void init(PartitionOptions = {});
   ALWAYS_INLINE PartitionRoot<thread_safe>* root() { return &partition_root_; }
 
  private:

base/allocator/partition_allocator/partition_alloc_perftest.cc

@@ -84,7 +84,8 @@ class PartitionAllocator : public Allocator {
   void Free(void* data) override { ThreadSafePartitionRoot::FreeNoHooks(data); }
 
  private:
-  ThreadSafePartitionRoot alloc_{false, false};
+  ThreadSafePartitionRoot alloc_{{PartitionOptions::Alignment::kRegular,
+                                  PartitionOptions::ThreadCache::kDisabled}};
 };
 
 class TestLoopThread : public PlatformThread::Delegate {

base/allocator/partition_allocator/partition_alloc_unittest.cc

@@ -156,8 +156,8 @@ class PartitionAllocTest : public testing::Test {
   void SetUp() override {
     scoped_feature_list.InitWithFeatures({kPartitionAllocGigaCage}, {});
     PartitionAllocGlobalInit(HandleOOM);
-    allocator.init(PartitionAllocatorAlignment::kRegular);
-    aligned_allocator.init(PartitionAllocatorAlignment::kAlignedAlloc);
+    allocator.init({PartitionOptions::Alignment::kRegular});
+    aligned_allocator.init({PartitionOptions::Alignment::kAlignedAlloc});
     test_bucket_index_ = SizeToIndex(kRealAllocSize);
   }
 

base/allocator/partition_allocator/thread_cache_unittest.cc

@@ -59,7 +59,9 @@ class DeltaCounter {
 // PartitionRoot has to outlive it.
 //
 // Forbid extras, since they make finding out which bucket is used harder.
-NoDestructor<ThreadSafePartitionRoot> g_root{true, true};
+NoDestructor<ThreadSafePartitionRoot> g_root{
+    PartitionOptions{PartitionOptions::Alignment::kAlignedAlloc,
+                     PartitionOptions::ThreadCache::kEnabled}};
 
 size_t FillThreadCacheAndReturnIndex(size_t size, size_t count = 1) {
   uint16_t bucket_index = PartitionRoot<ThreadSafe>::SizeToBucketIndex(size);
@@ -157,7 +159,8 @@ TEST_F(ThreadCacheTest, Purge) {
 
 TEST_F(ThreadCacheTest, NoCrossPartitionCache) {
   const size_t kTestSize = 12;
-  ThreadSafePartitionRoot root{true, false};
+  ThreadSafePartitionRoot root{{PartitionOptions::Alignment::kAlignedAlloc,
+                                PartitionOptions::ThreadCache::kDisabled}};
 
   size_t bucket_index = FillThreadCacheAndReturnIndex(kTestSize);
   void* ptr = root.Alloc(kTestSize, "");

third_party/blink/renderer/platform/wtf/allocator/partitions.cc

@@ -75,8 +75,8 @@ bool Partitions::InitializeOnce() {
   // - BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC): Only one thread cache at a time
   //   is supported, in this case it is already claimed by malloc().
 #if DCHECK_IS_ON() && !BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
-  fast_malloc_allocator.init(base::PartitionAllocatorAlignment::kRegular,
-                             true /* with_thread_cache */);
+  fast_malloc_allocator.init({base::PartitionOptions::Alignment::kRegular,
+                              base::PartitionOptions::ThreadCache::kEnabled});
 #else
   fast_malloc_allocator.init();
 #endif