Refactor lazily initialized singletons in simulators

Use the slimmer base::LeakyObject instead of base::LazyInstance.

R=tebbi@chromium.org

Bug: v8:8600
Change-Id: I71755db9fe3ea9c61be2cdf009a006947ef5560a
Reviewed-on: https://chromium-review.googlesource.com/c/1392203Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58544}

src/arm/simulator-arm.h

@@ -447,8 +447,6 @@ class Simulator : public SimulatorBase {
 
   class GlobalMonitor {
    public:
-    GlobalMonitor();
-
     class Processor {
      public:
       Processor();
@@ -484,16 +482,21 @@ class Simulator : public SimulatorBase {
     // Called when the simulator is destroyed.
     void RemoveProcessor(Processor* processor);
 
+    static GlobalMonitor* Get();
+
    private:
+    // Private constructor. Call {GlobalMonitor::Get()} to get the singleton.
+    GlobalMonitor() = default;
+    friend class base::LeakyObject<GlobalMonitor>;
+
     bool IsProcessorInLinkedList_Locked(Processor* processor) const;
     void PrependProcessor_Locked(Processor* processor);
 
-    Processor* head_;
+    Processor* head_ = nullptr;
   };
 
   LocalMonitor local_monitor_;
   GlobalMonitor::Processor global_monitor_processor_;
-  static base::LazyInstance<GlobalMonitor>::type global_monitor_;
 };
 
 }  // namespace internal

src/arm64/simulator-arm64.cc

@@ -13,6 +13,7 @@
 
 #include "src/arm64/decoder-arm64-inl.h"
 #include "src/assembler-inl.h"
+#include "src/base/lazy-instance.h"
 #include "src/codegen.h"
 #include "src/disasm.h"
 #include "src/macro-assembler.h"
@@ -57,9 +58,8 @@ TEXT_COLOUR clr_debug_number   = FLAG_log_colour ? COLOUR_BOLD(YELLOW)  : "";
 TEXT_COLOUR clr_debug_message  = FLAG_log_colour ? COLOUR(YELLOW)       : "";
 TEXT_COLOUR clr_printf         = FLAG_log_colour ? COLOUR(GREEN)        : "";
 
-// static
-base::LazyInstance<Simulator::GlobalMonitor>::type Simulator::global_monitor_ =
-    LAZY_INSTANCE_INITIALIZER;
+DEFINE_LAZY_LEAKY_OBJECT_GETTER(Simulator::GlobalMonitor,
+                                Simulator::GlobalMonitor::Get);
 
 // This is basically the same as PrintF, with a guard for FLAG_trace_sim.
 void Simulator::TraceSim(const char* format, ...) {
@@ -367,7 +367,7 @@ void Simulator::ResetState() {
 
 
 Simulator::~Simulator() {
-  global_monitor_.Pointer()->RemoveProcessor(&global_monitor_processor_);
+  GlobalMonitor::Get()->RemoveProcessor(&global_monitor_processor_);
   delete[] reinterpret_cast<byte*>(stack_);
   if (FLAG_log_instruction_stats) {
     delete instrument_;
@@ -1779,12 +1779,12 @@ void Simulator::LoadStoreHelper(Instruction* instr,
   uintptr_t stack = 0;
 
   {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
     if (instr->IsLoad()) {
       local_monitor_.NotifyLoad();
     } else {
       local_monitor_.NotifyStore();
-      global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_processor_);
+      GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_processor_);
     }
   }
 
@@ -1913,12 +1913,12 @@ void Simulator::LoadStorePairHelper(Instruction* instr,
   uintptr_t stack = 0;
 
   {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
     if (instr->IsLoad()) {
       local_monitor_.NotifyLoad();
     } else {
       local_monitor_.NotifyStore();
-      global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_processor_);
+      GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_processor_);
     }
   }
 
@@ -2064,7 +2064,7 @@ void Simulator::VisitLoadLiteral(Instruction* instr) {
   unsigned rt = instr->Rt();
 
   {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
     local_monitor_.NotifyLoad();
   }
 
@@ -2155,12 +2155,12 @@ void Simulator::VisitLoadStoreAcquireRelease(Instruction* instr) {
   unsigned access_size = 1 << instr->LoadStoreXSizeLog2();
   uintptr_t address = LoadStoreAddress(rn, 0, AddrMode::Offset);
   DCHECK_EQ(address % access_size, 0);
-  base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+  base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
   if (is_load != 0) {
     if (is_exclusive) {
       local_monitor_.NotifyLoadExcl(address, get_transaction_size(access_size));
-      global_monitor_.Pointer()->NotifyLoadExcl_Locked(
-          address, &global_monitor_processor_);
+      GlobalMonitor::Get()->NotifyLoadExcl_Locked(address,
+                                                  &global_monitor_processor_);
     } else {
       local_monitor_.NotifyLoad();
     }
@@ -2192,7 +2192,7 @@ void Simulator::VisitLoadStoreAcquireRelease(Instruction* instr) {
       DCHECK_NE(rs, rn);
       if (local_monitor_.NotifyStoreExcl(address,
                                          get_transaction_size(access_size)) &&
-          global_monitor_.Pointer()->NotifyStoreExcl_Locked(
+          GlobalMonitor::Get()->NotifyStoreExcl_Locked(
               address, &global_monitor_processor_)) {
         switch (op) {
           case STLXR_b:
@@ -2217,7 +2217,7 @@ void Simulator::VisitLoadStoreAcquireRelease(Instruction* instr) {
       }
     } else {
       local_monitor_.NotifyStore();
-      global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_processor_);
+      GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_processor_);
       switch (op) {
         case STLR_b:
           MemoryWrite<uint8_t>(address, wreg(rt));
@@ -4531,12 +4531,12 @@ void Simulator::NEONLoadStoreMultiStructHelper(const Instruction* instr,
   }
 
   {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
     if (log_read) {
       local_monitor_.NotifyLoad();
     } else {
       local_monitor_.NotifyStore();
-      global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_processor_);
+      GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_processor_);
     }
   }
 
@@ -4777,12 +4777,12 @@ void Simulator::NEONLoadStoreSingleStructHelper(const Instruction* instr,
   }
 
   {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
     if (do_load) {
       local_monitor_.NotifyLoad();
     } else {
       local_monitor_.NotifyStore();
-      global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_processor_);
+      GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_processor_);
     }
   }
 
@@ -5860,8 +5860,6 @@ bool Simulator::GlobalMonitor::Processor::NotifyStoreExcl_Locked(
   return false;
 }
 
-Simulator::GlobalMonitor::GlobalMonitor() : head_(nullptr) {}
-
 void Simulator::GlobalMonitor::NotifyLoadExcl_Locked(uintptr_t addr,
                                                      Processor* processor) {
   processor->NotifyLoadExcl_Locked(addr);

src/arm64/simulator-arm64.h

@@ -2230,8 +2230,6 @@ class Simulator : public DecoderVisitor, public SimulatorBase {
 
   class GlobalMonitor {
    public:
-    GlobalMonitor();
-
     class Processor {
      public:
       Processor();
@@ -2267,16 +2265,21 @@ class Simulator : public DecoderVisitor, public SimulatorBase {
     // Called when the simulator is destroyed.
     void RemoveProcessor(Processor* processor);
 
+    static GlobalMonitor* Get();
+
    private:
+    // Private constructor. Call {GlobalMonitor::Get()} to get the singleton.
+    GlobalMonitor() = default;
+    friend class base::LeakyObject<GlobalMonitor>;
+
     bool IsProcessorInLinkedList_Locked(Processor* processor) const;
     void PrependProcessor_Locked(Processor* processor);
 
-    Processor* head_;
+    Processor* head_ = nullptr;
   };
 
   LocalMonitor local_monitor_;
   GlobalMonitor::Processor global_monitor_processor_;
-  static base::LazyInstance<GlobalMonitor>::type global_monitor_;
 
  private:
   void Init(FILE* stream);

src/mips/simulator-mips.cc

@@ -14,6 +14,7 @@
 
 #include "src/assembler-inl.h"
 #include "src/base/bits.h"
+#include "src/base/lazy-instance.h"
 #include "src/codegen.h"
 #include "src/disasm.h"
 #include "src/macro-assembler.h"
@@ -24,9 +25,8 @@
 namespace v8 {
 namespace internal {
 
-// static
-base::LazyInstance<Simulator::GlobalMonitor>::type Simulator::global_monitor_ =
-    LAZY_INSTANCE_INITIALIZER;
+DEFINE_LAZY_LEAKY_OBJECT_GETTER(Simulator::GlobalMonitor,
+                                Simulator::GlobalMonitor::Get);
 
 // Utils functions.
 bool HaveSameSign(int32_t a, int32_t b) {
@@ -917,7 +917,7 @@ Simulator::Simulator(Isolate* isolate) : isolate_(isolate) {
 }
 
 Simulator::~Simulator() {
-  global_monitor_.Pointer()->RemoveLinkedAddress(&global_monitor_thread_);
+  GlobalMonitor::Get()->RemoveLinkedAddress(&global_monitor_thread_);
   free(stack_);
 }
 
@@ -2000,8 +2000,8 @@ void Simulator::WriteW(int32_t addr, int value, Instruction* instr) {
   }
   if ((addr & kPointerAlignmentMask) == 0 || IsMipsArchVariant(kMips32r6)) {
     local_monitor_.NotifyStore();
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-    global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_thread_);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+    GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_thread_);
     intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
     TraceMemWr(addr, value, WORD);
     *ptr = value;
@@ -2024,12 +2024,12 @@ void Simulator::WriteConditionalW(int32_t addr, int32_t value,
     dbg.Debug();
   }
   if ((addr & kPointerAlignmentMask) == 0 || IsMipsArchVariant(kMips32r6)) {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
     if (local_monitor_.NotifyStoreConditional(addr, TransactionSize::Word) &&
-        global_monitor_.Pointer()->NotifyStoreConditional_Locked(
+        GlobalMonitor::Get()->NotifyStoreConditional_Locked(
             addr, &global_monitor_thread_)) {
       local_monitor_.NotifyStore();
-      global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_thread_);
+      GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_thread_);
       TraceMemWr(addr, value, WORD);
       int* ptr = reinterpret_cast<int*>(addr);
       *ptr = value;
@@ -2062,8 +2062,8 @@ double Simulator::ReadD(int32_t addr, Instruction* instr) {
 void Simulator::WriteD(int32_t addr, double value, Instruction* instr) {
   if ((addr & kDoubleAlignmentMask) == 0 || IsMipsArchVariant(kMips32r6)) {
     local_monitor_.NotifyStore();
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-    global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_thread_);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+    GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_thread_);
     double* ptr = reinterpret_cast<double*>(addr);
     *ptr = value;
     return;
@@ -2108,8 +2108,8 @@ int16_t Simulator::ReadH(int32_t addr, Instruction* instr) {
 void Simulator::WriteH(int32_t addr, uint16_t value, Instruction* instr) {
   if ((addr & 1) == 0 || IsMipsArchVariant(kMips32r6)) {
     local_monitor_.NotifyStore();
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-    global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_thread_);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+    GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_thread_);
     uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
     TraceMemWr(addr, value, HALF);
     *ptr = value;
@@ -2125,8 +2125,8 @@ void Simulator::WriteH(int32_t addr, uint16_t value, Instruction* instr) {
 void Simulator::WriteH(int32_t addr, int16_t value, Instruction* instr) {
   if ((addr & 1) == 0 || IsMipsArchVariant(kMips32r6)) {
     local_monitor_.NotifyStore();
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-    global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_thread_);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+    GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_thread_);
     int16_t* ptr = reinterpret_cast<int16_t*>(addr);
     TraceMemWr(addr, value, HALF);
     *ptr = value;
@@ -2157,8 +2157,8 @@ int32_t Simulator::ReadB(int32_t addr) {
 
 void Simulator::WriteB(int32_t addr, uint8_t value) {
   local_monitor_.NotifyStore();
-  base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-  global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_thread_);
+  base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+  GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_thread_);
   uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
   TraceMemWr(addr, value, BYTE);
   *ptr = value;
@@ -2167,8 +2167,8 @@ void Simulator::WriteB(int32_t addr, uint8_t value) {
 
 void Simulator::WriteB(int32_t addr, int8_t value) {
   local_monitor_.NotifyStore();
-  base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-  global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_thread_);
+  base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+  GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_thread_);
   int8_t* ptr = reinterpret_cast<int8_t*>(addr);
   TraceMemWr(addr, value, BYTE);
   *ptr = value;
@@ -2192,8 +2192,8 @@ T Simulator::ReadMem(int32_t addr, Instruction* instr) {
 template <typename T>
 void Simulator::WriteMem(int32_t addr, T value, Instruction* instr) {
   local_monitor_.NotifyStore();
-  base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-  global_monitor_.Pointer()->NotifyStore_Locked(&global_monitor_thread_);
+  base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+  GlobalMonitor::Get()->NotifyStore_Locked(&global_monitor_thread_);
   int alignment_mask = (1 << sizeof(T)) - 1;
   if ((addr & alignment_mask) == 0 || IsMipsArchVariant(kMips32r6)) {
     T* ptr = reinterpret_cast<T*>(addr);
@@ -6788,12 +6788,12 @@ void Simulator::DecodeTypeImmediate() {
     }
     case LL: {
       DCHECK(!IsMipsArchVariant(kMips32r6));
-      base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+      base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
       addr = rs + se_imm16;
       set_register(rt_reg, ReadW(addr, instr_.instr()));
       local_monitor_.NotifyLoadLinked(addr, TransactionSize::Word);
-      global_monitor_.Pointer()->NotifyLoadLinked_Locked(
-          addr, &global_monitor_thread_);
+      GlobalMonitor::Get()->NotifyLoadLinked_Locked(addr,
+                                                    &global_monitor_thread_);
       break;
     }
     case SC: {
@@ -6870,14 +6870,14 @@ void Simulator::DecodeTypeImmediate() {
       switch (instr_.FunctionFieldRaw()) {
         case LL_R6: {
           DCHECK(IsMipsArchVariant(kMips32r6));
-          base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+          base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
           int32_t base = get_register(instr_.BaseValue());
           int32_t offset9 = instr_.Imm9Value();
           addr = base + offset9;
           DCHECK_EQ(addr & kPointerAlignmentMask, 0);
           set_register(rt_reg, ReadW(base + offset9, instr_.instr()));
           local_monitor_.NotifyLoadLinked(addr, TransactionSize::Word);
-          global_monitor_.Pointer()->NotifyLoadLinked_Locked(
+          GlobalMonitor::Get()->NotifyLoadLinked_Locked(
               addr, &global_monitor_thread_);
           break;
         }
@@ -7280,8 +7280,6 @@ bool Simulator::GlobalMonitor::LinkedAddress::NotifyStoreConditional_Locked(
   return false;
 }
 
-Simulator::GlobalMonitor::GlobalMonitor() : head_(nullptr) {}
-
 void Simulator::GlobalMonitor::NotifyLoadLinked_Locked(
     uintptr_t addr, LinkedAddress* linked_address) {
   linked_address->NotifyLoadLinked_Locked(addr);

src/mips/simulator-mips.h

@@ -597,8 +597,6 @@ class Simulator : public SimulatorBase {
 
   class GlobalMonitor {
    public:
-    GlobalMonitor();
-
     class LinkedAddress {
      public:
       LinkedAddress();
@@ -636,16 +634,21 @@ class Simulator : public SimulatorBase {
     // Called when the simulator is destroyed.
     void RemoveLinkedAddress(LinkedAddress* linked_address);
 
+    static GlobalMonitor* Get();
+
    private:
+    // Private constructor. Call {GlobalMonitor::Get()} to get the singleton.
+    GlobalMonitor() = default;
+    friend class base::LeakyObject<GlobalMonitor>;
+
     bool IsProcessorInLinkedList_Locked(LinkedAddress* linked_address) const;
     void PrependProcessor_Locked(LinkedAddress* linked_address);
 
-    LinkedAddress* head_;
+    LinkedAddress* head_ = nullptr;
   };
 
   LocalMonitor local_monitor_;
   GlobalMonitor::LinkedAddress global_monitor_thread_;
-  static base::LazyInstance<GlobalMonitor>::type global_monitor_;
 };
 
 }  // namespace internal

src/mips64/simulator-mips64.h

@@ -621,8 +621,6 @@ class Simulator : public SimulatorBase {
 
   class GlobalMonitor {
    public:
-    GlobalMonitor();
-
     class LinkedAddress {
      public:
       LinkedAddress();
@@ -660,16 +658,21 @@ class Simulator : public SimulatorBase {
     // Called when the simulator is destroyed.
     void RemoveLinkedAddress(LinkedAddress* linked_address);
 
+    static GlobalMonitor* Get();
+
    private:
+    // Private constructor. Call {GlobalMonitor::Get()} to get the singleton.
+    GlobalMonitor() = default;
+    friend class base::LeakyObject<GlobalMonitor>;
+
     bool IsProcessorInLinkedList_Locked(LinkedAddress* linked_address) const;
     void PrependProcessor_Locked(LinkedAddress* linked_address);
 
-    LinkedAddress* head_;
+    LinkedAddress* head_ = nullptr;
   };
 
   LocalMonitor local_monitor_;
   GlobalMonitor::LinkedAddress global_monitor_thread_;
-  static base::LazyInstance<GlobalMonitor>::type global_monitor_;
 };
 
 }  // namespace internal

src/ppc/simulator-ppc.cc

@@ -12,6 +12,7 @@
 
 #include "src/assembler.h"
 #include "src/base/bits.h"
+#include "src/base/lazy-instance.h"
 #include "src/codegen.h"
 #include "src/disasm.h"
 #include "src/macro-assembler.h"
@@ -26,9 +27,8 @@
 namespace v8 {
 namespace internal {
 
-// static
-base::LazyInstance<Simulator::GlobalMonitor>::type Simulator::global_monitor_ =
-    LAZY_INSTANCE_INITIALIZER;
+DEFINE_LAZY_LEAKY_OBJECT_GETTER(Simulator::GlobalMonitor,
+                                Simulator::GlobalMonitor::Get);
 
 // This macro provides a platform independent use of sscanf. The reason for
 // SScanF not being implemented in a platform independent way through
@@ -3952,12 +3952,6 @@ uintptr_t Simulator::PopAddress() {
   return address;
 }
 
-Simulator::GlobalMonitor::GlobalMonitor()
-    : access_state_(MonitorAccess::Open),
-      tagged_addr_(0),
-      size_(TransactionSize::None),
-      thread_id_(ThreadId::Invalid()) {}
-
 void Simulator::GlobalMonitor::Clear() {
   access_state_ = MonitorAccess::Open;
   tagged_addr_ = 0;

src/ppc/simulator-ppc.h

@@ -248,14 +248,14 @@ class Simulator : public SimulatorBase {
   // Read and write memory.
   template <typename T>
   inline void Read(uintptr_t address, T* value) {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
     memcpy(value, reinterpret_cast<const char*>(address), sizeof(T));
   }
 
   template <typename T>
   inline void ReadEx(uintptr_t address, T* value) {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-    global_monitor_.Pointer()->NotifyLoadExcl(
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+    GlobalMonitor::Get()->NotifyLoadExcl(
         address, static_cast<TransactionSize>(sizeof(T)),
         isolate_->thread_id());
     memcpy(value, reinterpret_cast<const char*>(address), sizeof(T));
@@ -263,17 +263,17 @@ class Simulator : public SimulatorBase {
 
   template <typename T>
   inline void Write(uintptr_t address, T value) {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-    global_monitor_.Pointer()->NotifyStore(
-        address, static_cast<TransactionSize>(sizeof(T)),
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+    GlobalMonitor::Get()->NotifyStore(address,
+                                      static_cast<TransactionSize>(sizeof(T)),
                                       isolate_->thread_id());
     memcpy(reinterpret_cast<char*>(address), &value, sizeof(T));
   }
 
   template <typename T>
   inline int32_t WriteEx(uintptr_t address, T value) {
-    base::MutexGuard lock_guard(&global_monitor_.Pointer()->mutex);
-    if (global_monitor_.Pointer()->NotifyStoreExcl(
+    base::MutexGuard lock_guard(&GlobalMonitor::Get()->mutex);
+    if (GlobalMonitor::Get()->NotifyStoreExcl(
             address, static_cast<TransactionSize>(sizeof(T)),
             isolate_->thread_id())) {
       memcpy(reinterpret_cast<char*>(address), &value, sizeof(T));
@@ -386,8 +386,6 @@ class Simulator : public SimulatorBase {
 
   class GlobalMonitor {
    public:
-    GlobalMonitor();
-
     // Exposed so it can be accessed by Simulator::{Read,Write}Ex*.
     base::Mutex mutex;
 
@@ -397,16 +395,20 @@ class Simulator : public SimulatorBase {
     bool NotifyStoreExcl(uintptr_t addr, TransactionSize size,
                          ThreadId thread_id);
 
+    static GlobalMonitor* Get();
+
    private:
+    // Private constructor. Call {GlobalMonitor::Get()} to get the singleton.
+    GlobalMonitor() = default;
+    friend class base::LeakyObject<GlobalMonitor>;
+
     void Clear();
 
-    MonitorAccess access_state_;
-    uintptr_t tagged_addr_;
-    TransactionSize size_;
-    ThreadId thread_id_;
+    MonitorAccess access_state_ = MonitorAccess::Open;
+    uintptr_t tagged_addr_ = 0;
+    TransactionSize size_ = TransactionSize::None;
+    ThreadId thread_id_ = ThreadId::Invalid();
   };
-
-  static base::LazyInstance<GlobalMonitor>::type global_monitor_;
 };
 
 }  // namespace internal