[vm] Implement more efficient CAS in simarm/simarm64 modes, v.2

runtime/vm/simulator_arm64.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM64)
 
 // Only build the simulator if not compiling for real ARM hardware.
 #if defined(USING_SIMULATOR)
 
 #include "vm/simulator.h"
 
 #include "vm/assembler.h"
 #include "vm/constants_arm64.h"
 #include "vm/disassembler.h"
-#include "vm/lockers.h"
 #include "vm/native_arguments.h"
 #include "vm/os_thread.h"
 #include "vm/stack_frame.h"
 
 namespace dart {
 
 DEFINE_FLAG(uint64_t,
             trace_sim_after,
             ULLONG_MAX,
             "Trace simulator execution after instruction count reached.");
@@ skipping 669 matching lines @@
     }
     // Copy the newly read line into the result.
     memmove(result + offset, line_buf, len);
     offset += len;
   }
   ASSERT(result != NULL);
   result[offset] = '\0';
   return result;
 }
 
-// Synchronization primitives support.
-Mutex* Simulator::exclusive_access_lock_ = NULL;
-Simulator::AddressTag Simulator::exclusive_access_state_[kNumAddressTags] = {
-    {NULL, 0}};
-int Simulator::next_address_tag_ = 0;
-
 void Simulator::InitOnce() {
-  // Setup exclusive access state lock.
-  exclusive_access_lock_ = new Mutex();
 }
 
-Simulator::Simulator() {
+Simulator::Simulator() : exclusive_access_addr_(0), exclusive_access_value_(0) {
   // Setup simulator support first. Some of this information is needed to
   // setup the architecture state.
   // We allocate the stack here, the size is computed as the sum of
   // the size specified by the user and the buffer space needed for
   // handling stack overflow exceptions. To be safe in potential
   // stack underflows we also add some underflow buffer space.
   stack_ =
       new char[(OSThread::GetSpecifiedStackSize() + OSThread::kStackSizeBuffer +
                 kSimulatorStackUnderflowSize)];
   pc_modified_ = false;
@@ skipping 368 matching lines @@
 int8_t Simulator::ReadB(uword addr) {
   int8_t* ptr = reinterpret_cast<int8_t*>(addr);
   return *ptr;
 }
 
 void Simulator::WriteB(uword addr, uint8_t value) {
   uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
   *ptr = value;
 }
 
-// Synchronization primitives support.
-void Simulator::SetExclusiveAccess(uword addr) {
-  Thread* thread = Thread::Current();
-  ASSERT(thread != NULL);
-  DEBUG_ASSERT(exclusive_access_lock_->IsOwnedByCurrentThread());
-  int i = 0;
-  // Find an entry for this thread in the exclusive access state.
-  while ((i < kNumAddressTags) &&
-         (exclusive_access_state_[i].thread != thread)) {
-    i++;
-  }
-  // Round-robin replacement of previously used entries.
-  if (i == kNumAddressTags) {
-    i = next_address_tag_;
-    if (++next_address_tag_ == kNumAddressTags) {
-      next_address_tag_ = 0;
-    }
-    exclusive_access_state_[i].thread = thread;
-  }
-  // Remember the address being reserved.
-  exclusive_access_state_[i].addr = addr;
-}
-
-bool Simulator::HasExclusiveAccessAndOpen(uword addr) {
-  Thread* thread = Thread::Current();
-  ASSERT(thread != NULL);
-  ASSERT(addr != 0);
-  DEBUG_ASSERT(exclusive_access_lock_->IsOwnedByCurrentThread());
-  bool result = false;
-  for (int i = 0; i < kNumAddressTags; i++) {
-    if (exclusive_access_state_[i].thread == thread) {
-      // Check whether the current threads address reservation matches.
-      if (exclusive_access_state_[i].addr == addr) {
-        result = true;
-      }
-      exclusive_access_state_[i].addr = 0;
-    } else if (exclusive_access_state_[i].addr == addr) {
-      // Other threads with matching address lose their reservations.
-      exclusive_access_state_[i].addr = 0;
-    }
-  }
-  return result;
-}
-
 void Simulator::ClearExclusive() {
-  MutexLocker ml(exclusive_access_lock_);
-  // Remove the reservation for this thread.
-  SetExclusiveAccess(0);
+  exclusive_access_addr_ = 0;
+  exclusive_access_value_ = 0;
 }
 
 intptr_t Simulator::ReadExclusiveX(uword addr, Instr* instr) {
-  MutexLocker ml(exclusive_access_lock_);
-  SetExclusiveAccess(addr);
-  return ReadX(addr, instr);
+  exclusive_access_addr_ = addr;
+  exclusive_access_value_ = ReadX(addr, instr);
+  return exclusive_access_value_;
 }
 
 intptr_t Simulator::ReadExclusiveW(uword addr, Instr* instr) {
-  MutexLocker ml(exclusive_access_lock_);
-  SetExclusiveAccess(addr);
-  return ReadWU(addr, instr);
+  exclusive_access_addr_ = addr;
+  exclusive_access_value_ = ReadWU(addr, instr);
+  return exclusive_access_value_;
 }
 
 intptr_t Simulator::WriteExclusiveX(uword addr, intptr_t value, Instr* instr) {
-  MutexLocker ml(exclusive_access_lock_);
-  bool write_allowed = HasExclusiveAccessAndOpen(addr);
-  if (write_allowed) {
-    WriteX(addr, value, instr);
+  // In a well-formed code store-exclusive instruction should always follow
+  // a corresponding load-exclusive instruction with the same address.
+  ASSERT((exclusive_access_addr_ == 0) || (exclusive_access_addr_ == addr));
+  if (exclusive_access_addr_ != addr) {
+    return 1;  // Failure.
+  }
+
+  uword old_value = exclusive_access_value_;
+  ClearExclusive();
+
+  if (AtomicOperations::CompareAndSwapWord(reinterpret_cast<uword*>(addr),
+                                           old_value, value) == old_value) {
     return 0;  // Success.
   }
   return 1;  // Failure.
 }
 
 intptr_t Simulator::WriteExclusiveW(uword addr, intptr_t value, Instr* instr) {
-  MutexLocker ml(exclusive_access_lock_);
-  bool write_allowed = HasExclusiveAccessAndOpen(addr);
-  if (write_allowed) {
-    WriteW(addr, value, instr);
+  // In a well-formed code store-exclusive instruction should always follow
+  // a corresponding load-exclusive instruction with the same address.
+  ASSERT((exclusive_access_addr_ == 0) || (exclusive_access_addr_ == addr));
+  if (exclusive_access_addr_ != addr) {
+    return 1;  // Failure.
+  }
+
+  uint32_t old_value = static_cast<uint32_t>(exclusive_access_value_);
+  ClearExclusive();
+
+  if (AtomicOperations::CompareAndSwapUint32(reinterpret_cast<uint32_t*>(addr),
+                                             old_value, value) == old_value) {
     return 0;  // Success.
   }
   return 1;  // Failure.
 }
 
-uword Simulator::CompareExchange(uword* address,
-                                 uword compare_value,
-                                 uword new_value) {
-  MutexLocker ml(exclusive_access_lock_);
-  // We do not get a reservation as it would be guaranteed to be found when
-  // writing below. No other thread is able to make a reservation while we
-  // hold the lock.
-  uword value = *address;
-  if (value == compare_value) {
-    *address = new_value;
-    // Same effect on exclusive access state as a successful STREX.
-    HasExclusiveAccessAndOpen(reinterpret_cast<uword>(address));
-  } else {
-    // Same effect on exclusive access state as an LDREX.
-    SetExclusiveAccess(reinterpret_cast<uword>(address));
-  }
-  return value;
-}
-
-uint32_t Simulator::CompareExchangeUint32(uint32_t* address,
-                                          uint32_t compare_value,
-                                          uint32_t new_value) {
-  MutexLocker ml(exclusive_access_lock_);
-  // We do not get a reservation as it would be guaranteed to be found when
-  // writing below. No other thread is able to make a reservation while we
-  // hold the lock.
-  uint32_t value = *address;
-  if (value == compare_value) {
-    *address = new_value;
-    // Same effect on exclusive access state as a successful STREX.
-    HasExclusiveAccessAndOpen(reinterpret_cast<uword>(address));
-  } else {
-    // Same effect on exclusive access state as an LDREX.
-    SetExclusiveAccess(reinterpret_cast<uword>(address));
-  }
-  return value;
-}
-
 // Unsupported instructions use Format to print an error and stop execution.
 void Simulator::Format(Instr* instr, const char* format) {
   OS::Print("Simulator found unsupported instruction:\n 0x%p: %s\n", instr,
             format);
   UNIMPLEMENTED();
 }
 
 // Calculate and set the Negative and Zero flags.
 void Simulator::SetNZFlagsW(int32_t val) {
   n_flag_ = (val < 0);
@@ skipping 2331 matching lines @@
   set_register(NULL, CODE_REG, code);
   set_register(NULL, PP, pp);
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(USING_SIMULATOR)
 
 #endif  // defined TARGET_ARCH_ARM64