[llvm][clang] Trace VFS calls

jansvoboda11 · jansvoboda11 · commit 540321e84dbd · 2024-04-10T16:03:19.000-07:00
diff --git a/clang/include/clang/Driver/Compilation.h b/clang/include/clang/Driver/Compilation.h
@@ -115,6 +115,9 @@ class Compilation {
   /// -ftime-trace result files.
   ArgStringMap TimeTraceFiles;
 
+  /// -fvfs-trace result files.
+  ArgStringMap VFSTraceFiles;
+
   /// Optional redirection for stdin, stdout, stderr.
   std::vector<std::optional<StringRef>> Redirects;
 
@@ -280,6 +283,14 @@ class Compilation {
     TimeTraceFiles[JA] = Name;
   }
 
+  const char *getVFSTraceFile(const JobAction *JA) const {
+    return VFSTraceFiles.lookup(JA);
+  }
+  void addVFSTraceFile(const char *Name, const JobAction *JA) {
+    assert(!VFSTraceFiles.contains(JA));
+    VFSTraceFiles[JA] = Name;
+  }
+
   /// CleanupFile - Delete a given file.
   ///
   /// \param IssueErrors - Report failures as errors.
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
@@ -3904,6 +3904,13 @@ def ftime_trace_EQ : Joined<["-"], "ftime-trace=">, Group<f_Group>,
   HelpText<"Similar to -ftime-trace. Specify the JSON file or a directory which will contain the JSON file">,
   Visibility<[ClangOption, CC1Option, CLOption, DXCOption]>,
   MarshallingInfoString<FrontendOpts<"TimeTracePath">>;
+def fvfs_trace : Flag<["-"], "fvfs-trace">, Group<f_Group>,
+  HelpText<"Turn of virtual file system profiler. Generates text file based on output filename.">,
+  Visibility<[ClangOption, CLOption, DXCOption]>;
+def fvfs_trace_EQ : Joined<["-"], "fvfs-trace=">, Group<f_Group>,
+  HelpText<"Similar to -fvfs-trace. Specify the text file or a directory that will contain the text file">,
+  Visibility<[ClangOption, CC1Option, CLOption, DXCOption]>,
+  MarshallingInfoString<FrontendOpts<"VFSTracePath">>;
 def fproc_stat_report : Joined<["-"], "fproc-stat-report">, Group<f_Group>,
   HelpText<"Print subprocess statistics">;
 def fproc_stat_report_EQ : Joined<["-"], "fproc-stat-report=">, Group<f_Group>,
diff --git a/clang/include/clang/Frontend/CompilerInstance.h b/clang/include/clang/Frontend/CompilerInstance.h
@@ -35,6 +35,9 @@ namespace llvm {
 class raw_fd_ostream;
 class Timer;
 class TimerGroup;
+namespace vfs {
+struct InstrumentingFileSystem;
+}
 }
 
 namespace clang {
@@ -89,6 +92,11 @@ class CompilerInstance : public ModuleLoader {
   /// Auxiliary Target info.
   IntrusiveRefCntPtr<TargetInfo> AuxTarget;
 
+public:
+  /// The instrumenting file system.
+  IntrusiveRefCntPtr<llvm::vfs::InstrumentingFileSystem> IVFS;
+private:
+
   /// The file manager.
   IntrusiveRefCntPtr<FileManager> FileMgr;
 
diff --git a/clang/include/clang/Frontend/CompilerInvocation.h b/clang/include/clang/Frontend/CompilerInvocation.h
@@ -39,6 +39,7 @@ class ArgList;
 namespace vfs {
 
 class FileSystem;
+struct InstrumentingFileSystem;
 
 } // namespace vfs
 
@@ -390,13 +391,14 @@ class CowCompilerInvocation : public CompilerInvocationBase {
   /// @}
 };
 
-IntrusiveRefCntPtr<llvm::vfs::FileSystem>
-createVFSFromCompilerInvocation(const CompilerInvocation &CI,
-                                DiagnosticsEngine &Diags);
+IntrusiveRefCntPtr<llvm::vfs::FileSystem> createVFSFromCompilerInvocation(
+    const CompilerInvocation &CI, DiagnosticsEngine &Diags,
+    IntrusiveRefCntPtr<llvm::vfs::InstrumentingFileSystem> *TracingFS = {});
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem> createVFSFromCompilerInvocation(
     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
-    IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
+    IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS,
+    IntrusiveRefCntPtr<llvm::vfs::InstrumentingFileSystem> *TracingFS = {});
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 createVFSFromOverlayFiles(ArrayRef<std::string> VFSOverlayFiles,
diff --git a/clang/include/clang/Frontend/FrontendOptions.h b/clang/include/clang/Frontend/FrontendOptions.h
@@ -568,6 +568,9 @@ class FrontendOptions {
   /// Path which stores the output files for -ftime-trace
   std::string TimeTracePath;
 
+  /// Path which stores the output files for -fvfs-trace
+  std::string VFSTracePath;
+
 public:
   FrontendOptions()
       : DisableFree(false), RelocatablePCH(false), ShowHelp(false),
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
@@ -5429,6 +5429,36 @@ static void handleTimeTrace(Compilation &C, const ArgList &Args,
   C.addResultFile(ResultFile, JA);
 }
 
+static void handleVFSTrace(Compilation &C, const ArgList &Args,
+                           const JobAction *JA, const char *BaseInput,
+                           const InputInfo &Result) {
+  Arg *A = Args.getLastArg(options::OPT_fvfs_trace, options::OPT_fvfs_trace_EQ);
+  if (!A)
+    return;
+  SmallString<128> Path;
+  if (A->getOption().matches(options::OPT_fvfs_trace_EQ)) {
+    Path = A->getValue();
+    if (llvm::sys::fs::is_directory(Path)) {
+      SmallString<128> Tmp(Result.getFilename());
+      llvm::sys::path::replace_extension(Tmp, "vfs.txt");
+      llvm::sys::path::append(Path, llvm::sys::path::filename(Tmp));
+    }
+  } else {
+    if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
+      // The trace file is ${dumpdir}${basename}.vfs.txt. Note that dumpdir may
+      // not end with a path separator.
+      Path = DumpDir->getValue();
+      Path += llvm::sys::path::filename(BaseInput);
+    } else {
+      Path = Result.getFilename();
+    }
+    llvm::sys::path::replace_extension(Path, "vfs.txt");
+  }
+  const char *ResultFile = C.getArgs().MakeArgString(Path);
+  C.addVFSTraceFile(ResultFile, JA);
+  C.addResultFile(ResultFile, JA);
+}
+
 InputInfoList Driver::BuildJobsForActionNoCache(
     Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch,
     bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput,
@@ -5678,8 +5708,10 @@ InputInfoList Driver::BuildJobsForActionNoCache(
                                              AtTopLevel, MultipleArchs,
                                              OffloadingPrefix),
                        BaseInput);
-    if (T->canEmitIR() && OffloadingPrefix.empty())
+    if (T->canEmitIR() && OffloadingPrefix.empty()) {
       handleTimeTrace(C, Args, JA, BaseInput, Result);
+      handleVFSTrace(C, Args, JA, BaseInput, Result);
+    }
   }
 
   if (CCCPrintBindings && !CCGenDiagnostics) {
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -6759,6 +6759,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
     Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
   }
 
+  if (const char *Name = C.getVFSTraceFile(&JA))
+    CmdArgs.push_back(Args.MakeArgString("-fvfs-trace=" + Twine(Name)));
+
   if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
     CmdArgs.push_back("-ftrapv-handler");
     CmdArgs.push_back(A->getValue());
diff --git a/clang/lib/Frontend/CompilerInstance.cpp b/clang/lib/Frontend/CompilerInstance.cpp
@@ -379,7 +379,7 @@ FileManager *CompilerInstance::createFileManager(
   if (!VFS)
     VFS = FileMgr ? &FileMgr->getVirtualFileSystem()
                   : createVFSFromCompilerInvocation(getInvocation(),
-                                                    getDiagnostics());
+                                                    getDiagnostics(), &IVFS);
   assert(VFS && "FileManager has no VFS?");
   FileMgr = new FileManager(getFileSystemOpts(), std::move(VFS));
   return FileMgr.get();
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -4935,16 +4935,25 @@ void CompilerInvocation::clearImplicitModuleBuildOptions() {
 }
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
-clang::createVFSFromCompilerInvocation(const CompilerInvocation &CI,
-                                       DiagnosticsEngine &Diags) {
-  return createVFSFromCompilerInvocation(CI, Diags,
-                                         llvm::vfs::getRealFileSystem());
+clang::createVFSFromCompilerInvocation(
+    const CompilerInvocation &CI, DiagnosticsEngine &Diags,
+    IntrusiveRefCntPtr<llvm::vfs::InstrumentingFileSystem> *TracingFS) {
+  return createVFSFromCompilerInvocation(
+      CI, Diags, llvm::vfs::getRealFileSystem(), TracingFS);
 }
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 clang::createVFSFromCompilerInvocation(
     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
-    IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) {
+    IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS,
+    IntrusiveRefCntPtr<llvm::vfs::InstrumentingFileSystem> *TracingFS) {
+  if (!CI.getFrontendOpts().VFSTracePath.empty()) {
+    auto TFS = llvm::makeIntrusiveRefCnt<llvm::vfs::InstrumentingFileSystem>(
+        std::move(BaseFS));
+    if (TracingFS)
+      *TracingFS = TFS;
+    BaseFS = std::move(TFS);
+  }
   return createVFSFromOverlayFiles(CI.getHeaderSearchOpts().VFSOverlayFiles,
                                    Diags, std::move(BaseFS));
 }
diff --git a/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp b/clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp
@@ -338,6 +338,7 @@ class DependencyScanningAction : public tooling::ToolAction {
     ScanInstance.getFrontendOpts().GenerateGlobalModuleIndex = false;
     ScanInstance.getFrontendOpts().UseGlobalModuleIndex = false;
     ScanInstance.getFrontendOpts().ModulesShareFileManager = false;
+    ScanInstance.getFrontendOpts().VFSTracePath.clear();
     ScanInstance.getHeaderSearchOpts().ModuleFormat = "raw";
     ScanInstance.getHeaderSearchOpts().ModulesIncludeVFSUsage =
         any(OptimizeArgs & ScanningOptimizations::VFS);
diff --git a/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp b/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
@@ -152,6 +152,11 @@ void ModuleDepCollector::addOutputPaths(CowCompilerInvocation &CI,
       CI.getMutDependencyOutputOpts().Targets.push_back(std::string(Target));
     }
   }
+  if (!CI.getMutFrontendOpts().VFSTracePath.empty()) {
+    SmallString<128> VFSTracePath{CI.getMutFrontendOpts().OutputFile};
+    llvm::sys::path::replace_extension(VFSTracePath, "vfs.txt");
+    CI.getMutFrontendOpts().VFSTracePath = VFSTracePath.str();
+  }
 }
 
 static CowCompilerInvocation
@@ -186,6 +191,8 @@ makeCommonInvocationForModuleBuild(CompilerInvocation CI) {
     CI.getDiagnosticOpts().DiagnosticSerializationFile = "-";
   if (!CI.getDependencyOutputOpts().OutputFile.empty())
     CI.getDependencyOutputOpts().OutputFile = "-";
+  if (!CI.getFrontendOpts().VFSTracePath.empty())
+    CI.getFrontendOpts().VFSTracePath = "-";
   CI.getDependencyOutputOpts().Targets.clear();
 
   CI.getFrontendOpts().ProgramAction = frontend::GenerateModule;
diff --git a/clang/test/ClangScanDeps/modules-inferred.m b/clang/test/ClangScanDeps/modules-inferred.m
@@ -21,7 +21,7 @@
 [{
   "directory": "DIR",
   "file": "DIR/tu.m",
-  "command": "clang -fmodules -fimplicit-module-maps -fmodules-cache-path=DIR/cache -F DIR/frameworks -c DIR/tu.m -o DIR/tu.o"
+  "command": "clang -fmodules -fimplicit-module-maps -fmodules-cache-path=DIR/cache -F DIR/frameworks -c DIR/tu.m -o DIR/tu.o -fvfs-trace"
 }]
 
 // RUN: sed "s|DIR|%/t|g" %t/cdb.json.template > %t/cdb.json
diff --git a/clang/tools/clang-scan-deps/ClangScanDeps.cpp b/clang/tools/clang-scan-deps/ClangScanDeps.cpp
@@ -84,6 +84,7 @@ static std::vector<std::string> ModuleDepTargets;
 static bool DeprecatedDriverCommand;
 static ResourceDirRecipeKind ResourceDirRecipe;
 static bool Verbose;
+static bool PrintVFSTrace;
 static bool PrintTiming;
 static std::vector<const char *> CommandLine;
 
@@ -219,6 +220,8 @@ static void ParseArgs(int argc, char **argv) {
     ResourceDirRecipe = *Kind;
   }
 
+  PrintVFSTrace = Args.hasArg(OPT_vfs_trace);
+
   PrintTiming = Args.hasArg(OPT_print_timing);
 
   Verbose = Args.hasArg(OPT_verbose);
@@ -886,8 +889,16 @@ int clang_scan_deps_main(int argc, char **argv, const llvm::ToolContext &) {
   if (Format == ScanningOutputFormat::Full)
     FD.emplace(ModuleName.empty() ? Inputs.size() : 0);
 
+  std::atomic<std::size_t> NumStatusCalls = 0;
+  std::atomic<std::size_t> NumOpenCalls = 0;
+  std::atomic<std::size_t> NumDirBeginCalls = 0;
+  std::atomic<std::size_t> NumRealPathCalls = 0;
+
   auto ScanningTask = [&](DependencyScanningService &Service) {
-    DependencyScanningTool WorkerTool(Service);
+    auto TracingFS =
+        llvm::makeIntrusiveRefCnt<llvm::vfs::InstrumentingFileSystem>(
+            llvm::vfs::createPhysicalFileSystem());
+    DependencyScanningTool WorkerTool(Service, TracingFS);
 
     llvm::DenseSet<ModuleID> AlreadySeenModules;
     while (auto MaybeInputIndex = GetNextInputIndex()) {
@@ -970,6 +981,11 @@ int clang_scan_deps_main(int argc, char **argv, const llvm::ToolContext &) {
           HadErrors = true;
       }
     }
+
+    NumStatusCalls += TracingFS->NumStatusCalls;
+    NumOpenCalls += TracingFS->NumOpenCalls;
+    NumDirBeginCalls += TracingFS->NumDirBeginCalls;
+    NumRealPathCalls += TracingFS->NumRealPathCalls;
   };
 
   DependencyScanningService Service(ScanMode, Format, OptimizeArgs,
@@ -1001,6 +1017,13 @@ int clang_scan_deps_main(int argc, char **argv, const llvm::ToolContext &) {
         "clang-scan-deps timing: %0.2fs wall, %0.2fs process\n",
         T.getTotalTime().getWallTime(), T.getTotalTime().getProcessTime());
 
+  if (PrintVFSTrace)
+    llvm::errs() << llvm::format(
+        "clang-scan-deps VFS trace: %d status, %d openFileForRead, %d "
+        "dir_begin, %d getRealPath\n",
+        NumStatusCalls.load(), NumOpenCalls.load(), NumDirBeginCalls.load(),
+        NumRealPathCalls.load());
+
   if (RoundTripArgs)
     if (FD && FD->roundTripCommands(llvm::errs()))
       HadErrors = true;
diff --git a/clang/tools/clang-scan-deps/Opts.td b/clang/tools/clang-scan-deps/Opts.td
@@ -31,6 +31,7 @@ def deprecated_driver_command : F<"deprecated-driver-command", "use a single dri
 
 defm resource_dir_recipe : Eq<"resource-dir-recipe", "How to produce missing '-resource-dir' argument">;
 
+def vfs_trace: F<"fvfs-trace", "Profile virtual file system calls">;
 def print_timing : F<"print-timing", "Print timing information">;
 
 def verbose : F<"v", "Use verbose output">;
diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp
@@ -261,6 +261,19 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
     }
   }
 
+  if (!Clang->getFrontendOpts().VFSTracePath.empty()) {
+    assert(Clang->IVFS);
+    if (auto VFSOutput = Clang->createOutputFile(
+            Clang->getFrontendOpts().VFSTracePath, /*Binary=*/false,
+            /*RemoveFileOnSignal=*/false,
+            /*useTemporary=*/false)) {
+      *VFSOutput << "status\t" << Clang->IVFS->NumStatusCalls << "\n"
+                 << "openFileForRead\t" << Clang->IVFS->NumOpenCalls << "\n"
+                 << "dir_begin\t" << Clang->IVFS->NumDirBeginCalls << "\n"
+                 << "getRealPath\t" << Clang->IVFS->NumRealPathCalls << "\n";
+    }
+  }
+
   // Our error handler depends on the Diagnostics object, which we're
   // potentially about to delete. Uninstall the handler now so that any
   // later errors use the default handling behavior instead.
diff --git a/llvm/include/llvm/Support/VirtualFileSystem.h b/llvm/include/llvm/Support/VirtualFileSystem.h
@@ -26,6 +26,7 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
+#include <atomic>
 #include <cassert>
 #include <cstdint>
 #include <ctime>
@@ -1125,6 +1126,34 @@ class YAMLVFSWriter {
   void write(llvm::raw_ostream &OS);
 };
 
+/// File system that tracks the number of calls to the underlying file system.
+/// This is particularly useful when wrapped around \c RealFileSystem to add
+/// lightweight tracking of expensive syscalls.
+struct InstrumentingFileSystem
+    : llvm::RTTIExtends<InstrumentingFileSystem, OverlayFileSystem> {
+  static const char ID;
+
+  std::atomic<std::size_t> NumStatusCalls = 0;
+  std::atomic<std::size_t> NumOpenCalls = 0;
+  std::atomic<std::size_t> NumDirBeginCalls = 0;
+  mutable std::atomic<std::size_t> NumRealPathCalls = 0;
+
+  InstrumentingFileSystem(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS);
+
+  ErrorOr<Status> status(const Twine &Path) override;
+
+  ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override;
+
+  directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
+
+  std::error_code getRealPath(const Twine &Path,
+                              SmallVectorImpl<char> &Output) const override;
+
+protected:
+  void printImpl(raw_ostream &OS, PrintType Type,
+                 unsigned IndentLevel) const override;
+};
+
 } // namespace vfs
 } // namespace llvm
 
diff --git a/llvm/lib/Support/VirtualFileSystem.cpp b/llvm/lib/Support/VirtualFileSystem.cpp
diff --git a/llvm/unittests/Support/VirtualFileSystemTest.cpp b/llvm/unittests/Support/VirtualFileSystemTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -6759,6 +6759,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,`
`6759`	`6759`	`Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);`
`6760`	`6760`	`}`
`6761`	`6761`
	`6762`	`+ if (const char *Name = C.getVFSTraceFile(&JA))`
	`6763`	`+ CmdArgs.push_back(Args.MakeArgString("-fvfs-trace=" + Twine(Name)));`
	`6764`	`+`
`6762`	`6765`	`if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {`
`6763`	`6766`	`CmdArgs.push_back("-ftrapv-handler");`
`6764`	`6767`	`CmdArgs.push_back(A->getValue());`