[Tooling] Optimize memory usage in InMemoryToolResults.

[hokein]

Summary

Avoid storing duplicated "std::string"s.

Previsouly, clangd's global-symbol-builder consumes 20+GB memory when running across LLVM repository.
With this patch, the used memory is reduced to ~10GB (running on 48 threads, most of memory are AST-related).

[hokein]

Update.

[ilya-biryukov]

This definitely helps with memory consumption of clangd's global-symbol-indexer, I can now run it over LLVM on MacBook without it swapping out of RAM. The physical memory usage goes up to 3GB at some point, before it was > 20GB.

Strictly speaking, interning the strings is probably more work for some workloads, so I'm not sure it's a better in all cases.
On average this LG, though, so LGTM from my side.

[sammccall]

include/clang/Tooling/Execution.h

58

please add a high-level comment explaining what this is caching and when we expect it to work well.

[hokein]

Add a comment.

include/clang/Tooling/Execution.h

 
 #ifndef LLVM_CLANG_TOOLING_EXECUTION_H
 #define LLVM_CLANG_TOOLING_EXECUTION_H
 
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Registry.h"
+#include "llvm/Support/StringSaver.h"
 
 namespace clang {
 namespace tooling {
 
 /// \brief An abstraction for the result of a tool execution. For example, the
 /// underlying result can be in-memory or on-disk.
 ///
 /// Results should be string key-value pairs. For example, a refactoring tool
 /// can use source location as key and a replacement in YAML format as value.
 class ToolResults {
 public:
   virtual ~ToolResults() = default;
   virtual void addResult(StringRef Key, StringRef Value) = 0;
-  virtual std::vector<std::pair<std::string, std::string>> AllKVResults() = 0;
+  virtual std::vector<std::pair<llvm::StringRef, llvm::StringRef>>
+  AllKVResults() = 0;
   virtual void forEachResult(
       llvm::function_ref<void(StringRef Key, StringRef Value)> Callback) = 0;
 };
 
+/// \brief Stores the key-value results in memory. It maintains the lifetime of
+/// the result. Clang tools using this class are expected to generate a small
+/// set of different results, or a large set of duplicated results.
 class InMemoryToolResults : public ToolResults {
 public:
+  InMemoryToolResults() : StringsPool(Arena) {}
   void addResult(StringRef Key, StringRef Value) override;
-  std::vector<std::pair<std::string, std::string>> AllKVResults() override;
+  std::vector<std::pair<llvm::StringRef, llvm::StringRef>>
+  AllKVResults() override;
   void forEachResult(llvm::function_ref<void(StringRef Key, StringRef Value)>
                          Callback) override;
 
 private:
-  std::vector<std::pair<std::string, std::string>> KVResults;
+  llvm::BumpPtrAllocator Arena;
+  llvm::StringSaver StringsPool;
+  llvm::DenseSet<llvm::StringRef> Strings;
+
+  std::vector<std::pair<llvm::StringRef, llvm::StringRef>> KVResults;
 };
 
 /// \brief The context of an execution, including the information about
 /// compilation and results.
 class ExecutionContext {
 public:
   virtual ~ExecutionContext() {}
 

lib/Tooling/AllTUsExecution.cpp

 
 class ThreadSafeToolResults : public ToolResults {
 public:
   void addResult(StringRef Key, StringRef Value) override {
     std::unique_lock<std::mutex> LockGuard(Mutex);
     Results.addResult(Key, Value);
   }
 
-  std::vector<std::pair<std::string, std::string>> AllKVResults() override {
+  std::vector<std::pair<llvm::StringRef, llvm::StringRef>>
+  AllKVResults() override {
     return Results.AllKVResults();
   }
 
   void forEachResult(llvm::function_ref<void(StringRef Key, StringRef Value)>
                          Callback) override {
     Results.forEachResult(Callback);
   }
 

lib/Tooling/Execution.cpp

 namespace clang {
 namespace tooling {
 
 static llvm::cl::opt<std::string>
     ExecutorName("executor", llvm::cl::desc("The name of the executor to use."),
                  llvm::cl::init("standalone"));
 
 void InMemoryToolResults::addResult(StringRef Key, StringRef Value) {
-  KVResults.push_back({Key.str(), Value.str()});
+  auto Intern = [&](StringRef &V) {
+    auto R = Strings.insert(V);
+    if (R.second) { // A new entry, create a new string copy.
+      *R.first = StringsPool.save(V);
+    }
+    V = *R.first;
+  };
+  Intern(Key);
+  Intern(Value);
+  KVResults.push_back({Key, Value});
 }
 
-std::vector<std::pair<std::string, std::string>>
+std::vector<std::pair<llvm::StringRef, llvm::StringRef>>
 InMemoryToolResults::AllKVResults() {
   return KVResults;
 }
 
 void InMemoryToolResults::forEachResult(
     llvm::function_ref<void(StringRef Key, StringRef Value)> Callback) {
   for (const auto &KV : KVResults) {
     Callback(KV.first, KV.second);