[hwasan] Fix lock contention on thread creation.

[eugenis]

Summary

Do not hold the free/live thread list lock longer than necessary.
This change speeds up the following benchmark 10x.

constexpr int kTopThreads = 50;
constexpr int kChildThreads = 20;
constexpr int kChildIterations = 8;

void Thread() {

for (int i = 0; i < kChildIterations; ++i) {
  std::vector<std::thread> threads;
  for (int i = 0; i < kChildThreads; ++i)
    threads.emplace_back([](){});
  for (auto& t : threads)
    t.join();
}

}

int main() {

std::vector<std::thread> threads;
for (int i = 0; i < kTopThreads; ++i)
  threads.emplace_back(Thread);
for (auto& t : threads)
  t.join();

}

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_thread_list.h

92

unrelated to the patch but maybe free_list_ and live_list_ could have each own mutex

137

{} redundant in this case

[eugenis]

addressed comments

compiler-rt/lib/hwasan/hwasan_thread_list.h

92

I've actually tried this and could not see a measurable perf improvement.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_thread_list.h

92

To my taste it would be cleaner that way: different resources rely on different mutexes.
This bug will less likely to happen in the first place :)

[eugenis]

split locks for live and free lists

compiler-rt/lib/hwasan/hwasan_thread_list.h

HwasanThreadList(uptr storage, uptr size)
     // * a ring buffer at offset 0,
     // * a Thread object at offset ring_buffer_size_.
     ring_buffer_size_ = RingBufferSize();
     thread_alloc_size_ =
         RoundUpTo(ring_buffer_size_ + sizeof(Thread), ring_buffer_size_ * 2);
   }
 
   Thread *CreateCurrentThread() {
-    Thread *t;
+    Thread *t = nullptr;
     {
-      SpinMutexLock l(&list_mutex_);
+      SpinMutexLock l(&free_list_mutex_);
       if (!free_list_.empty()) {
         t = free_list_.back();
         free_list_.pop_back();
-        uptr start = (uptr)t - ring_buffer_size_;
-        internal_memset((void *)start, 0, ring_buffer_size_ + sizeof(Thread));
-      } else {
-        t = AllocThread();
-      }
+      }
+    }
+    if (t) {
+    {
+      SpinMutexLock l(&live_list_mutex_);
       live_list_.push_back(t);
     }
     t->Init((uptr)t - ring_buffer_size_, ring_buffer_size_);
     AddThreadStats(t);
     return t;
   }
 
   void DontNeedThread(Thread *t) {
     uptr start = (uptr)t - ring_buffer_size_;
     ReleaseMemoryPagesToOS(start, start + thread_alloc_size_);
   }
 
   void RemoveThreadFromLiveList(Thread *t) {
+    SpinMutexLock l(&live_list_mutex_);
     for (Thread *&t2 : live_list_)
       if (t2 == t) {
         // To remove t2, copy the last element of the list in t2's position, and
         // pop_back(). This works even if t2 is itself the last element.
         t2 = live_list_.back();
         live_list_.pop_back();
         return;
       }
     CHECK(0 && "thread not found in live list");
   }
 
   void ReleaseThread(Thread *t) {
     RemoveThreadStats(t);
     t->Destroy();
-    SpinMutexLock l(&list_mutex_);
+    DontNeedThread(t);
     RemoveThreadFromLiveList(t);
+    SpinMutexLock l(&free_list_mutex_);
     free_list_.push_back(t);
-    DontNeedThread(t);
   }
 
   Thread *GetThreadByBufferAddress(uptr p) {
     return (Thread *)(RoundDownTo(p, ring_buffer_size_ * 2) +
                       ring_buffer_size_);
   }
 
   uptr MemoryUsedPerThread() {
     uptr res = sizeof(Thread) + ring_buffer_size_;
     if (auto sz = flags()->heap_history_size)
       res += HeapAllocationsRingBuffer::SizeInBytes(sz);
     return res;
   }
 
   template <class CB>
   void VisitAllLiveThreads(CB cb) {
-    SpinMutexLock l(&list_mutex_);
+    SpinMutexLock l(&live_list_mutex_);
     for (Thread *t : live_list_) cb(t);
   }
 
   void AddThreadStats(Thread *t) {
     SpinMutexLock l(&stats_mutex_);
     stats_.n_live_threads++;
     stats_.total_stack_size += t->stack_size();
   }
Thread *AllocThread() {
     return t;
   }
 
   uptr free_space_;
   uptr free_space_end_;
   uptr ring_buffer_size_;
   uptr thread_alloc_size_;
 
+  SpinMutex free_list_mutex_;
   InternalMmapVector<Thread *> free_list_;
+  SpinMutex live_list_mutex_;
   InternalMmapVector<Thread *> live_list_;
-  SpinMutex list_mutex_;
 
   ThreadStats stats_;
   SpinMutex stats_mutex_;
 };
 
 void InitThreadList(uptr storage, uptr size);
 HwasanThreadList &hwasanThreadList();
 
 } // namespace