[clangd] Control the delay between index hot reloading in remote-server-index

[kbobyrev]

Summary

This helps reduce the time needed for remote-server-index shutdown.

[kadircet]

clang-tools-extra/clangd/index/remote/server/Server.cpp

78

this was 30 before. not that it matters.

79

i think this might be useful in general, as servers will have different pull frequency for newer index. so maybe make it non-hidden.

clang-tools-extra/clangd/test/remote-index/pipeline_helper.py

35

let's set it to 1. clangd tests already takes about 3-4 seconds to run on (our) workstations. it feels like this might end up increasing the test latency.

[kbobyrev]

As discussed in PM, it probably doesn't make sense right now.

clang-tools-extra/clangd/index/remote/server/Server.cpp

 //===--- Server.cpp - gRPC-based Remote Index Server  ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Index.pb.h"
 #include "Service.grpc.pb.h"
 #include "index/Index.h"
 #include "index/Serialization.h"
 #include "index/Symbol.h"
 #include "index/remote/marshalling/Marshalling.h"
 #include "support/Logger.h"
 #include "support/Shutdown.h"
 #include "support/ThreadsafeFS.h"
llvm::cl::opt<bool> PrettyPrint{
     llvm::cl::desc("Pretty-print JSON output in the trace"),
     llvm::cl::init(false),
 };
 
 llvm::cl::opt<std::string> ServerAddress(
     "server-address", llvm::cl::init("0.0.0.0:50051"),
     llvm::cl::desc("Address of the invoked server. Defaults to 0.0.0.0:50051"));
 
+llvm::cl::opt<unsigned> HotReloadFrequency{
+    "hot-reload-frequency",
+    llvm::cl::desc("Delay between index hot reload checks (in seconds)"),
+    llvm::cl::init(90),
+    llvm::cl::Hidden,
+};
+
 class RemoteIndexServer final : public v1::SymbolIndex::Service {
 public:
   RemoteIndexServer(clangd::SymbolIndex &Index, llvm::StringRef IndexRoot)
       : Index(Index) {
     llvm::SmallString<256> NativePath = IndexRoot;
     llvm::sys::path::native(NativePath);
     ProtobufMarshaller = std::unique_ptr<Marshaller>(new Marshaller(
         /*RemoteIndexRoot=*/llvm::StringRef(NativePath),
int main(int argc, char *argv[]) {
   auto Index = std::make_unique<clang::clangd::SwapIndex>(
       clang::clangd::loadIndex(IndexPath));
 
   if (!Index) {
     llvm::errs() << "Failed to open the index.\n";
     return -1;
   }
 
-  std::thread HotReloadThread([&Index, &Status, &FS]() {
+  const auto RefreshFrequency = std::chrono::seconds(HotReloadFrequency);
+  std::thread HotReloadThread([&Index, &Status, &FS, &RefreshFrequency]() {
     llvm::vfs::Status LastStatus = *Status;
-    static constexpr auto RefreshFrequency = std::chrono::seconds(30);
     while (!clang::clangd::shutdownRequested()) {
       hotReload(*Index, llvm::StringRef(IndexPath), LastStatus, FS);
       std::this_thread::sleep_for(RefreshFrequency);
     }
   });
 
   runServerAndWait(*Index, ServerAddress, IndexPath);
 
   HotReloadThread.join();
 }

clang-tools-extra/clangd/test/remote-index/pipeline_helper.py

def main():
 
   # Grab an available port.
   with socket() as s:
     s.bind(('localhost', 0))
     server_address = 'localhost:' + str(s.getsockname()[1])
 
   index_server_process = subprocess.Popen([
       'clangd-index-server', '--server-address=' + server_address,
-      args.index_file, args.project_root
+      '--hot-reload-frequency=3', args.index_file, args.project_root
   ],
                                           stderr=subprocess.PIPE)
 
   # Wait for the server to warm-up.
   time.sleep(4)
   found_init_message = False
   for line in index_server_process.stderr:
     if b'Server listening' in line: