[TimeProfiler] Emit real process ID and thread names

[broadwaylamb]

Remove unrelated changes

[broadwaylamb]

Explicitly specify argument types in writeMetadataEvent lambda.

[russell.gallop]

Would be nice if the test could check that the pid was being set to something but not sure how you could do that (beyond checking that it's a number).

Apart from that, LGTM.

[MaskRay]

llvm/lib/Support/TimeProfiler.cpp

77

You can define ThreadName as SmallString<0> to avoid this function.

246

The new line is not necessary

249

Delete {} for simple statements. In LLVM code, such {} is not common.

[broadwaylamb]

llvm/lib/Support/TimeProfiler.cpp

77

Then the ThreadName field will lose const-ness, and I will also need to call llvm::get_thread_name in the constructor body, not the member initialization list. Would that be OK?

249

The code above uses {}.

According to http://llvm.org/docs/CodingStandards.html:

If you are extending, enhancing, or bug fixing already implemented code, use the style that is already being used so that the source is uniform and easy to follow.

[MaskRay]

llvm/lib/Support/TimeProfiler.cpp

77

This is OK. Thanks

80

return Name.str();

249

They were added without enough scrutiny. There are many other simple statements in this file not surrounded by {}

[MaskRay]

llvm/lib/Support/TimeProfiler.cpp

249

See D78153

[broadwaylamb]

Fix coding style

[MaskRay]

llvm/lib/Support/TimeProfiler.cpp

237

This is not great but I guess it is ok...

[broadwaylamb]

llvm/lib/Support/TimeProfiler.cpp

237

What is?

clang/test/Driver/check-time-trace.cpp

 // RUN: %clangxx -S -ftime-trace -ftime-trace-granularity=0 -o %T/check-time-trace %s
 // RUN: cat %T/check-time-trace.json \
 // RUN:   | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \
 // RUN:   | FileCheck %s
 
 // CHECK: "traceEvents": [
 // CHECK: "args":
 // CHECK: "detail":
 // CHECK: "dur":
 // CHECK: "name":
 // CHECK-NEXT: "ph":
 // CHECK-NEXT: "pid":
 // CHECK-NEXT: "tid":
 // CHECK-NEXT: "ts":
 // CHECK: "name": "clang{{.*}}"
 // CHECK: "name": "process_name"
+// CHECK: "name": "thread_name"
 
 template <typename T>
 struct Struct {
   T Num;
 };
 
 int main() {
   Struct<int> S;
 
   return 0;
 }

lld/test/ELF/time-trace.s

 # CHECK-NEXT: "ts":
 
 # Check there is an ExecuteLinker event
 # CHECK: "name": "ExecuteLinker"
 
 # Check process_name entry field
 # CHECK: "name": "ld.lld{{(.exe)?}}"
 # CHECK: "name": "process_name"
+# CHECK: "name": "thread_name"
 
 .globl _start
 _start:
   ret

llvm/lib/Support/TimeProfiler.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/Threading.h"
 #include <algorithm>
 #include <cassert>
 #include <chrono>
 #include <mutex>
 #include <string>
 #include <vector>
 
struct Entry {
 
   steady_clock::rep getFlameGraphDurUs() const {
     return (time_point_cast<microseconds>(End) -
             time_point_cast<microseconds>(Start))
         .count();
   }
 };
 
+static std::string getThreadName() {
+  SmallString<64> Name;
+  llvm::get_thread_name(Name);
+  return std::string(std::move(Name));
+}
+
 struct TimeTraceProfiler {
   TimeTraceProfiler(unsigned TimeTraceGranularity = 0, StringRef ProcName = "")
       : StartTime(steady_clock::now()), ProcName(ProcName),
-        Tid(llvm::get_threadid()), TimeTraceGranularity(TimeTraceGranularity) {}
+        Pid(sys::Process::getProcessId()), ThreadName(getThreadName()),
+        Tid(llvm::get_threadid()),
+        TimeTraceGranularity(TimeTraceGranularity) {}
 
   void begin(std::string Name, llvm::function_ref<std::string()> Detail) {
     Stack.emplace_back(steady_clock::now(), TimePointType(), std::move(Name),
                        Detail());
   }
 
   void end() {
     assert(!Stack.empty() && "Must call begin() first");
void Write(raw_pwrite_stream &OS) {
     J.arrayBegin();
 
     // Emit all events for the main flame graph.
     auto writeEvent = [&](const auto &E, uint64_t Tid) {
       auto StartUs = E.getFlameGraphStartUs(StartTime);
       auto DurUs = E.getFlameGraphDurUs();
 
       J.object([&]{
-        J.attribute("pid", 1);
+        J.attribute("pid", Pid);
         J.attribute("tid", int64_t(Tid));
         J.attribute("ph", "X");
         J.attribute("ts", StartUs);
         J.attribute("dur", DurUs);
         J.attribute("name", E.Name);
         if (!E.Detail.empty()) {
           J.attributeObject("args", [&] { J.attribute("detail", E.Detail); });
         }
void Write(raw_pwrite_stream &OS) {
 
     // Report totals on separate threads of tracing file.
     uint64_t TotalTid = MaxTid + 1;
     for (const auto &Total : SortedTotals) {
       auto DurUs = duration_cast<microseconds>(Total.second.second).count();
       auto Count = AllCountAndTotalPerName[Total.first].first;
 
       J.object([&]{
-        J.attribute("pid", 1);
+        J.attribute("pid", Pid);
         J.attribute("tid", int64_t(TotalTid));
         J.attribute("ph", "X");
         J.attribute("ts", 0);
         J.attribute("dur", DurUs);
         J.attribute("name", "Total " + Total.first);
         J.attributeObject("args", [&] {
           J.attribute("count", int64_t(Count));
           J.attribute("avg ms", int64_t(DurUs / Count / 1000));
         });
       });
 
       ++TotalTid;
     }
 
-    // Emit metadata event with process name.
+    auto writeMetadataEvent = [&](const char* Name, uint64_t Tid, auto arg) {
       J.object([&] {
         J.attribute("cat", "");
-      J.attribute("pid", 1);
-      J.attribute("tid", 0);
+        J.attribute("pid", Pid);
+        J.attribute("tid", int64_t(Tid));
         J.attribute("ts", 0);
         J.attribute("ph", "M");
-      J.attribute("name", "process_name");
-      J.attributeObject("args", [&] { J.attribute("name", ProcName); });
+        J.attribute("name", Name);
+        J.attributeObject("args", [&] { J.attribute("name", arg); });
       });
+    };
+
+    writeMetadataEvent("process_name", Tid, ProcName);
+
+    writeMetadataEvent("thread_name", Tid, ThreadName);
+
+    for (const auto &TTP : ThreadTimeTraceProfilerInstances) {
+      writeMetadataEvent("thread_name", TTP->Tid, TTP->ThreadName);
+    }
 
     J.arrayEnd();
     J.attributeEnd();
     J.objectEnd();
   }
 
   SmallVector<Entry, 16> Stack;
   SmallVector<Entry, 128> Entries;
   StringMap<CountAndDurationType> CountAndTotalPerName;
   const TimePointType StartTime;
   const std::string ProcName;
+  const sys::Process::Pid Pid;
+  const std::string ThreadName;
   const uint64_t Tid;
 
   // Minimum time granularity (in microseconds)
   const unsigned TimeTraceGranularity;
 };
 
 void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
                                  StringRef ProcName) {