use new lock (#1423)

Summary: Pull Request resolved: #1423

Differential Revision: D58193617

include/hermes/VM/Profiler/SamplingProfiler.h

@@ -155,6 +155,8 @@ class SamplingProfiler {
   /// domains, and thread associated with the runtime.
   std::mutex runtimeDataLock_;
 
+  std::mutex threadIdLock_;
+
  protected:
   /// Sampled stack traces overtime. Protected by runtimeDataLock_.
   std::vector<StackTrace> sampledStacks_;

lib/VM/Profiler/SamplingProfilerPosix.cpp

@@ -72,7 +72,7 @@ struct SamplingProfilerPosix : SamplingProfiler {
 
   /// Thread that this profiler instance represents. This can be updated as the
   /// runtime is invoked on different threads. Must only be accessed while
-  /// holding the runtimeDataLock_.
+  /// holding the threadIdLock_.
   pthread_t currentThread_;
 
 #if defined(HERMESVM_ENABLE_LOOM) && defined(__ANDROID__)
@@ -315,9 +315,10 @@ bool Sampler::platformSuspendVMAndWalkStack(SamplingProfiler *profiler) {
   // acquired the updates to domains_.
   self->profilerForSig_.store(profiler, std::memory_order_release);
 
-  // Signal target runtime thread to sample stack. The runtimeDataLock is
-  // held by the caller, ensuring the runtime won't start to be used on
+  // Signal target runtime thread to sample stack. The threadIdLock_ is
+  // held ensuring the runtime won't start to be used on
   // another thread before sampling begins.
+  std::lock_guard<std::mutex> lockGuard(posixProfiler->threadIdLock_);
   pthread_kill(posixProfiler->currentThread_, SIGPROF);
 
   // Threading: samplingDoneSem_ will synchronise this thread with the
@@ -473,13 +474,13 @@ std::unique_ptr<SamplingProfiler> SamplingProfiler::create(Runtime &rt) {
 
 bool SamplingProfiler::belongsToCurrentThread() {
   auto profiler = static_cast<sampling_profiler::SamplingProfilerPosix *>(this);
-  std::lock_guard<std::mutex> lock(profiler->runtimeDataLock_);
+  std::lock_guard<std::mutex> lock(profiler->threadIdLock_);
   return profiler->currentThread_ == pthread_self();
 }
 
 void SamplingProfiler::setRuntimeThread() {
   auto profiler = static_cast<sampling_profiler::SamplingProfilerPosix *>(this);
-  std::lock_guard<std::mutex> lock(profiler->runtimeDataLock_);
+  std::lock_guard<std::mutex> lock(profiler->threadIdLock_);
   profiler->currentThread_ = pthread_self();
 }
 

lib/VM/Profiler/SamplingProfilerWindows.cpp

@@ -178,9 +178,10 @@ void Sampler::platformPostSampleStack(SamplingProfiler *localProfiler) {
 bool Sampler::platformSuspendVMAndWalkStack(SamplingProfiler *profiler) {
   auto *winProfiler = static_cast<SamplingProfilerWindows *>(profiler);
 
-  // Suspend the JS thread. The runtimeDataLock is held by the caller, ensuring
+  // Suspend the JS thread. The threadIdLock_ is held by the caller, ensuring
   // the runtime won't start to be used on another thread before sampling
   // begins.
+  std::lock_guard<std::mutex> lockGuard(winProfiler->threadIdLock_);
   DWORD prevSuspendCount = SuspendThread(winProfiler->currentThread_);
   if (prevSuspendCount == static_cast<DWORD>(-1)) {
     return true;
@@ -212,14 +213,14 @@ std::unique_ptr<SamplingProfiler> SamplingProfiler::create(Runtime &rt) {
 bool SamplingProfiler::belongsToCurrentThread() {
   auto profiler =
       static_cast<sampling_profiler::SamplingProfilerWindows *>(this);
-  std::lock_guard<std::mutex> lock(profiler->runtimeDataLock_);
+  std::lock_guard<std::mutex> lock(profiler->threadIdLock_);
   return GetThreadId(profiler->currentThread_) == GetCurrentThreadId();
 }
 
 void SamplingProfiler::setRuntimeThread() {
   auto profiler =
       static_cast<sampling_profiler::SamplingProfilerWindows *>(this);
-  std::lock_guard<std::mutex> lock(profiler->runtimeDataLock_);
+  std::lock_guard<std::mutex> lock(profiler->threadIdLock_);
   CloseHandle(profiler->currentThread_);
   profiler->currentThread_ = openCurrentThread();
 }

unittests/VMRuntime/SamplingProfilerTest.cpp

@@ -65,7 +65,7 @@ TEST(SamplingProfilerTest, MultipleProfilers) {
 #endif
 
 TEST(SamplingProfilerTest, MultipleThreads) {
-  constexpr uint32_t kThreadCount = 3;
+  constexpr uint32_t kThreadCount = 10;
 
   auto rt = makeRuntime(withSamplingProfilerEnabled);
   rt->samplingProfiler->enable();