sanitizer_common: add simpler ThreadRegistry ctor

[dvyukov]

Summary

Currently ThreadRegistry is overcomplicated because of tsan,
it needs tid quarantine and reuse counters. Other sanitizers
don't need that. It also seems that no other sanitizer now
needs max number of threads. Asan used to need 2^24 limit,
but it does not seem to be needed now. Other sanitizers blindly
copy-pasted that without reasons. Lsan also uses quarantine,
but I don't see why that may be potentially needed.

Add a ThreadRegistry ctor that does not require any sizes
and use it in all sanitizers except for tsan.
In preparation for new tsan runtime, which won't need
any of these parameters as well.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

103

UINT32_MAX

115–116

It's not just simplify, it allocates 4B instead of 4M threads?

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

115–116

MmapNoReserveOrDie?

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

115–116

but we have i386 support in asan

[dvyukov]

fixed comments

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

115–116

You are right.
Switched to InternalMmapVectorNoCtor to fix this.

[dvyukov]

PTAL

[vitalybuka]

sanitizer_common/tests/sanitizer_thread_registry_test.cpp:138:18: error: no matching constructor for initialization of '__sanitizer::ThreadRegistry'

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

115–116

you don't need to do threads_.Initialize(1024);, it will initialize on the first push

Everything should work without this
however if I remove the line I get

SanitizerCommon-Unit :: ./Sanitizer-i386-Test/SanitizerCommon.ThreadRegistryTest
SanitizerCommon-Unit :: ./Sanitizer-i386-Test/SanitizerCommon.ThreadRegistryThreadedTest
SanitizerCommon-Unit :: ./Sanitizer-x86_64-Test/SanitizerCommon.ThreadRegistryTest
SanitizerCommon-Unit :: ./Sanitizer-x86_64-Test/SanitizerCommon.ThreadRegistryThreadedTest

which is very strange

141

do we need max_threads_ now?
I guess threads_.push_back will just crash when re-map fails.

146

I am not sure if this is going to work
push_back may reallocate entire vector, so it will invalidate all pointers to ThreadContext

At least PlatformTSDDtor does that

[dvyukov]

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

115–116

The vector does not have a ctor. It will work if it's zero initialized, but it's not the case at least in tests (as you discovered :)). Initialize is effectively a replacement for ctor.

141

TSan still uses a lower max_threads_.

146

It only invalidates pointers to pointers to ThreadContext (not the ThreadContext objects themselves). These pointers to pointers don't leak from ThreadRegistry I think.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

115–116

Oh, I assumed it's InternalMmapVector
so why not just use InternalMmapVector<ThreadContextBase *> threads_; ?

146

Oh, it's pointers, then LGTM

[dvyukov]

Use InternalMmapVector instead of InternalMmapVectorNoCtor.

[dvyukov]

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

115–116

Good idea. Done.
We don't need reserve as well. I probably assumed that InternalMmapVector does not round up the buffer to page size.

[dvyukov]

This broke android:
https://lab.llvm.org/buildbot#builders/77/builds/7734

+ FileCheck /var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm-project/compiler-rt/test/asan/TestCases/Linux/global-overflow-lld.cpp
/var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm-project/compiler-rt/test/asan/TestCases/Linux/global-overflow-lld.cpp:15:12: error: CHECK: expected string not found in input
// CHECK: {{READ of size 1 at}}

^

<stdin>:1:1: note: scanning from here
AddressSanitizer: CHECK failed: sanitizer_common.h:491 "((i)) < ((size_))" (0x0, 0x0) (tid=26836)
^
<stdin>:1:19: note: possible intended match here
AddressSanitizer: CHECK failed: sanitizer_common.h:491 "((i)) < ((size_))" (0x0, 0x0) (tid=26836)

^

Input file: <stdin>
Check file: /var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm-project/compiler-rt/test/asan/TestCases/Linux/global-overflow-lld.cpp

-dump-input=help explains the following input dump.

Input was:
<<<<<<

1: AddressSanitizer: CHECK failed: sanitizer_common.h:491 "((i)) < ((size_))" (0x0, 0x0) (tid=26836)

check:15'0 X~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: no match found
check:15'1 ? possible intended match

2:  <empty stack>

check:15'0 ~~~~~~~~~~~~~~~

It seems that android fails to properly initialize asan runtime (don't create main thread).
I see that AsanInitInternal always calls CreateMainThread. So I am not sure how that is possible.
I don't have android to reproduce and fix this.

[vitalybuka]

includes 6062c672bc5e560a4c3dc73741f9e82b39d08527.

[vitalybuka]

I can take a look, but software android emulator works with zorg/buildbot/builders/sanitizers/buildbot_android.sh

[dvyukov]

In D105713#2871884, @vitalybuka wrote:

I can take a look, but software android emulator works with zorg/buildbot/builders/sanitizers/buildbot_android.sh

I've run this script, but it started to a full fresh build from the current llvm HEAD I guess. This change is already reverted, so it won't reproduce the problem.

I am not sure how I should use it to debug the problem.
Is there a way to point it to a custom checkout? And run a single test? Or at least 'ninja check-asan`?

It also all failed with "unavailable device":

+ local _arch=i686
+ [[ ! -f tested_arch_i686 ]]
+ echo @@@BUILD_STEP unavailable device android/i686@@@
@@@BUILD_STEP unavailable device android/i686@@@
+ echo @@@STEP_EXCEPTION@@@
@@@STEP_EXCEPTION@@@
+ for _arg in "$@"
+ local _arch=arm
+ [[ ! -f tested_arch_arm ]]
+ echo @@@BUILD_STEP unavailable device android/arm@@@
@@@BUILD_STEP unavailable device android/arm@@@
+ echo @@@STEP_EXCEPTION@@@
@@@STEP_EXCEPTION@@@
+ for _arg in "$@"
+ local _arch=aarch64
+ [[ ! -f tested_arch_aarch64 ]]
+ echo @@@BUILD_STEP unavailable device android/aarch64@@@
@@@BUILD_STEP unavailable device android/aarch64@@@
+ echo @@@STEP_EXCEPTION@@@
@@@STEP_EXCEPTION@@@

[dvyukov]

I wonder if it worked only because GetThreadLocked has DCHECK instead of CHECK:

// Should be guarded by ThreadRegistryLock.
ThreadContextBase *GetThreadLocked(u32 tid) {
  DCHECK_LT(tid, n_contexts_);
  return threads_[tid];
}

Do we test DEBUG configuration for Android?

[vitalybuka]

I am not sure how I should use it to debug the problem.
Is there a way to point it to a custom checkout? And run a single test? Or at least 'ninja check-asan`?

something like
BUILDBOT_MONO_REPO_PATH=~/src/llvm.git/llvm-project ~/src/zorg/zorg/buildbot/builders/sanitizers/buildbot_android.sh
from: https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild

[vitalybuka]

// Should be guarded by ThreadRegistryLock.
ThreadContextBase *GetThreadLocked(u32 tid) {
  DCHECK_LT(tid, n_contexts_);
  return threads_[tid];
}

Do we test DEBUG configuration for Android?

No we don't.
Unfortunately I noticed this comment just now, and spent some time debugging. That's the reason.

[vitalybuka]

Fix android test

compiler-rt/lib/asan/asan_thread.h

 #include "sanitizer_common/sanitizer_thread_registry.h"
 
 namespace __sanitizer {
 struct DTLS;
 }  // namespace __sanitizer
 
 namespace __asan {
 
-const u32 kMaxNumberOfThreads = (1 << 22);  // 4M
-
 class AsanThread;
 
 // These objects are created for every thread and are never deleted,
 // so we can find them by tid even if the thread is long dead.
 class AsanThreadContext final : public ThreadContextBase {
  public:
   explicit AsanThreadContext(int tid)
       : ThreadContextBase(tid), announced(false),

compiler-rt/lib/asan/asan_thread.cpp

ThreadRegistry &asanThreadRegistry() {
   static bool initialized;
   // Don't worry about thread_safety - this should be called when there is
   // a single thread.
   if (!initialized) {
     // Never reuse ASan threads: we store pointer to AsanThreadContext
     // in TSD and can't reliably tell when no more TSD destructors will
     // be called. It would be wrong to reuse AsanThreadContext for another
     // thread before all TSD destructors will be called for it.
-    asan_thread_registry = new(thread_registry_placeholder) ThreadRegistry(
-        GetAsanThreadContext, kMaxNumberOfThreads, kMaxNumberOfThreads);
+    asan_thread_registry =
+        new (thread_registry_placeholder) ThreadRegistry(GetAsanThreadContext);
     initialized = true;
   }
   return *asan_thread_registry;
 }
 
 AsanThreadContext *GetThreadContextByTidLocked(u32 tid) {
   return static_cast<AsanThreadContext *>(
       asanThreadRegistry().GetThreadLocked(tid));

compiler-rt/lib/lsan/lsan_thread.cpp

 
 static ThreadRegistry *thread_registry;
 
 static ThreadContextBase *CreateThreadContext(u32 tid) {
   void *mem = MmapOrDie(sizeof(ThreadContext), "ThreadContext");
   return new (mem) ThreadContext(tid);
 }
 
-static const uptr kMaxThreads = 1 << 22;  // 4M
-static const uptr kThreadQuarantineSize = 64;
-
 void InitializeThreadRegistry() {
   static ALIGNED(64) char thread_registry_placeholder[sizeof(ThreadRegistry)];
-  thread_registry = new (thread_registry_placeholder)
-      ThreadRegistry(CreateThreadContext, kMaxThreads, kThreadQuarantineSize);
+  thread_registry =
+      new (thread_registry_placeholder) ThreadRegistry(CreateThreadContext);
 }
 
 ThreadContextLsanBase::ThreadContextLsanBase(int tid)
     : ThreadContextBase(tid) {}
 
 void ThreadContextLsanBase::OnFinished() {
   AllocatorThreadFinish();
   DTLS_Destroy();

compiler-rt/lib/memprof/memprof_thread.h

 #include "sanitizer_common/sanitizer_thread_registry.h"
 
 namespace __sanitizer {
 struct DTLS;
 } // namespace __sanitizer
 
 namespace __memprof {
 
-const u32 kMaxNumberOfThreads = (1 << 22); // 4M
-
 class MemprofThread;
 
 // These objects are created for every thread and are never deleted,
 // so we can find them by tid even if the thread is long dead.
 struct MemprofThreadContext final : public ThreadContextBase {
   explicit MemprofThreadContext(int tid)
       : ThreadContextBase(tid), announced(false),
         destructor_iterations(GetPthreadDestructorIterations()), stack_id(0),

compiler-rt/lib/memprof/memprof_thread.cpp

ThreadRegistry &memprofThreadRegistry() {
   static bool initialized;
   // Don't worry about thread_safety - this should be called when there is
   // a single thread.
   if (!initialized) {
     // Never reuse MemProf threads: we store pointer to MemprofThreadContext
     // in TSD and can't reliably tell when no more TSD destructors will
     // be called. It would be wrong to reuse MemprofThreadContext for another
     // thread before all TSD destructors will be called for it.
-    memprof_thread_registry = new (thread_registry_placeholder) ThreadRegistry(
-        GetMemprofThreadContext, kMaxNumberOfThreads, kMaxNumberOfThreads);
+    memprof_thread_registry = new (thread_registry_placeholder)
+        ThreadRegistry(GetMemprofThreadContext);
     initialized = true;
   }
   return *memprof_thread_registry;
 }
 
 MemprofThreadContext *GetThreadContextByTidLocked(u32 tid) {
   return static_cast<MemprofThreadContext *>(
       memprofThreadRegistry().GetThreadLocked(tid));

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.h

  protected:
   ~ThreadContextBase();
 };
 
 typedef ThreadContextBase* (*ThreadContextFactory)(u32 tid);
 
 class MUTEX ThreadRegistry {
  public:
+  ThreadRegistry(ThreadContextFactory factory);
   ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
-                 u32 thread_quarantine_size, u32 max_reuse = 0);
+                 u32 thread_quarantine_size, u32 max_reuse);
   void GetNumberOfThreads(uptr *total = nullptr, uptr *running = nullptr,
                           uptr *alive = nullptr);
   uptr GetMaxAliveThreads();
 
   void Lock() ACQUIRE() { mtx_.Lock(); }
   void CheckLocked() const CHECK_LOCKED { mtx_.CheckLocked(); }
   void Unlock() RELEASE() { mtx_.Unlock(); }
 
   // Should be guarded by ThreadRegistryLock.
   ThreadContextBase *GetThreadLocked(u32 tid) {
-    DCHECK_LT(tid, n_contexts_);
-    return threads_[tid];
+    return threads_.empty() ? nullptr : threads_[tid];
   }
 
   u32 CreateThread(uptr user_id, bool detached, u32 parent_tid, void *arg);
 
   typedef void (*ThreadCallback)(ThreadContextBase *tctx, void *arg);
   // Invokes callback with a specified arg for each thread context.
   // Should be guarded by ThreadRegistryLock.
   void RunCallbackForEachThreadLocked(ThreadCallback cb, void *arg);

  private:
   const ThreadContextFactory context_factory_;
   const u32 max_threads_;
   const u32 thread_quarantine_size_;
   const u32 max_reuse_;
 
   BlockingMutex mtx_;
 
-  u32 n_contexts_;      // Number of created thread contexts,
-                        // at most max_threads_.
   u64 total_threads_;   // Total number of created threads. May be greater than
                         // max_threads_ if contexts were reused.
   uptr alive_threads_;  // Created or running.
   uptr max_alive_threads_;
   uptr running_threads_;
 
-  ThreadContextBase **threads_;  // Array of thread contexts is leaked.
+  InternalMmapVector<ThreadContextBase *> threads_;
   IntrusiveList<ThreadContextBase> dead_threads_;
   IntrusiveList<ThreadContextBase> invalid_threads_;
 
   void QuarantinePush(ThreadContextBase *tctx);
   ThreadContextBase *QuarantinePop();
 };
 
 typedef GenericScopedLock<ThreadRegistry> ThreadRegistryLock;
 
 } // namespace __sanitizer
 
 #endif // SANITIZER_THREAD_REGISTRY_H

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

void ThreadContextBase::Reset() {
   status = ThreadStatusInvalid;
   SetName(0);
   atomic_store(&thread_destroyed, 0, memory_order_release);
   OnReset();
 }
 
 // ThreadRegistry implementation.
 
+ThreadRegistry::ThreadRegistry(ThreadContextFactory factory)
+    : ThreadRegistry(factory, UINT32_MAX, UINT32_MAX, 0) {}
+
 ThreadRegistry::ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
                                u32 thread_quarantine_size, u32 max_reuse)
     : context_factory_(factory),
       max_threads_(max_threads),
       thread_quarantine_size_(thread_quarantine_size),
       max_reuse_(max_reuse),
       mtx_(),
-      n_contexts_(0),
       total_threads_(0),
       alive_threads_(0),
       max_alive_threads_(0),
       running_threads_(0) {
-  threads_ = (ThreadContextBase **)MmapOrDie(max_threads_ * sizeof(threads_[0]),
-                                             "ThreadRegistry");
   dead_threads_.clear();
   invalid_threads_.clear();
 }
 
 void ThreadRegistry::GetNumberOfThreads(uptr *total, uptr *running,
                                         uptr *alive) {
   BlockingMutexLock l(&mtx_);
-  if (total) *total = n_contexts_;
+  if (total)
+    *total = threads_.size();
   if (running) *running = running_threads_;
   if (alive) *alive = alive_threads_;
 }
 
 uptr ThreadRegistry::GetMaxAliveThreads() {
   BlockingMutexLock l(&mtx_);
   return max_alive_threads_;
 }
 
 u32 ThreadRegistry::CreateThread(uptr user_id, bool detached, u32 parent_tid,
                                  void *arg) {
   BlockingMutexLock l(&mtx_);
   u32 tid = kInvalidTid;
   ThreadContextBase *tctx = QuarantinePop();
   if (tctx) {
     tid = tctx->tid;
-  } else if (n_contexts_ < max_threads_) {
+  } else if (threads_.size() < max_threads_) {
     // Allocate new thread context and tid.
-    tid = n_contexts_++;
+    tid = threads_.size();
     tctx = context_factory_(tid);
-    threads_[tid] = tctx;
+    threads_.push_back(tctx);
   } else {
 #if !SANITIZER_GO
     Report("%s: Thread limit (%u threads) exceeded. Dying.\n",
            SanitizerToolName, max_threads_);
 #else
     Printf("race: limit on %u simultaneously alive goroutines is exceeded,"
         " dying\n", max_threads_);
 #endif
     Die();
#endif
   tctx->SetCreated(user_id, total_threads_++, detached,
                    parent_tid, arg);
   return tid;
 }
 
 void ThreadRegistry::RunCallbackForEachThreadLocked(ThreadCallback cb,
                                                     void *arg) {
   CheckLocked();
-  for (u32 tid = 0; tid < n_contexts_; tid++) {
+  for (u32 tid = 0; tid < threads_.size(); tid++) {
     ThreadContextBase *tctx = threads_[tid];
     if (tctx == 0)
       continue;
     cb(tctx, arg);
   }
 }
 
 u32 ThreadRegistry::FindThread(FindThreadCallback cb, void *arg) {
   BlockingMutexLock l(&mtx_);
-  for (u32 tid = 0; tid < n_contexts_; tid++) {
+  for (u32 tid = 0; tid < threads_.size(); tid++) {
     ThreadContextBase *tctx = threads_[tid];
     if (tctx != 0 && cb(tctx, arg))
       return tctx->tid;
   }
   return kInvalidTid;
 }
 
 ThreadContextBase *
 ThreadRegistry::FindThreadContextLocked(FindThreadCallback cb, void *arg) {
   CheckLocked();
-  for (u32 tid = 0; tid < n_contexts_; tid++) {
+  for (u32 tid = 0; tid < threads_.size(); tid++) {
     ThreadContextBase *tctx = threads_[tid];
     if (tctx != 0 && cb(tctx, arg))
       return tctx;
   }
   return 0;
 }
 
 static bool FindThreadContextByOsIdCallback(ThreadContextBase *tctx,
                                             void *arg) {
   return (tctx->os_id == (uptr)arg && tctx->status != ThreadStatusInvalid &&
       tctx->status != ThreadStatusDead);
 }
 
 ThreadContextBase *ThreadRegistry::FindThreadContextByOsIDLocked(tid_t os_id) {
   return FindThreadContextLocked(FindThreadContextByOsIdCallback,
                                  (void *)os_id);
 }
 
 void ThreadRegistry::SetThreadName(u32 tid, const char *name) {
   BlockingMutexLock l(&mtx_);
-  CHECK_LT(tid, n_contexts_);
   ThreadContextBase *tctx = threads_[tid];
   CHECK_NE(tctx, 0);
   CHECK_EQ(SANITIZER_FUCHSIA ? ThreadStatusCreated : ThreadStatusRunning,
            tctx->status);
   tctx->SetName(name);
 }
 
 void ThreadRegistry::SetThreadNameByUserId(uptr user_id, const char *name) {
   BlockingMutexLock l(&mtx_);
-  for (u32 tid = 0; tid < n_contexts_; tid++) {
+  for (u32 tid = 0; tid < threads_.size(); tid++) {
     ThreadContextBase *tctx = threads_[tid];
     if (tctx != 0 && tctx->user_id == user_id &&
         tctx->status != ThreadStatusInvalid) {
       tctx->SetName(name);
       return;
     }
   }
 }
 
 void ThreadRegistry::DetachThread(u32 tid, void *arg) {
   BlockingMutexLock l(&mtx_);
-  CHECK_LT(tid, n_contexts_);
   ThreadContextBase *tctx = threads_[tid];
   CHECK_NE(tctx, 0);
   if (tctx->status == ThreadStatusInvalid) {
     Report("%s: Detach of non-existent thread\n", SanitizerToolName);
     return;
   }
   tctx->OnDetached(arg);
   if (tctx->status == ThreadStatusFinished) {
     tctx->SetDead();
     QuarantinePush(tctx);
   } else {
     tctx->detached = true;
   }
 }
 
 void ThreadRegistry::JoinThread(u32 tid, void *arg) {
   bool destroyed = false;
   do {
     {
       BlockingMutexLock l(&mtx_);
-      CHECK_LT(tid, n_contexts_);
       ThreadContextBase *tctx = threads_[tid];
       CHECK_NE(tctx, 0);
       if (tctx->status == ThreadStatusInvalid) {
         Report("%s: Join of non-existent thread\n", SanitizerToolName);
         return;
       }
       if ((destroyed = tctx->GetDestroyed())) {
         tctx->SetJoined(arg);

 // called in ThreadStatusCreated state, then this thread was never
 // really started.  We just did CreateThread for a prospective new
 // thread before trying to create it, and then failed to actually
 // create it, and so never called StartThread.
 ThreadStatus ThreadRegistry::FinishThread(u32 tid) {
   BlockingMutexLock l(&mtx_);
   CHECK_GT(alive_threads_, 0);
   alive_threads_--;
-  CHECK_LT(tid, n_contexts_);
   ThreadContextBase *tctx = threads_[tid];
   CHECK_NE(tctx, 0);
   bool dead = tctx->detached;
   ThreadStatus prev_status = tctx->status;
   if (tctx->status == ThreadStatusRunning) {
     CHECK_GT(running_threads_, 0);
     running_threads_--;
   } else {
ThreadStatus ThreadRegistry::FinishThread(u32 tid) {
   tctx->SetDestroyed();
   return prev_status;
 }
 
 void ThreadRegistry::StartThread(u32 tid, tid_t os_id, ThreadType thread_type,
                                  void *arg) {
   BlockingMutexLock l(&mtx_);
   running_threads_++;
-  CHECK_LT(tid, n_contexts_);
   ThreadContextBase *tctx = threads_[tid];
   CHECK_NE(tctx, 0);
   CHECK_EQ(ThreadStatusCreated, tctx->status);
   tctx->SetStarted(os_id, thread_type, arg);
 }
 
 void ThreadRegistry::QuarantinePush(ThreadContextBase *tctx) {
   if (tctx->tid == 0)
if (invalid_threads_.size() == 0)
     return 0;
   ThreadContextBase *tctx = invalid_threads_.front();
   invalid_threads_.pop_front();
   return tctx;
 }
 
 void ThreadRegistry::SetThreadUserId(u32 tid, uptr user_id) {
   BlockingMutexLock l(&mtx_);
-  CHECK_LT(tid, n_contexts_);
   ThreadContextBase *tctx = threads_[tid];
   CHECK_NE(tctx, 0);
   CHECK_NE(tctx->status, ThreadStatusInvalid);
   CHECK_NE(tctx->status, ThreadStatusDead);
   CHECK_EQ(tctx->user_id, 0);
   tctx->user_id = user_id;
 }
 
 }  // namespace __sanitizer

compiler-rt/lib/sanitizer_common/tests/sanitizer_thread_registry_test.cpp

for (u32 i = 0; i < exp_total; i++) {
     EXPECT_EQ(main_thread, registry->FindThreadContextLocked(
         HasUid, (void*)get_uid(0)));
   }
   EXPECT_EQ(11U, registry->GetMaxAliveThreads());
 }
 
 TEST(SanitizerCommon, ThreadRegistryTest) {
   ThreadRegistry quarantine_registry(GetThreadContext<ThreadContextBase>,
-                                     kMaxRegistryThreads,
-                                     kRegistryQuarantine);
+                                     kMaxRegistryThreads, kRegistryQuarantine,
+                                     0);
   TestRegistry(&quarantine_registry, true);
 
   ThreadRegistry no_quarantine_registry(GetThreadContext<ThreadContextBase>,
                                         kMaxRegistryThreads,
-                                        kMaxRegistryThreads);
+                                        kMaxRegistryThreads, 0);
   TestRegistry(&no_quarantine_registry, false);
 }
 
 static const int kThreadsPerShard = 20;
 static const int kNumShards = 25;
 
 static int num_created[kNumShards + 1];
 static int num_started[kNumShards + 1];

 }
 
 TEST(SanitizerCommon, ThreadRegistryThreadedTest) {
   memset(&num_created, 0, sizeof(num_created));
   memset(&num_started, 0, sizeof(num_created));
   memset(&num_joined, 0, sizeof(num_created));
 
   ThreadRegistry registry(GetThreadContext<TestThreadContext>,
-                          kThreadsPerShard * kNumShards + 1, 10);
+                          kThreadsPerShard * kNumShards + 1, 10, 0);
   ThreadedTestRegistry(&registry);
 }
 
 }  // namespace __sanitizer