Cache tilde expansions to avoid redundant lookups

[jasonmolenda]

Summary

We have tilde's in our dSYMs internally, and expanding these can involve a network access that is slow for some people. I'm not worried about tilde expanding to a different filepath during the lifetime of a single lldb session, and I believe people will see very few different tildes ever expanded -- I'd be surprised if anyone exceed five different tilde's -- so this would be something easy to cache in lldb given how TildeExpressionResolver::ResolveFullPath() is structured.

This patch creates a simple vector of <ConstString, std::string>'s with the tilde names (ConstString to make comparisons cheap) and the expanded filepath. The method accepts a filepath as a StringRef and returns an expanded path in a SmallVectorImpl<char>, but I don't think the specific container used is important one way or the other. I'm not wedded to this impl though.

This bit of code has been untouched in years, but adding Jonas who did touch it a couple years ago.

rdar://77091379

[jingham]

I don't think the cache belongs in a global in the TildeExpressionResolver class. The derived ExpressionResolvers might very well resolve the same ~foo to different paths (e.g. if there were a RemoteTildeExpressionResolver.) So the cache needs to be kept in the derived class rather than in a global object. Maybe just add an abstract GetTildeCache method to TildeExpressionResolver to fetch the cache from the subclass?

[jasonmolenda]

Yeah, you're right. And as I walk through in my head what I'm solving with this -- it's not the really expensive part of this whole operation, I don't think. I should check more carefully but it's the stat's over NFS partitions that are impacting performance, and I doubt the realpath() to expand the tilde's is a significant factor (the kernel should cache all of these inodes anyway if we're doing it in a hot fashion). I'll probably abandon this altogether unless I can prove to myself that it's important, and hoist it into the base class.

lldb/source/Utility/TildeExpressionResolver.cpp

 //===-- TildeExpressionResolver.cpp ---------------------------------------===//
 //
 // 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 "lldb/Utility/TildeExpressionResolver.h"
 
 #include <cassert>
 #include <system_error>
 
+#include "lldb/Utility/ConstString.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 #if !defined(_WIN32)
 #include <pwd.h>
#else
   }
 
   return true;
 #endif
 }
 
 bool TildeExpressionResolver::ResolveFullPath(
     StringRef Expr, llvm::SmallVectorImpl<char> &Output) {
+  static std::vector<std::tuple<ConstString, std::string>> g_tildes_expanded;
   if (!Expr.startswith("~")) {
     Output.assign(Expr.begin(), Expr.end());
     return false;
   }
 
   namespace path = llvm::sys::path;
   StringRef Left =
       Expr.take_until([](char c) { return path::is_separator(c); });
 
+  ConstString tilde_name(Left);
+  std::string expanded_path;
+  for (const auto &it : g_tildes_expanded) {
+    if (std::get<0>(it) == tilde_name) {
+      expanded_path = std::get<1>(it);
+      break;
+    }
+  }
+
+  if (expanded_path.empty()) {
     if (!ResolveExact(Left, Output)) {
       Output.assign(Expr.begin(), Expr.end());
       return false;
     }
-
-  Output.append(Expr.begin() + Left.size(), Expr.end());
+    expanded_path = std::string(Output.data(), Output.size());
+    g_tildes_expanded.push_back(
+        std::tuple<ConstString, std::string>(tilde_name, expanded_path));
+  } else {
+    StringRef expanded_strref(expanded_path);
+    Output.assign(expanded_path.begin(), expanded_path.end());
+  }
+  Output.append(Expr.begin() + tilde_name.GetLength(), Expr.end());
   return true;
 }