[PA] Make AddressPoolManager constructor constexpr.

Bug: 1151236

Change-Id: I5d06b44aae97eb62f66969a4cedea445a8bbed06
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3642766
Reviewed-by: Yuki Shiino <yukishiino@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Bartek Nowierski <bartekn@chromium.org>
Owners-Override: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Takashi Sakamoto <tasak@google.com>
Cr-Commit-Position: refs/heads/main@{#1003643}

base/allocator/partition_allocator/DEPS

@@ -12,7 +12,6 @@ include_rules = [
     "+base/dcheck_is_on.h",
     "+base/debug/proc_maps_linux.h",
     "+base/immediate_crash.h",
-    "+base/lazy_instance.h",
     "+base/logging_buildflags.h",
     "+base/mac/foundation_util.h",
     "+base/mac/mac_util.h",

base/allocator/partition_allocator/address_pool_manager.cc

@@ -17,7 +17,6 @@
 #include "base/allocator/partition_allocator/partition_alloc_constants.h"
 #include "base/allocator/partition_allocator/partition_alloc_notreached.h"
 #include "base/allocator/partition_allocator/reservation_offset_table.h"
-#include "base/lazy_instance.h"
 #include "build/build_config.h"
 
 #if BUILDFLAG(IS_APPLE)
@@ -26,16 +25,11 @@
 
 namespace partition_alloc::internal {
 
-namespace {
-
-base::LazyInstance<AddressPoolManager>::Leaky g_address_pool_manager =
-    LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
+AddressPoolManager AddressPoolManager::singleton_;
 
 // static
-AddressPoolManager* AddressPoolManager::GetInstance() {
-  return g_address_pool_manager.Pointer();
+AddressPoolManager& AddressPoolManager::GetInstance() {
+  return singleton_;
 }
 
 #if defined(PA_HAS_64_BITS_POINTERS)
@@ -283,9 +277,6 @@ void AddressPoolManager::Pool::GetStats(PoolStats* stats) {
   stats->largest_available_reservation = largest_run;
 }
 
-AddressPoolManager::Pool::Pool() = default;
-AddressPoolManager::Pool::~Pool() = default;
-
 void AddressPoolManager::GetPoolStats(const pool_handle handle,
                                       PoolStats* stats) {
   Pool* pool = GetPool(handle);
@@ -546,7 +537,4 @@ void AddressPoolManager::DumpStats(AddressSpaceStatsDumper* dumper) {
   }
 }
 
-AddressPoolManager::AddressPoolManager() = default;
-AddressPoolManager::~AddressPoolManager() = default;
-
 }  // namespace partition_alloc::internal

base/allocator/partition_allocator/address_pool_manager.h

@@ -54,7 +54,7 @@ namespace partition_alloc::internal {
 // All PartitionAlloc allocations must be in either of the pools.
 class BASE_EXPORT AddressPoolManager {
  public:
-  static AddressPoolManager* GetInstance();
+  static AddressPoolManager& GetInstance();
 
   AddressPoolManager(const AddressPoolManager&) = delete;
   AddressPoolManager& operator=(const AddressPoolManager&) = delete;
@@ -100,8 +100,8 @@ class BASE_EXPORT AddressPoolManager {
  private:
   friend class AddressPoolManagerForTesting;
 
-  AddressPoolManager();
-  ~AddressPoolManager();
+  constexpr AddressPoolManager() = default;
+  ~AddressPoolManager() = default;
 
   // Populates `stats` if applicable.
   // Returns whether `stats` was populated. (They might not be, e.g.
@@ -111,8 +111,11 @@ class BASE_EXPORT AddressPoolManager {
 #if defined(PA_HAS_64_BITS_POINTERS)
   class Pool {
    public:
-    Pool();
-    ~Pool();
+    constexpr Pool() = default;
+    ~Pool() = default;
+
+    Pool(const Pool&) = delete;
+    Pool& operator=(const Pool&) = delete;
 
     void Initialize(uintptr_t ptr, size_t length);
     bool IsInitialized();
@@ -139,7 +142,7 @@ class BASE_EXPORT AddressPoolManager {
     // 1s. This is a best-effort hint in the sense that there still may be lots
     // of 1s after this index, but at least we know there is no point in
     // starting the search before it.
-    size_t bit_hint_ GUARDED_BY(lock_);
+    size_t bit_hint_ GUARDED_BY(lock_) = 0;
 
     size_t total_bits_ = 0;
     uintptr_t address_begin_ = 0;
@@ -161,6 +164,8 @@ class BASE_EXPORT AddressPoolManager {
 
 #endif  // defined(PA_HAS_64_BITS_POINTERS)
 
+  static AddressPoolManager singleton_;
+
   friend struct base::LazyInstanceTraitsBase<AddressPoolManager>;
 };
 

base/allocator/partition_allocator/address_pool_manager_unittest.cc

@@ -274,13 +274,13 @@ TEST(PartitionAllocAddressPoolManagerTest, IsManagedByRegularPool) {
   static const size_t kNumPages[kAllocCount] = {1, 4, 7, 8, 13, 16, 31, 60};
   uintptr_t addrs[kAllocCount];
   for (size_t i = 0; i < kAllocCount; ++i) {
-    addrs[i] = AddressPoolManager::GetInstance()->Reserve(
+    addrs[i] = AddressPoolManager::GetInstance().Reserve(
         GetRegularPool(), 0,
         AddressPoolManagerBitmap::kBytesPer1BitOfRegularPoolBitmap *
             kNumPages[i]);
     EXPECT_TRUE(addrs[i]);
     EXPECT_TRUE(!(addrs[i] & kSuperPageOffsetMask));
-    AddressPoolManager::GetInstance()->MarkUsed(
+    AddressPoolManager::GetInstance().MarkUsed(
         GetRegularPool(), addrs[i],
         AddressPoolManagerBitmap::kBytesPer1BitOfRegularPoolBitmap *
             kNumPages[i]);
@@ -304,11 +304,11 @@ TEST(PartitionAllocAddressPoolManagerTest, IsManagedByRegularPool) {
     }
   }
   for (size_t i = 0; i < kAllocCount; ++i) {
-    AddressPoolManager::GetInstance()->MarkUnused(
+    AddressPoolManager::GetInstance().MarkUnused(
         GetRegularPool(), addrs[i],
         AddressPoolManagerBitmap::kBytesPer1BitOfRegularPoolBitmap *
             kNumPages[i]);
-    AddressPoolManager::GetInstance()->UnreserveAndDecommit(
+    AddressPoolManager::GetInstance().UnreserveAndDecommit(
         GetRegularPool(), addrs[i],
         AddressPoolManagerBitmap::kBytesPer1BitOfRegularPoolBitmap *
             kNumPages[i]);
@@ -324,12 +324,12 @@ TEST(PartitionAllocAddressPoolManagerTest, IsManagedByBRPPool) {
   static const size_t kNumPages[kAllocCount] = {1, 3, 7, 11};
   uintptr_t addrs[kAllocCount];
   for (size_t i = 0; i < kAllocCount; ++i) {
-    addrs[i] = AddressPoolManager::GetInstance()->Reserve(
+    addrs[i] = AddressPoolManager::GetInstance().Reserve(
         GetBRPPool(), 0, kSuperPageSize * kNumPages[i]);
     EXPECT_TRUE(addrs[i]);
     EXPECT_TRUE(!(addrs[i] & kSuperPageOffsetMask));
-    AddressPoolManager::GetInstance()->MarkUsed(GetBRPPool(), addrs[i],
-                                                kSuperPageSize * kNumPages[i]);
+    AddressPoolManager::GetInstance().MarkUsed(GetBRPPool(), addrs[i],
+                                               kSuperPageSize * kNumPages[i]);
   }
 
   constexpr size_t first_guard_size =
@@ -357,9 +357,9 @@ TEST(PartitionAllocAddressPoolManagerTest, IsManagedByBRPPool) {
     }
   }
   for (size_t i = 0; i < kAllocCount; ++i) {
-    AddressPoolManager::GetInstance()->MarkUnused(
-        GetBRPPool(), addrs[i], kSuperPageSize * kNumPages[i]);
-    AddressPoolManager::GetInstance()->UnreserveAndDecommit(
+    AddressPoolManager::GetInstance().MarkUnused(GetBRPPool(), addrs[i],
+                                                 kSuperPageSize * kNumPages[i]);
+    AddressPoolManager::GetInstance().UnreserveAndDecommit(
         GetBRPPool(), addrs[i], kSuperPageSize * kNumPages[i]);
     EXPECT_FALSE(AddressPoolManager::IsManagedByRegularPool(addrs[i]));
     EXPECT_FALSE(AddressPoolManager::IsManagedByBRPPool(addrs[i]));
@@ -369,24 +369,24 @@ TEST(PartitionAllocAddressPoolManagerTest, IsManagedByBRPPool) {
 
 TEST(PartitionAllocAddressPoolManagerTest, RegularPoolUsageChanges) {
   AddressSpaceStatsDumperForTesting dumper{};
-  AddressPoolManager::GetInstance()->DumpStats(&dumper);
+  AddressPoolManager::GetInstance().DumpStats(&dumper);
   const size_t usage_before = dumper.regular_pool_usage_;
 
-  const uintptr_t address = AddressPoolManager::GetInstance()->Reserve(
+  const uintptr_t address = AddressPoolManager::GetInstance().Reserve(
       GetRegularPool(), 0, kSuperPageSize);
   ASSERT_TRUE(address);
-  AddressPoolManager::GetInstance()->MarkUsed(GetRegularPool(), address,
-                                              kSuperPageSize);
+  AddressPoolManager::GetInstance().MarkUsed(GetRegularPool(), address,
+                                             kSuperPageSize);
 
-  AddressPoolManager::GetInstance()->DumpStats(&dumper);
+  AddressPoolManager::GetInstance().DumpStats(&dumper);
   EXPECT_GT(dumper.regular_pool_usage_, usage_before);
 
-  AddressPoolManager::GetInstance()->MarkUnused(GetRegularPool(), address,
-                                                kSuperPageSize);
-  AddressPoolManager::GetInstance()->UnreserveAndDecommit(
+  AddressPoolManager::GetInstance().MarkUnused(GetRegularPool(), address,
+                                               kSuperPageSize);
+  AddressPoolManager::GetInstance().UnreserveAndDecommit(
       GetRegularPool(), address, kSuperPageSize);
 
-  AddressPoolManager::GetInstance()->DumpStats(&dumper);
+  AddressPoolManager::GetInstance().DumpStats(&dumper);
   EXPECT_EQ(dumper.regular_pool_usage_, usage_before);
 }
 

base/allocator/partition_allocator/partition_address_space.cc

@@ -91,7 +91,7 @@ void PartitionAddressSpace::Init() {
   setup_.regular_pool_base_mask_ = ~(RegularPoolSize() - 1) & kMemTagUnmask;
 #endif
   PA_DCHECK(!(setup_.regular_pool_base_address_ & (RegularPoolSize() - 1)));
-  setup_.regular_pool_ = AddressPoolManager::GetInstance()->Add(
+  setup_.regular_pool_ = AddressPoolManager::GetInstance().Add(
       setup_.regular_pool_base_address_, RegularPoolSize());
   PA_CHECK(setup_.regular_pool_ == kRegularPoolHandle);
   PA_DCHECK(!IsInRegularPool(setup_.regular_pool_base_address_ - 1));
@@ -117,7 +117,7 @@ void PartitionAddressSpace::Init() {
   setup_.brp_pool_base_mask_ = ~(BRPPoolSize() - 1) & kMemTagUnmask;
 #endif
   PA_DCHECK(!(setup_.brp_pool_base_address_ & (BRPPoolSize() - 1)));
-  setup_.brp_pool_ = AddressPoolManager::GetInstance()->Add(
+  setup_.brp_pool_ = AddressPoolManager::GetInstance().Add(
       setup_.brp_pool_base_address_, BRPPoolSize());
   PA_CHECK(setup_.brp_pool_ == kBRPPoolHandle);
   PA_DCHECK(!IsInBRPPool(setup_.brp_pool_base_address_ - 1));
@@ -128,7 +128,7 @@ void PartitionAddressSpace::Init() {
 #if PA_STARSCAN_USE_CARD_TABLE
   // Reserve memory for PCScan quarantine card table.
   uintptr_t requested_address = setup_.regular_pool_base_address_;
-  uintptr_t actual_address = AddressPoolManager::GetInstance()->Reserve(
+  uintptr_t actual_address = AddressPoolManager::GetInstance().Reserve(
       setup_.regular_pool_, requested_address, kSuperPageSize);
   PA_CHECK(requested_address == actual_address)
       << "QuarantineCardTable is required to be allocated at the beginning of "
@@ -153,7 +153,7 @@ void PartitionAddressSpace::InitConfigurablePool(uintptr_t pool_base,
   setup_.configurable_pool_base_address_ = pool_base;
   setup_.configurable_pool_base_mask_ = ~(size - 1);
 
-  setup_.configurable_pool_ = AddressPoolManager::GetInstance()->Add(
+  setup_.configurable_pool_ = AddressPoolManager::GetInstance().Add(
       setup_.configurable_pool_base_address_, size);
   PA_CHECK(setup_.configurable_pool_ == kConfigurablePoolHandle);
 }
@@ -174,11 +174,11 @@ void PartitionAddressSpace::UninitForTesting() {
   setup_.regular_pool_ = 0;
   setup_.brp_pool_ = 0;
   setup_.configurable_pool_ = 0;
-  AddressPoolManager::GetInstance()->ResetForTesting();
+  AddressPoolManager::GetInstance().ResetForTesting();
 }
 
 void PartitionAddressSpace::UninitConfigurablePoolForTesting() {
-  AddressPoolManager::GetInstance()->Remove(setup_.configurable_pool_);
+  AddressPoolManager::GetInstance().Remove(setup_.configurable_pool_);
   setup_.configurable_pool_base_address_ = kUninitializedPoolBaseAddress;
   setup_.configurable_pool_base_mask_ = 0;
   setup_.configurable_pool_ = 0;

base/allocator/partition_allocator/partition_alloc.cc

@@ -80,7 +80,7 @@ void PartitionAllocGlobalUninitForTesting() {
 #if defined(PA_HAS_64_BITS_POINTERS)
   internal::PartitionAddressSpace::UninitForTesting();
 #else
-  internal::AddressPoolManager::GetInstance()->ResetForTesting();
+  internal::AddressPoolManager::GetInstance().ResetForTesting();
 #endif  // defined(PA_HAS_64_BITS_POINTERS)
 #endif  // !BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
   internal::g_oom_handling_function = nullptr;

base/allocator/partition_allocator/partition_bucket.cc

@@ -94,7 +94,7 @@ uintptr_t ReserveMemoryFromGigaCage(pool_handle pool,
                                     size_t requested_size) {
   PA_DCHECK(!(requested_address % kSuperPageSize));
 
-  uintptr_t reserved_address = AddressPoolManager::GetInstance()->Reserve(
+  uintptr_t reserved_address = AddressPoolManager::GetInstance().Reserve(
       pool, requested_address, requested_size);
 
   // In 32-bit mode, when allocating from BRP pool, verify that the requested
@@ -107,12 +107,12 @@ uintptr_t ReserveMemoryFromGigaCage(pool_handle pool,
           AreAllowedSuperPagesForBRPPool(reserved_address,
                                          reserved_address + requested_size))
         break;
-      AddressPoolManager::GetInstance()->UnreserveAndDecommit(
+      AddressPoolManager::GetInstance().UnreserveAndDecommit(
           pool, reserved_address, requested_size);
       // No longer try to honor |requested_address|, because it didn't work for
       // us last time.
       reserved_address =
-          AddressPoolManager::GetInstance()->Reserve(pool, 0, requested_size);
+          AddressPoolManager::GetInstance().Reserve(pool, 0, requested_size);
     }
 
     // If the allocation attempt succeeds, we will break out of the following
@@ -129,10 +129,10 @@ uintptr_t ReserveMemoryFromGigaCage(pool_handle pool,
           AreAllowedSuperPagesForBRPPool(reserved_address,
                                          reserved_address + requested_size))
         break;
-      AddressPoolManager::GetInstance()->UnreserveAndDecommit(
+      AddressPoolManager::GetInstance().UnreserveAndDecommit(
           pool, reserved_address, requested_size);
       // Reserve() can return a different pointer than attempted.
-      reserved_address = AddressPoolManager::GetInstance()->Reserve(
+      reserved_address = AddressPoolManager::GetInstance().Reserve(
           pool, address_to_try, requested_size);
     }
 
@@ -141,7 +141,7 @@ uintptr_t ReserveMemoryFromGigaCage(pool_handle pool,
     if (reserved_address &&
         !AreAllowedSuperPagesForBRPPool(reserved_address,
                                         reserved_address + requested_size)) {
-      AddressPoolManager::GetInstance()->UnreserveAndDecommit(
+      AddressPoolManager::GetInstance().UnreserveAndDecommit(
           pool, reserved_address, requested_size);
       reserved_address = 0;
     }
@@ -155,8 +155,8 @@ uintptr_t ReserveMemoryFromGigaCage(pool_handle pool,
   // If `MarkUsed` was called earlier, the other thread could incorrectly
   // determine that the allocation had come form PartitionAlloc.
   if (reserved_address)
-    AddressPoolManager::GetInstance()->MarkUsed(pool, reserved_address,
-                                                requested_size);
+    AddressPoolManager::GetInstance().MarkUsed(pool, reserved_address,
+                                               requested_size);
 #endif
 
   PA_DCHECK(!(reserved_address % kSuperPageSize));
@@ -383,10 +383,10 @@ SlotSpanMetadata<thread_safe>* PartitionDirectMap(
       {
         ScopedSyscallTimer timer{root};
 #if !defined(PA_HAS_64_BITS_POINTERS)
-        AddressPoolManager::GetInstance()->MarkUnused(pool, reservation_start,
-                                                      reservation_size);
+        AddressPoolManager::GetInstance().MarkUnused(pool, reservation_start,
+                                                     reservation_size);
 #endif
-        AddressPoolManager::GetInstance()->UnreserveAndDecommit(
+        AddressPoolManager::GetInstance().UnreserveAndDecommit(
             pool, reservation_start, reservation_size);
       }
 

base/allocator/partition_allocator/partition_page.cc

@@ -350,12 +350,12 @@ void UnmapNow(uintptr_t reservation_start,
   }
 
 #if !defined(PA_HAS_64_BITS_POINTERS)
-  AddressPoolManager::GetInstance()->MarkUnused(pool, reservation_start,
-                                                reservation_size);
+  AddressPoolManager::GetInstance().MarkUnused(pool, reservation_start,
+                                               reservation_size);
 #endif
 
   // After resetting the table entries, unreserve and decommit the memory.
-  AddressPoolManager::GetInstance()->UnreserveAndDecommit(
+  AddressPoolManager::GetInstance().UnreserveAndDecommit(
       pool, reservation_start, reservation_size);
 }
 

base/allocator/partition_allocator/partition_root.cc

@@ -636,7 +636,7 @@ void PartitionRoot<thread_safe>::DestructForTesting() {
   auto* curr = first_extent;
   while (curr != nullptr) {
     auto* next = curr->next;
-    internal::AddressPoolManager::GetInstance()->UnreserveAndDecommit(
+    internal::AddressPoolManager::GetInstance().UnreserveAndDecommit(
         pool_handle, reinterpret_cast<uintptr_t>(curr),
         internal::kSuperPageSize * curr->number_of_consecutive_super_pages);
     curr = next;

base/allocator/partition_allocator/reservation_offset_table.h

@@ -204,7 +204,7 @@ ALWAYS_INLINE uintptr_t GetDirectMapReservationStart(uintptr_t address) {
 ALWAYS_INLINE uintptr_t GetDirectMapReservationStart(uintptr_t address,
                                                      pool_handle pool,
                                                      uintptr_t offset_in_pool) {
-  PA_DCHECK(AddressPoolManager::GetInstance()->GetPoolBaseAddress(pool) +
+  PA_DCHECK(AddressPoolManager::GetInstance().GetPoolBaseAddress(pool) +
                 offset_in_pool ==
             address);
   uint16_t* offset_ptr = ReservationOffsetPointer(pool, offset_in_pool);

base/trace_event/address_space_dump_provider.cc

@@ -98,7 +98,7 @@ AddressSpaceDumpProvider* AddressSpaceDumpProvider::GetInstance() {
 bool AddressSpaceDumpProvider::OnMemoryDump(const MemoryDumpArgs& args,
                                             ProcessMemoryDump* pmd) {
   AddressSpaceStatsDumperImpl stats_dumper(pmd);
-  partition_alloc::internal::AddressPoolManager::GetInstance()->DumpStats(
+  partition_alloc::internal::AddressPoolManager::GetInstance().DumpStats(
       &stats_dumper);
   return true;
 }

chromeos/memory/userspace_swap/userspace_swap.cc

@@ -492,20 +492,19 @@ CHROMEOS_EXPORT bool GetPartitionAllocSuperPagesInUse(
   uint32_t superpages_remaining =
       max_superpages >= 0 ? max_superpages : UINT32_MAX;
 
-  auto* pool_manager = base::internal::AddressPoolManager::GetInstance();
-  DCHECK(pool_manager);
+  auto& pool_manager = base::internal::AddressPoolManager::GetInstance();
 
   for (base::internal::pool_handle ph :
        {base::internal::PartitionAddressSpace::GetRegularPool(),
         base::internal::PartitionAddressSpace::GetBRPPool()}) {
-    uintptr_t pool_base = pool_manager->GetPoolBaseAddress(ph);
+    uintptr_t pool_base = pool_manager.GetPoolBaseAddress(ph);
     DCHECK(pool_base);
 
     uintptr_t current_area = 0;
     uint64_t current_area_length = 0;
 
     std::bitset<partition_alloc::kMaxSuperPagesInPool> alloc_bitset;
-    pool_manager->GetPoolUsedSuperPages(ph, alloc_bitset);
+    pool_manager.GetPoolUsedSuperPages(ph, alloc_bitset);
 
     for (size_t i = 0; i < alloc_bitset.size() && superpages_remaining; ++i) {
       if (alloc_bitset.test(i)) {