[RFC] Adding time-trace to LLD?

[russell.gallop]

Summary

The clang -ftime-trace feature is useful for analysing build time in compiles. I've been experimenting with adding time-trace support to LLD for analysing link times.

Adding the option -time-trace produces a .json file alongside the output ELF file (just ELF so far). This works for LTO and ThinLTO, picking up the relevant markers from LLVM. Example ThinLTO build:

This is still work in progress so shouldn't be submitted in its present state. There are a few things that still need doing:

• Improve how events are collected. (The current method combines multiple threads (ThinLTO) in one stack with a mutex which won't scale well. Making this thread local would probably be better.)
• Adding test(s)
• Re-enable the assertion for monotonically increasing times which I don't have working yet.

Do people think that this will be useful/worth pursuing?

[ruiu]

This seems useful. Can I see an example output?

Speaking of the output file, I'd make --time-trace option to take an output filename, as an output executable doesn't always have an extension (On Windows it's almost always .exe, but on Unix, extension is usually omitted).

[russell.gallop]

In D69043#1712542, @ruiu wrote:

This seems useful. Can I see an example output?

Thanks.

Here's an example from Building clang with ThinLTO:

clang-10.json1 MBDownload

Using linker flags: -Wl,-time-trace -Wl,-time-trace-granularity=50000

I increased the granularity from the default, otherwise the trace gets very large (~800MiB).

Speaking of the output file, I'd make --time-trace option to take an output filename, as an output executable doesn't always have an extension (On Windows it's almost always .exe, but on Unix, extension is usually omitted).

Okay. I'll look at doing that.

[aganea]

lld/ELF/Driver.cpp

515

Could you possibly move this block (and the init block above) into a new file in lld/Common/ so we can use it in the COFF driver as well?

527

Extraneous return.

lld/ELF/Options.td

361

Given this option is a candidate for the other LLD drivers, I am wondering if we couldn't have a shared lld/Common/CommonOpt.td. @ruiu WDYT?

llvm/lib/Support/TimeProfiler.cpp

70

The lock is definitely not the way to go, it would skew all the timings especially on tens-of-cores machines. Like you're suggesting, make TimeTraceProfilerInstance a TLS, along with a new combiner upon the call to timeTraceProfilerWrite().

[ruiu]

I applied this patch and built clang with ThinLTO. Here is the generated file:

$ less bin/clang-10.json
{"traceEvents":[{"pid":1,"tid":185412,"ph":"X","ts":181,"dur":1441864,"name":"Parse input files","args":{"detail":""}},{"pid":1,"tid":185412,"ph":"X","ts":12564626,"dur":541606,"name":"OptModule","args":{"detail":"ld-temp.o"}},{"pid":1,"tid":185412,"ph":"X","ts":1454232,"dur":17946238,"name":"LTO","args":{"detail":""}},{"pid":1,"tid":185412,"ph":"X","ts":19461534,"dur":15275,"name":"GC","args":{"detail":""}},{"pid":1,"tid":185412,"ph":"X","ts":19721702,"dur":1241569,"name":"Write output file","args":{"detail":""}},{"pid":1,"tid":185412,"ph":"X","ts":2,"dur":20963276,"name":"ExecuteLinker","args":{"detail":""}},{"pid":1,"tid":185413,"ph":"X","ts":0,"dur":20963276,"name":"Total ExecuteLinker","args":{"count":1,"avg ms":20963}},{"pid":1,"tid":185414,"ph":"X","ts":0,"dur":17946237,"name":"Total LTO","args":{"count":1,"avg ms":17946}},{"pid":1,"tid":185415,"ph":"X","ts":0,"dur":1441864,"name":"Total Parse input files","args":{"count":1,"avg ms":1441}},{"pid":1,"tid":185416,"ph":"X","ts":0,"dur":1241569,"name":"Total Write output file","args":{"count":1,"avg ms":1241}},{"pid":1,"tid":185417,"ph":"X","ts":0,"dur":541704,"name":"Total OptModule","args":{"count":2,"avg ms":270}},{"pid":1,"tid":185418,"ph":"X","ts":0,"dur":15274,"name":"Total GC","args":{"count":1,"avg ms":15}},{"cat":"","pid":1,"tid":0,"ts":0,"ph":"M","name":"process_name","args":{"name":"ld.lld"}}]}

This file seems much smaller than yours. What am I missing? (I couldn't download your file because the server times out perhaps due to the file size.)

[ruiu]

lld/ELF/Options.td

361

In many cases command line options are slightly different among drivers. so currently we have a completely separated option file for each driver. It looks like maintaining each file separately makes things much easier, so I wouldn't create a new common file.

[russell.gallop]

In D69043#1714060, @ruiu wrote:

I applied this patch and built clang with ThinLTO. Here is the generated file:
This file seems much smaller than yours. What am I missing?

I have seen some very empty looking traces when ThinLTO doesn't have much to do. Is it possible that the ThinLTO cache is doing a very good job?

(I couldn't download your file because the server times out perhaps due to the file size.)

That's odd. I can download it okay from here.

[grimar]

In D69043#1714134, @russell.gallop wrote:

In D69043#1714060, @ruiu wrote:

(I couldn't download your file because the server times out perhaps due to the file size.)

That's odd. I can download it okay from here.

It probably was a temporary issue. I was unable to download it ~2h ago too, but now it works fine for me.

[russell.gallop]

I've re-implemented this using thread local time tracing.

Have broken the changes down into a couple of patches.

Preliminaries:
https://reviews.llvm.org/D70904 - Tidying up in TimeProfiler.cpp
https://reviews.llvm.org/D70950 - Add ProcName to TimeTraceProfiler

Main change:
https://reviews.llvm.org/D71059 - [LLD][ELF] Add time-trace to ELF LLD (1/2) (multi-thread support in TimeProfiler)
https://reviews.llvm.org/D71060 - [LLD][ELF] Add time-trace to ELF LLD (2/2) (Add time trace to LLD)

[russell.gallop]

This was submitted as the sequence of patches:
https://reviews.llvm.org/D70904 - Tidying up in TimeProfiler.cpp
https://reviews.llvm.org/D70950 - Add ProcName to TimeTraceProfiler
https://reviews.llvm.org/D71059 - [LLD][ELF] Add time-trace to ELF LLD (1/2) (multi-thread support in TimeProfiler)
https://reviews.llvm.org/D71060 - [LLD][ELF] Add time-trace to ELF LLD (2/2) (Add time trace to LLD)

Closing this review.

clang/tools/driver/cc1_main.cpp

#endif
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
   bool Success =
       CompilerInvocation::CreateFromArgs(Clang->getInvocation(), Argv, Diags);
 
   if (Clang->getFrontendOpts().TimeTrace) {
     llvm::timeTraceProfilerInitialize(
-        Clang->getFrontendOpts().TimeTraceGranularity);
+        Clang->getFrontendOpts().TimeTraceGranularity, Argv0);
   }
   // --print-supported-cpus takes priority over the actual compilation.
   if (Clang->getFrontendOpts().PrintSupportedCPUs)
     return PrintSupportedCPUs(Clang->getTargetOpts().Triple);
 
   // Infer the builtin include path if unspecified.
   if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
       Clang->getHeaderSearchOpts().ResourceDir.empty())

lld/ELF/Driver.cpp

 #include "llvm/LTO/LTO.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys;
if (errorCount())
     return;
 
   inferMachineType();
   setConfigs(args);
   checkOptions();
   if (errorCount())
     return;
 
+  // Initialize time trace.
+  if (args.hasArg(OPT_time_trace))
+    llvm::timeTraceProfilerInitialize(
+        args::getInteger(args, OPT_time_trace_granularity, 500u),
+        config->progName);
+
   // The Target instance handles target-specific stuff, such as applying
   // relocations or writing a PLT section. It also contains target-dependent
   // values such as a default image base address.
   target = getTarget();
 
   switch (config->ekind) {
   case ELF32LEKind:
     link<ELF32LE>(args);
-    return;
+    break;
   case ELF32BEKind:
     link<ELF32BE>(args);
-    return;
+    break;
   case ELF64LEKind:
     link<ELF64LE>(args);
-    return;
+    break;
   case ELF64BEKind:
     link<ELF64BE>(args);
-    return;
+    break;
   default:
     llvm_unreachable("unknown Config->EKind");
   }
+
+  if (llvm::timeTraceProfilerEnabled()) {
+    SmallString<128> path(config->outputFile);
+    llvm::sys::path::replace_extension(path, "json");
+    std::error_code errorCode;
+    raw_fd_ostream profilerOS(path, errorCode, sys::fs::F_Text);
+    if (errorCode) {
+      error("cannot open " + path + ": " + errorCode.message());
+      return;
+    }
+    llvm::timeTraceProfilerWrite(profilerOS);
+    llvm::timeTraceProfilerCleanup();
+  }
+  return;
 }
 
 static std::string getRpath(opt::InputArgList &args) {
   std::vector<StringRef> v = args::getStrings(args, OPT_rpath);
   return llvm::join(v.begin(), v.end(), ":");
 }
 
 // Determines what we should do if there are remaining unresolved

 // This function is where all the optimizations of link-time
 // optimization takes place. When LTO is in use, some input files are
 // not in native object file format but in the LLVM bitcode format.
 // This function compiles bitcode files into a few big native files
 // using LLVM functions and replaces bitcode symbols with the results.
 // Because all bitcode files that the program consists of are passed to
 // the compiler at once, it can do a whole-program optimization.
 template <class ELFT> void LinkerDriver::compileBitcodeFiles() {
+  llvm::TimeTraceScope timeScope("LTO", StringRef(""));
   // Compile bitcode files and replace bitcode symbols.
   lto.reset(new BitcodeCompiler);
   for (BitcodeFile *file : bitcodeFiles)
     lto->add(*file);
 
   for (InputFile *file : lto->compile()) {
     auto *obj = cast<ObjFile<ELFT>>(file);
     obj->parse(/*ignoreComdats=*/true);
if (config->pacPlt)
     ret |= GNU_PROPERTY_AARCH64_FEATURE_1_PAC;
 
   return ret;
 }
 
 // Do actual linking. Note that when this function is called,
 // all linker scripts have already been parsed.
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
+  llvm::TimeTraceScope timeScope("ExecuteLinker", StringRef(""));
+
   // If a -hash-style option was not given, set to a default value,
   // which varies depending on the target.
   if (!args.hasArg(OPT_hash_style)) {
     if (config->emachine == EM_MIPS)
       config->sysvHash = true;
     else
       config->sysvHash = config->gnuHash = true;
   }
template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
   // Handle --trace-symbol.
   for (auto *arg : args.filtered(OPT_trace_symbol))
     symtab->insert(arg->getValue())->traced = true;
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table. This process might
   // add files to the link, via autolinking, these files are always
   // appended to the Files vector.
+  {
+    llvm::TimeTraceScope timeScope("Parse input files", StringRef(""));
     for (size_t i = 0; i < files.size(); ++i)
       parseFile(files[i]);
+  }
 
   // Now that we have every file, we can decide if we will need a
   // dynamic symbol table.
   // We need one if we were asked to export dynamic symbols or if we are
   // producing a shared library.
   // We also need one if any shared libraries are used and for pie executables
   // (probably because the dynamic linker needs it).
   config->hasDynSymTab =

lld/ELF/ICF.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Writer.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Object/ELF.h"
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/xxhash.h"
 #include <algorithm>
 #include <atomic>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 

 
 static void print(const Twine &s) {
   if (config->printIcfSections)
     message(s);
 }
 
 // The main function of ICF.
 template <class ELFT> void ICF<ELFT>::run() {
+  llvm::TimeTraceScope timeScope("ICF", StringRef(""));
   // Collect sections to merge.
   for (InputSectionBase *sec : inputSections) {
     auto *s = cast<InputSection>(sec);
     if (isEligible(s))
       sections.push_back(s);
   }
 
   // Initially, we use hash values to partition sections.

lld/ELF/MarkLive.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/ELF.h"
+#include "llvm/Support/TimeProfiler.h"
 #include <functional>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 namespace endian = llvm::support::endian;
template <class ELFT> void MarkLive<ELFT>::moveToMain() {
 
   mark();
 }
 
 // Before calling this function, Live bits are off for all
 // input sections. This function make some or all of them on
 // so that they are emitted to the output file.
 template <class ELFT> void markLive() {
+  llvm::TimeTraceScope timeScope("GC", StringRef(""));
   // If -gc-sections is not given, no sections are removed.
   if (!config->gcSections) {
     for (InputSectionBase *sec : inputSections)
       sec->markLive();
 
     // If a DSO defines a symbol referenced in a regular object, it is needed.
     symtab->forEachSymbol([](Symbol *sym) {
       if (auto *s = dyn_cast<SharedSymbol>(sym))

lld/ELF/Options.td

 defm target2:
   Eq<"target2", "Interpret R_ARM_TARGET2 as <type>, where <type> is one of rel, abs, or got-rel">,
   MetaVarName<"<type>">;
 
 defm threads: B<"threads",
     "Run the linker multi-threaded (default)",
     "Do not run the linker multi-threaded">;
 
+def time_trace: F<"time-trace">, HelpText<"Record time trace">;
+
+defm time_trace_granularity: Eq<"time-trace-granularity",
+  "Minimum time granularity (in microseconds) traced by time profiler">;
+
 defm toc_optimize : B<"toc-optimize",
     "(PowerPC64) Enable TOC related optimizations (default)",
     "(PowerPC64) Disable TOC related optimizations">;
 
 def trace: F<"trace">, HelpText<"Print the names of the input files">;
 
 defm trace_symbol: Eq<"trace-symbol", "Trace references to symbols">;
 

lld/ELF/Writer.cpp

 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/xxhash.h"
 #include <climits>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
StringRef getOutputSectionName(const InputSectionBase *s) {
   return s->name;
 }
 
 static bool needsInterpSection() {
   return !sharedFiles.empty() && !config->dynamicLinker.empty() &&
          script->needsInterpSection();
 }
 
-template <class ELFT> void writeResult() { Writer<ELFT>().run(); }
+template <class ELFT> void writeResult() {
+  llvm::TimeTraceScope timeScope("Write output file", StringRef(""));
+  Writer<ELFT>().run();
+}
 
 static void removeEmptyPTLoad(std::vector<PhdrEntry *> &phdrs) {
   llvm::erase_if(phdrs, [&](const PhdrEntry *p) {
     if (p->p_type != PT_LOAD)
       return false;
     if (!p->firstSec)
       return true;
     uint64_t size = p->lastSec->addr + p->lastSec->size - p->firstSec->addr;

llvm/include/llvm/Support/TimeProfiler.h

 namespace llvm {
 
 struct TimeTraceProfiler;
 extern TimeTraceProfiler *TimeTraceProfilerInstance;
 
 /// Initialize the time trace profiler.
 /// This sets up the global \p TimeTraceProfilerInstance
 /// variable to be the profiler instance.
-void timeTraceProfilerInitialize(unsigned TimeTraceGranularity);
+void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
+                                 StringRef ProgName);
 
 /// Cleanup the time trace profiler, if it was initialized.
 void timeTraceProfilerCleanup();
 
 /// Is the time trace profiler enabled, i.e. initialized?
 inline bool timeTraceProfilerEnabled() {
   return TimeTraceProfilerInstance != nullptr;
 }

llvm/lib/Support/TimeProfiler.cpp

 //===-- TimeProfiler.cpp - Hierarchical Time Profiler ---------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements hierarchical time profiler.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/JSON.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Threading.h"
 #include <cassert>
 #include <chrono>
 #include <string>
 #include <vector>
 
 using namespace std::chrono;
 
 namespace llvm {
 
 TimeTraceProfiler *TimeTraceProfilerInstance = nullptr;
 
 typedef duration<steady_clock::rep, steady_clock::period> DurationType;
 typedef time_point<steady_clock> TimePointType;
 typedef std::pair<size_t, DurationType> CountAndDurationType;
 typedef std::pair<std::string, CountAndDurationType>
     NameAndCountAndDurationType;
 
 struct Entry {
   TimePointType Start;
   TimePointType End;
   std::string Name;
   std::string Detail;
+  uint64_t Tid;
 
   Entry(TimePointType &&S, TimePointType &&E, std::string &&N, std::string &&Dt)
       : Start(std::move(S)), End(std::move(E)), Name(std::move(N)),
-        Detail(std::move(Dt)){};
+        Detail(std::move(Dt)), Tid(llvm::get_threadid()){};
 
   // Calculate timings for FlameGraph. Cast time points to microsecond precision
   // rather than casting duration. This avoid truncation issues causing inner
   // scopes overruning outer scopes.
   steady_clock::rep getFlameGraphStartUs(TimePointType StartTime) const {
     return (time_point_cast<microseconds>(Start) -
             time_point_cast<microseconds>(StartTime))
         .count();
   }
 
   steady_clock::rep getFlameGraphDurUs() const {
     return (time_point_cast<microseconds>(End) -
             time_point_cast<microseconds>(Start))
         .count();
   }
 };
 
 struct TimeTraceProfiler {
-  TimeTraceProfiler() {
+  TimeTraceProfiler(StringRef ProgName) {
     StartTime = steady_clock::now();
+    this->ProgName = ProgName;
   }
 
   void begin(std::string Name, llvm::function_ref<std::string()> Detail) {
+    std::lock_guard<std::mutex> Lock(Mu);
     Stack.emplace_back(steady_clock::now(), TimePointType(), std::move(Name),
                        Detail());
   }
 
   void end() {
+    std::lock_guard<std::mutex> Lock(Mu);
+    uint64_t Tid = llvm::get_threadid();
+
     assert(!Stack.empty() && "Must call begin() first");
-    auto &E = Stack.back();
+
+    // Find the latest entry from this thread on the stack.
+    auto LatestEvent =
+        std::find_if(Stack.rbegin(), Stack.rend(),
+                     [&](const Entry &Val) { return Val.Tid == Tid; });
+    // Should always be able to find a stack entry on this thread.
+    assert(LatestEvent != Stack.rend() &&
+           "end() without begin() found on thread");
+
+    // Get reference from iterator.
+    auto &E = *LatestEvent;
+
     E.End = steady_clock::now();
 
     // Check that end times monotonically increase.
-    assert((Entries.empty() ||
-            (E.getFlameGraphStartUs(StartTime) + E.getFlameGraphDurUs() >=
-             Entries.back().getFlameGraphStartUs(StartTime) +
-                 Entries.back().getFlameGraphDurUs())) &&
-           "TimeProfiler scope ended earlier than previous scope");
+    //    auto LastEntryOnThreadIter = std::find_if(Entries.rbegin(),
+    //    Entries.rend(), [&](const Entry &Val) {
+    //          return Val.Tid == Tid;
+    //        });
+    //    auto &LastEntryOnThread = *LastEntryOnThreadIter;
+    //    assert((Entries.empty() ||
+    //            (E.getFlameGraphStartUs(StartTime) + E.getFlameGraphDurUs() >=
+    //             LastEntryOnThread.getFlameGraphStartUs(StartTime) +
+    //                 LastEntryOnThread.getFlameGraphDurUs())) &&
+    //           "TimeProfiler scope ended earlier than previous scope");
 
     // Calculate duration at full precision for overall counts.
     DurationType Duration = E.End - E.Start;
 
     // Only include sections longer or equal to TimeTraceGranularity msec.
     if (duration_cast<microseconds>(Duration).count() >= TimeTraceGranularity)
       Entries.emplace_back(E);
 
     // Track total time taken by each "name", but only the topmost levels of
     // them; e.g. if there's a template instantiation that instantiates other
     // templates from within, we only want to add the topmost one. "topmost"
     // happens to be the ones that don't have any currently open entries above
     // itself.
-    if (std::find_if(++Stack.rbegin(), Stack.rend(), [&](const Entry &Val) {
-          return Val.Name == E.Name;
+    if (std::find_if(std::next(LatestEvent), Stack.rend(),
+                     [&](const Entry &Val) {
+                       return (Val.Name == E.Name) && (Val.Tid == Tid);
                      }) == Stack.rend()) {
       auto &CountAndTotal = CountAndTotalPerName[E.Name];
       CountAndTotal.first++;
       CountAndTotal.second += Duration;
     }
 
-    Stack.pop_back();
+    // Remove the last entry in the stack that matches this Tid.
+    Stack.erase(std::next(LatestEvent).base());
   }
 
   void Write(raw_pwrite_stream &OS) {
+    std::lock_guard<std::mutex> Lock(Mu);
     assert(Stack.empty() &&
            "All profiler sections should be ended when calling Write");
     json::OStream J(OS);
     J.objectBegin();
     J.attributeBegin("traceEvents");
     J.arrayBegin();
 
     // Emit all events for the main flame graph.
     for (const auto &E : Entries) {
       auto StartUs = E.getFlameGraphStartUs(StartTime);
       auto DurUs = E.getFlameGraphDurUs();
 
       J.object([&]{
         J.attribute("pid", 1);
-        J.attribute("tid", 0);
+        J.attribute("tid", int64_t(E.Tid));
         J.attribute("ph", "X");
         J.attribute("ts", StartUs);
         J.attribute("dur", DurUs);
         J.attribute("name", E.Name);
         J.attributeObject("args", [&] { J.attribute("detail", E.Detail); });
       });
     }
 
     // Emit totals by section name as additional "thread" events, sorted from
     // longest one.
-    int Tid = 1;
+    // Find highest used thread id.
+    uint64_t MaxTid = 0;
+    for (const auto &E : Entries) {
+      MaxTid = std::max(MaxTid, E.Tid);
+    }
+    uint64_t Tid = MaxTid + 1;
     std::vector<NameAndCountAndDurationType> SortedTotals;
     SortedTotals.reserve(CountAndTotalPerName.size());
     for (const auto &E : CountAndTotalPerName)
       SortedTotals.emplace_back(E.getKey(), E.getValue());
 
     llvm::sort(SortedTotals.begin(), SortedTotals.end(),
                [](const NameAndCountAndDurationType &A,
                   const NameAndCountAndDurationType &B) {
                  return A.second.second > B.second.second;
                });
     for (const auto &E : SortedTotals) {
       auto DurUs = duration_cast<microseconds>(E.second.second).count();
       auto Count = CountAndTotalPerName[E.first].first;
 
       J.object([&]{
         J.attribute("pid", 1);
-        J.attribute("tid", Tid);
+        J.attribute("tid", int64_t(Tid));
         J.attribute("ph", "X");
         J.attribute("ts", 0);
         J.attribute("dur", DurUs);
         J.attribute("name", "Total " + E.first);
         J.attributeObject("args", [&] {
           J.attribute("count", int64_t(Count));
           J.attribute("avg ms", int64_t(DurUs / Count / 1000));
         });
       });
 
       ++Tid;
     }
 
     // Emit metadata event with process name.
     J.object([&] {
       J.attribute("cat", "");
       J.attribute("pid", 1);
       J.attribute("tid", 0);
       J.attribute("ts", 0);
       J.attribute("ph", "M");
       J.attribute("name", "process_name");
-      J.attributeObject("args", [&] { J.attribute("name", "clang"); });
+      J.attributeObject("args", [&] { J.attribute("name", ProgName); });
     });
 
     J.arrayEnd();
     J.attributeEnd();
     J.objectEnd();
   }
 
-  SmallVector<Entry, 16> Stack;
-  SmallVector<Entry, 128> Entries;
-  StringMap<CountAndDurationType> CountAndTotalPerName;
+  std::mutex Mu;
+  SmallVector<Entry, 16> Stack /*GUARDED_BY(Mu)*/;
+  SmallVector<Entry, 128> Entries /*GUARDED_BY(Mu)*/;
+  StringMap<CountAndDurationType> CountAndTotalPerName /*GUARDED_BY(Mu)*/;
   TimePointType StartTime;
+  StringRef ProgName;
 
   // Minimum time granularity (in microseconds)
   unsigned TimeTraceGranularity;
 };
 
-void timeTraceProfilerInitialize(unsigned TimeTraceGranularity) {
+void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
+                                 StringRef ProgName) {
   assert(TimeTraceProfilerInstance == nullptr &&
          "Profiler should not be initialized");
-  TimeTraceProfilerInstance = new TimeTraceProfiler();
+  TimeTraceProfilerInstance =
+      new TimeTraceProfiler(llvm::sys::path::filename(ProgName));
   TimeTraceProfilerInstance->TimeTraceGranularity = TimeTraceGranularity;
 }
 
 void timeTraceProfilerCleanup() {
   delete TimeTraceProfilerInstance;
   TimeTraceProfilerInstance = nullptr;
 }