[clangd] Prevent thread starvation in tests on loaded systems.

[sammccall]

Summary

Background index deliberately runs low-priority, but for tests this may stop
them making progress.

[kadircet]

clangd/tool/ClangdMain.cpp

357

Can we move this to the beginning of main, it seems like that's where we handle test specific adjustments, could be better to keep them in one place.

clangd/Threading.h

private:
   std::size_t InFlightTasks = 0;
 };
 
 enum class ThreadPriority {
   Low = 0,
   Normal = 1,
 };
 void setThreadPriority(std::thread &T, ThreadPriority Priority);
+// Avoid the use of scheduler policies that may starve low-priority threads.
+// This prevents tests from timing out on loaded systems.
+// Affects subsequent setThreadPriority() calls.
+void preventThreadStarvationInTests();
 
 } // namespace clangd
 } // namespace clang
 #endif

clangd/Threading.cpp

 #include "Threading.h"
 #include "Trace.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Threading.h"
+#include <atomic>
 #include <thread>
 #ifdef __USE_POSIX
 #include <pthread.h>
 #endif
 
 using namespace llvm;
 namespace clang {
 namespace clangd {
void wait(std::unique_lock<std::mutex> &Lock, std::condition_variable &CV,
           Deadline D) {
   if (D == Deadline::zero())
     return;
   if (D == Deadline::infinity())
     return CV.wait(Lock);
   CV.wait_until(Lock, D.time());
 }
 
+static std::atomic<bool> AvoidThreadStarvation = {false};
+
 void setThreadPriority(std::thread &T, ThreadPriority Priority) {
   // Some *really* old glibcs are missing SCHED_IDLE.
 #if defined(__linux__) && defined(SCHED_IDLE)
   sched_param priority;
   priority.sched_priority = 0;
   pthread_setschedparam(
       T.native_handle(),
-      Priority == ThreadPriority::Low ? SCHED_IDLE : SCHED_OTHER, &priority);
+      Priority == ThreadPriority::Low && !AvoidThreadStarvation ? SCHED_IDLE
+                                                                : SCHED_OTHER,
+      &priority);
 #endif
 }
 
+void preventThreadStarvationInTests() { AvoidThreadStarvation = true; }
+
 } // namespace clangd
 } // namespace clang

clangd/tool/ClangdMain.cpp

cl::ParseCommandLineOptions(
       "directly. "
       "For more information, see:"
       "\n\thttps://clang.llvm.org/extra/clangd.html"
       "\n\thttps://microsoft.github.io/language-server-protocol/");
   if (Test) {
     RunSynchronously = true;
     InputStyle = JSONStreamStyle::Delimited;
     PrettyPrint = true;
+    preventThreadStarvationInTests(); // Ensure background index makes progress.
   }
   if (Test || EnableTestScheme) {
     static URISchemeRegistry::Add<TestScheme> X(
         "test", "Test scheme for clangd lit tests.");
   }
 
   if (!RunSynchronously && WorkerThreadsCount == 0) {
     errs() << "A number of worker threads cannot be 0. Did you mean to "
int main(int argc, char *argv[]) {
   }
   if (!ResourceDir.empty())
     Opts.ResourceDir = ResourceDir;
   Opts.BuildDynamicSymbolIndex = EnableIndex;
   Opts.HeavyweightDynamicSymbolIndex = UseDex;
   Opts.BackgroundIndex = EnableBackgroundIndex;
   std::unique_ptr<SymbolIndex> StaticIdx;
   std::future<void> AsyncIndexLoad; // Block exit while loading the index.
   if (EnableIndex && !IndexFile.empty()) {
     // Load the index asynchronously. Meanwhile SwapIndex returns no results.
     SwapIndex *Placeholder;
     StaticIdx.reset(Placeholder = new SwapIndex(llvm::make_unique<MemIndex>()));
     AsyncIndexLoad = runAsync<void>([Placeholder] {
       if (auto Idx = loadIndex(IndexFile, /*UseDex=*/true))
         Placeholder->reset(std::move(Idx));
     });
     if (RunSynchronously)

unittests/clangd/BackgroundIndexTests.cpp

if (!IndexFile) {
                     << IndexFile.takeError();
       return nullptr;
     }
     CacheHits++;
     return llvm::make_unique<IndexFileIn>(std::move(*IndexFile));
   }
 };
 
-TEST(BackgroundIndexTest, IndexTwoFiles) {
+class BackgroundIndexTest : public ::testing::Test {
+protected:
+  BackgroundIndexTest() { preventThreadStarvationInTests(); }
+};
+
+TEST_F(BackgroundIndexTest, IndexTwoFiles) {
   MockFSProvider FS;
   // a.h yields different symbols when included by A.cc vs B.cc.
   FS.Files[testPath("root/A.h")] = R"cpp(
       void common();
       void f_b();
       #if A
         class A_CC {};
       #else
TEST_F(BackgroundIndexTest, IndexTwoFiles) {
   EXPECT_THAT(Syms, UnorderedElementsAre(Named("common")));
   auto Common = *Syms.begin();
   EXPECT_THAT(getRefs(Idx, Common.ID),
               RefsAre({FileURI("unittest:///root/A.h"),
                        FileURI("unittest:///root/A.cc"),
                        FileURI("unittest:///root/B.cc")}));
 }
 
-TEST(BackgroundIndexTest, ShardStorageWriteTest) {
+TEST_F(BackgroundIndexTest, ShardStorageWriteTest) {
   MockFSProvider FS;
   FS.Files[testPath("root/A.h")] = R"cpp(
       void common();
       void f_b();
       class A_CC {};
       )cpp";
   std::string A_CC = "#include \"A.h\"\nvoid g() { (void)common; }";
   FS.Files[testPath("root/A.cc")] = A_CC;