diff --git a/a-abfdec1d.o.tmp b/a-abfdec1d.o.tmp deleted file mode 100644 index e69de29bb2d1d6..00000000000000 diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 971df672b6ca1e..e0e86af257a195 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -736,9 +736,6 @@ Improvements to Clang's time-trace - Clang now specifies that using ``auto`` in a lambda parameter is a C++14 extension when appropriate. (`#46059: `_). -- Clang now adds source file infomation for template instantiations as ``event["args"]["filename"]``. This - added behind an option ``-ftime-trace-verbose``. This is expected to increase the size of trace by 2-3 times. - Improvements to Coverage Mapping -------------------------------- diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index d3068c1b30a7aa..1675e435d210c5 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -3988,10 +3988,6 @@ def ftime_trace_granularity_EQ : Joined<["-"], "ftime-trace-granularity=">, Grou HelpText<"Minimum time granularity (in microseconds) traced by time profiler">, Visibility<[ClangOption, CC1Option, CLOption, DXCOption]>, MarshallingInfoInt, "500u">; -def ftime_trace_verbose : Joined<["-"], "ftime-trace-verbose">, Group, - HelpText<"Make time trace capture verbose event details (e.g. source filenames). This can increase the size of the output by 2-3 times">, - Visibility<[ClangOption, CC1Option, CLOption, DXCOption]>, - MarshallingInfoFlag>; def ftime_trace_EQ : Joined<["-"], "ftime-trace=">, Group, HelpText<"Similar to -ftime-trace. Specify the JSON file or a directory which will contain the JSON file">, Visibility<[ClangOption, CC1Option, CLOption, DXCOption]>, diff --git a/clang/include/clang/Frontend/FrontendOptions.h b/clang/include/clang/Frontend/FrontendOptions.h index 8241925c984763..5e5034fe01eb54 100644 --- a/clang/include/clang/Frontend/FrontendOptions.h +++ b/clang/include/clang/Frontend/FrontendOptions.h @@ -580,11 +580,6 @@ class FrontendOptions { /// Minimum time granularity (in microseconds) traced by time profiler. unsigned TimeTraceGranularity; - /// Make time trace capture verbose event details (e.g. source filenames). - /// This can increase the size of the output by 2-3 times. - LLVM_PREFERRED_TYPE(bool) - unsigned TimeTraceVerbose : 1; - /// Path which stores the output files for -ftime-trace std::string TimeTracePath; @@ -606,8 +601,7 @@ class FrontendOptions { EmitSymbolGraph(false), EmitExtensionSymbolGraphs(false), EmitSymbolGraphSymbolLabelsForTesting(false), EmitPrettySymbolGraphs(false), GenReducedBMI(false), - UseClangIRPipeline(false), TimeTraceGranularity(500), - TimeTraceVerbose(false) {} + UseClangIRPipeline(false), TimeTraceGranularity(500) {} /// getInputKindForExtension - Return the appropriate input kind for a file /// extension. For example, "c" would return Language::C. diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index 6b33301d364010..1fd6fba2100426 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -6754,7 +6754,6 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (const char *Name = C.getTimeTraceFile(&JA)) { CmdArgs.push_back(Args.MakeArgString("-ftime-trace=" + Twine(Name))); Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ); - Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_verbose); } if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) { diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp index 725b62db5e80ab..a7bc6749c58520 100644 --- a/clang/lib/Sema/SemaTemplateInstantiate.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp @@ -3426,16 +3426,11 @@ Sema::InstantiateClass(SourceLocation PointOfInstantiation, return true; llvm::TimeTraceScope TimeScope("InstantiateClass", [&]() { - llvm::TimeTraceMetadata M; - llvm::raw_string_ostream OS(M.Detail); + std::string Name; + llvm::raw_string_ostream OS(Name); Instantiation->getNameForDiagnostic(OS, getPrintingPolicy(), /*Qualified=*/true); - if (llvm::isTimeTraceVerbose()) { - auto Loc = SourceMgr.getExpansionLoc(Instantiation->getLocation()); - M.File = SourceMgr.getFilename(Loc); - M.Line = SourceMgr.getExpansionLineNumber(Loc); - } - return M; + return Name; }); Pattern = PatternDef; diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index 4e619f4b491a6c..01432301633ed2 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -4966,16 +4966,11 @@ void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, } llvm::TimeTraceScope TimeScope("InstantiateFunction", [&]() { - llvm::TimeTraceMetadata M; - llvm::raw_string_ostream OS(M.Detail); + std::string Name; + llvm::raw_string_ostream OS(Name); Function->getNameForDiagnostic(OS, getPrintingPolicy(), /*Qualified=*/true); - if (llvm::isTimeTraceVerbose()) { - auto Loc = SourceMgr.getExpansionLoc(Function->getLocation()); - M.File = SourceMgr.getFilename(Loc); - M.Line = SourceMgr.getExpansionLineNumber(Loc); - } - return M; + return Name; }); // If we're performing recursive template instantiation, create our own diff --git a/clang/test/Driver/ftime-trace-sections.cpp b/clang/test/Driver/ftime-trace-sections.cpp index da7109b9d81a6b..0c16052bc0c3a2 100644 --- a/clang/test/Driver/ftime-trace-sections.cpp +++ b/clang/test/Driver/ftime-trace-sections.cpp @@ -1,5 +1,5 @@ // RUN: rm -rf %t && mkdir %t && cd %t -// RUN: %clangxx -S -ftime-trace -ftime-trace-granularity=0 -ftime-trace-verbose -o out %s +// RUN: %clangxx -S -ftime-trace -ftime-trace-granularity=0 -o out %s // RUN: %python %S/ftime-trace-sections.py < out.json template diff --git a/clang/test/Driver/ftime-trace.cpp b/clang/test/Driver/ftime-trace.cpp index 60c5885704b58e..5fe63de915a718 100644 --- a/clang/test/Driver/ftime-trace.cpp +++ b/clang/test/Driver/ftime-trace.cpp @@ -1,18 +1,18 @@ // RUN: rm -rf %t && mkdir -p %t && cd %t -// RUN: %clangxx -S -no-canonical-prefixes -ftime-trace -ftime-trace-granularity=0 -ftime-trace-verbose -o out %s +// RUN: %clangxx -S -no-canonical-prefixes -ftime-trace -ftime-trace-granularity=0 -o out %s // RUN: cat out.json \ // RUN: | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \ // RUN: | FileCheck %s -// RUN: %clangxx -S -no-canonical-prefixes -ftime-trace=new-name.json -ftime-trace-granularity=0 -ftime-trace-verbose -o out %s +// RUN: %clangxx -S -no-canonical-prefixes -ftime-trace=new-name.json -ftime-trace-granularity=0 -o out %s // RUN: cat new-name.json \ // RUN: | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \ // RUN: | FileCheck %s // RUN: mkdir dir1 dir2 -// RUN: %clangxx -S -no-canonical-prefixes -ftime-trace=dir1 -ftime-trace-granularity=0 -ftime-trace-verbose -o out %s +// RUN: %clangxx -S -no-canonical-prefixes -ftime-trace=dir1 -ftime-trace-granularity=0 -o out %s // RUN: cat dir1/out.json \ // RUN: | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \ // RUN: | FileCheck %s -// RUN: %clangxx -S -no-canonical-prefixes -ftime-trace=dir2/ -ftime-trace-granularity=0 -ftime-trace-verbose -o out %s +// RUN: %clangxx -S -no-canonical-prefixes -ftime-trace=dir2/ -ftime-trace-granularity=0 -o out %s // RUN: cat dir2/out.json \ // RUN: | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \ // RUN: | FileCheck %s @@ -34,33 +34,32 @@ // RUN: mkdir d e f && cp %s d/a.cpp && touch d/b.c /// TODO: Support -fno-integrated-as. -// RUN: %clang -### -c -ftime-trace -ftime-trace-granularity=0 -ftime-trace-verbose -fintegrated-as d/a.cpp -o e/a.o 2>&1 | FileCheck %s --check-prefix=COMPILE1 -// COMPILE1: -cc1{{.*}} "-ftime-trace=e/a.json" "-ftime-trace-granularity=0" "-ftime-trace-verbose" +// RUN: %clang -### -c -ftime-trace -ftime-trace-granularity=0 -fintegrated-as d/a.cpp -o e/a.o 2>&1 | FileCheck %s --check-prefix=COMPILE1 +// COMPILE1: -cc1{{.*}} "-ftime-trace=e/a.json" "-ftime-trace-granularity=0" -// RUN: %clang -### -c -ftime-trace -ftime-trace-granularity=0 -ftime-trace-verbose d/a.cpp d/b.c -dumpdir f/ 2>&1 | FileCheck %s --check-prefix=COMPILE2 -// COMPILE2: -cc1{{.*}} "-ftime-trace=f/a.json" "-ftime-trace-granularity=0" "-ftime-trace-verbose" -// COMPILE2: -cc1{{.*}} "-ftime-trace=f/b.json" "-ftime-trace-granularity=0" "-ftime-trace-verbose" +// RUN: %clang -### -c -ftime-trace -ftime-trace-granularity=0 d/a.cpp d/b.c -dumpdir f/ 2>&1 | FileCheck %s --check-prefix=COMPILE2 +// COMPILE2: -cc1{{.*}} "-ftime-trace=f/a.json" "-ftime-trace-granularity=0" +// COMPILE2: -cc1{{.*}} "-ftime-trace=f/b.json" "-ftime-trace-granularity=0" /// -o specifies the link output. Create ${output}-${basename}.json. -// RUN: %clang -### -ftime-trace -ftime-trace-granularity=0 -ftime-trace-verbose d/a.cpp d/b.c -o e/x 2>&1 | FileCheck %s --check-prefix=LINK1 -// LINK1: -cc1{{.*}} "-ftime-trace=e/x-a.json" "-ftime-trace-granularity=0" "-ftime-trace-verbose" -// LINK1: -cc1{{.*}} "-ftime-trace=e/x-b.json" "-ftime-trace-granularity=0" "-ftime-trace-verbose" +// RUN: %clang -### -ftime-trace -ftime-trace-granularity=0 d/a.cpp d/b.c -o e/x 2>&1 | FileCheck %s --check-prefix=LINK1 +// LINK1: -cc1{{.*}} "-ftime-trace=e/x-a.json" "-ftime-trace-granularity=0" +// LINK1: -cc1{{.*}} "-ftime-trace=e/x-b.json" "-ftime-trace-granularity=0" /// -dumpdir is f/g, not ending with a path separator. We create f/g${basename}.json. -// RUN: %clang -### -ftime-trace -ftime-trace-granularity=0 -ftime-trace-verbose d/a.cpp d/b.c -o e/x -dumpdir f/g 2>&1 | FileCheck %s --check-prefix=LINK2 -// LINK2: -cc1{{.*}} "-ftime-trace=f/ga.json" "-ftime-trace-granularity=0" "-ftime-trace-verbose" -// LINK2: -cc1{{.*}} "-ftime-trace=f/gb.json" "-ftime-trace-granularity=0" "-ftime-trace-verbose" +// RUN: %clang -### -ftime-trace -ftime-trace-granularity=0 d/a.cpp d/b.c -o e/x -dumpdir f/g 2>&1 | FileCheck %s --check-prefix=LINK2 +// LINK2: -cc1{{.*}} "-ftime-trace=f/ga.json" "-ftime-trace-granularity=0" +// LINK2: -cc1{{.*}} "-ftime-trace=f/gb.json" "-ftime-trace-granularity=0" -// RUN: %clang -### -ftime-trace=e -ftime-trace-granularity=0 -ftime-trace-verbose d/a.cpp d/b.c -o f/x -dumpdir f/ 2>&1 | FileCheck %s --check-prefix=LINK3 -// LINK3: -cc1{{.*}} "-ftime-trace=e{{/|\\\\}}a-{{[^.]*}}.json" "-ftime-trace-granularity=0" "-ftime-trace-verbose" -// LINK3: -cc1{{.*}} "-ftime-trace=e{{/|\\\\}}b-{{[^.]*}}.json" "-ftime-trace-granularity=0" "-ftime-trace-verbose" +// RUN: %clang -### -ftime-trace=e -ftime-trace-granularity=0 d/a.cpp d/b.c -o f/x -dumpdir f/ 2>&1 | FileCheck %s --check-prefix=LINK3 +// LINK3: -cc1{{.*}} "-ftime-trace=e{{/|\\\\}}a-{{[^.]*}}.json" "-ftime-trace-granularity=0" +// LINK3: -cc1{{.*}} "-ftime-trace=e{{/|\\\\}}b-{{[^.]*}}.json" "-ftime-trace-granularity=0" -// RUN: %clang -### -ftime-trace -ftime-trace=e -ftime-trace-granularity=1 -ftime-trace-verbose -xassembler d/a.cpp 2>&1 | \ +// RUN: %clang -### -ftime-trace -ftime-trace=e -ftime-trace-granularity=1 -xassembler d/a.cpp 2>&1 | \ // RUN: FileCheck %s --check-prefix=UNUSED // UNUSED: warning: argument unused during compilation: '-ftime-trace' // UNUSED-NEXT: warning: argument unused during compilation: '-ftime-trace=e' // UNUSED-NEXT: warning: argument unused during compilation: '-ftime-trace-granularity=1' -// UNUSED-NEXT: warning: argument unused during compilation: '-ftime-trace-verbose' // UNUSED-NOT: warning: template diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp index f5e5fad36573ec..c2ccb47a15bc85 100644 --- a/clang/tools/driver/cc1_main.cpp +++ b/clang/tools/driver/cc1_main.cpp @@ -241,8 +241,7 @@ int cc1_main(ArrayRef Argv, const char *Argv0, void *MainAddr) { if (!Clang->getFrontendOpts().TimeTracePath.empty()) { llvm::timeTraceProfilerInitialize( - Clang->getFrontendOpts().TimeTraceGranularity, Argv0, - Clang->getFrontendOpts().TimeTraceVerbose); + Clang->getFrontendOpts().TimeTraceGranularity, Argv0); } // --print-supported-cpus takes priority over the actual compilation. if (Clang->getFrontendOpts().PrintSupportedCPUs) diff --git a/clang/unittests/Support/TimeProfilerTest.cpp b/clang/unittests/Support/TimeProfilerTest.cpp index 96e137508ed94d..5f3950ff033f13 100644 --- a/clang/unittests/Support/TimeProfilerTest.cpp +++ b/clang/unittests/Support/TimeProfilerTest.cpp @@ -10,14 +10,11 @@ #include "clang/Frontend/FrontendActions.h" #include "clang/Lex/PreprocessorOptions.h" -#include "llvm/ADT/StringMap.h" #include "llvm/Support/JSON.h" #include "llvm/Support/TimeProfiler.h" -#include "llvm/Support/VirtualFileSystem.h" #include #include "gtest/gtest.h" -#include using namespace clang; using namespace llvm; @@ -26,8 +23,7 @@ namespace { // Should be called before testing. void setupProfiler() { - timeTraceProfilerInitialize(/*TimeTraceGranularity=*/0, "test", - /*TimeTraceVerbose=*/true); + timeTraceProfilerInitialize(/*TimeTraceGranularity=*/0, "test"); } // Should be called after `compileFromString()`. @@ -42,24 +38,14 @@ std::string teardownProfiler() { // Returns true if code compiles successfully. // We only parse AST here. This is enough for constexpr evaluation. -bool compileFromString(StringRef Code, StringRef Standard, StringRef File, - llvm::StringMap Headers = {}) { +bool compileFromString(StringRef Code, StringRef Standard, StringRef FileName) { CompilerInstance Compiler; Compiler.createDiagnostics(); - llvm::IntrusiveRefCntPtr FS( - new llvm::vfs::InMemoryFileSystem()); - FS->addFile(File, 0, MemoryBuffer::getMemBuffer(Code)); - for (const auto &Header : Headers) { - FS->addFile(Header.getKey(), 0, - MemoryBuffer::getMemBuffer(Header.getValue())); - } - llvm::IntrusiveRefCntPtr Files( - new FileManager(FileSystemOptions(), FS)); - Compiler.setFileManager(Files.get()); - auto Invocation = std::make_shared(); - std::vector Args = {Standard.data(), File.data()}; + Invocation->getPreprocessorOpts().addRemappedFile( + FileName, MemoryBuffer::getMemBuffer(Code).release()); + const char *Args[] = {Standard.data(), FileName.data()}; CompilerInvocation::CreateFromArgs(*Invocation, Args, Compiler.getDiagnostics()); Compiler.setInvocation(std::move(Invocation)); @@ -74,27 +60,13 @@ bool compileFromString(StringRef Code, StringRef Standard, StringRef File, return Compiler.ExecuteAction(Action); } -std::string GetMetadata(json::Object *Event) { - std::string Metadata; - llvm::raw_string_ostream OS(Metadata); - if (json::Object *Args = Event->getObject("args")) { - if (auto Detail = Args->getString("detail")) - OS << Detail->str(); - if (auto File = Args->getString("file")) - OS << ", " << File->str(); - if (auto Line = Args->getInteger("line")) - OS << ":" << *Line; - } - return Metadata; -} - // Returns pretty-printed trace graph. std::string buildTraceGraph(StringRef Json) { struct EventRecord { int64_t TimestampBegin; int64_t TimestampEnd; - std::string Name; - std::string Metadata; + StringRef Name; + StringRef Detail; }; std::vector Events; @@ -109,13 +81,10 @@ std::string buildTraceGraph(StringRef Json) { int64_t TimestampBegin = TraceEventObj->getInteger("ts").value_or(0); int64_t TimestampEnd = TimestampBegin + TraceEventObj->getInteger("dur").value_or(0); - std::string Name = TraceEventObj->getString("name").value_or("").str(); - std::string Metadata = GetMetadata(TraceEventObj); - - // Source events are asynchronous events and may not perfectly nest the - // synchronous events. Skip testing them. - if (Name == "Source") - continue; + StringRef Name = TraceEventObj->getString("name").value_or(""); + StringRef Detail = ""; + if (json::Object *Args = TraceEventObj->getObject("args")) + Detail = Args->getString("detail").value_or(""); // This is a "summary" event, like "Total PerformPendingInstantiations", // skip it @@ -123,7 +92,7 @@ std::string buildTraceGraph(StringRef Json) { continue; Events.emplace_back( - EventRecord{TimestampBegin, TimestampEnd, Name, Metadata}); + EventRecord{TimestampBegin, TimestampEnd, Name, Detail}); } // There can be nested events that are very fast, for example: @@ -163,9 +132,9 @@ std::string buildTraceGraph(StringRef Json) { Stream << "| "; } Stream.write(Event.Name.data(), Event.Name.size()); - if (!Event.Metadata.empty()) { + if (!Event.Detail.empty()) { Stream << " ("; - Stream.write(Event.Metadata.data(), Event.Metadata.size()); + Stream.write(Event.Detail.data(), Event.Detail.size()); Stream << ")"; } Stream << "\n"; @@ -176,7 +145,7 @@ std::string buildTraceGraph(StringRef Json) { } // namespace TEST(TimeProfilerTest, ConstantEvaluationCxx20) { - std::string Code = R"( + constexpr StringRef Code = R"( void print(double value); namespace slow_namespace { @@ -206,7 +175,8 @@ constexpr int slow_init_list[] = {1, 1, 2, 3, 5, 8, 13, 21}; // 25th line setupProfiler(); ASSERT_TRUE(compileFromString(Code, "-std=c++20", "test.cc")); std::string Json = teardownProfiler(); - ASSERT_EQ(R"( + std::string TraceGraph = buildTraceGraph(Json); + ASSERT_TRUE(TraceGraph == R"( Frontend | ParseDeclarationOrFunctionDefinition (test.cc:2:1) | ParseDeclarationOrFunctionDefinition (test.cc:6:1) @@ -232,54 +202,14 @@ Frontend | ParseDeclarationOrFunctionDefinition (test.cc:25:1) | | EvaluateAsInitializer (slow_init_list) | PerformPendingInstantiations -)", - buildTraceGraph(Json)); -} - -TEST(TimeProfilerTest, TemplateInstantiations) { - std::string B_H = R"( - template - T fooB(T t) { - return T(); - } +)"); - #define MacroTemp(x) template void foo##x(T) { T(); } - )"; - - std::string A_H = R"( - #include "b.h" - - MacroTemp(MTA) - - template - void fooA(T t) { fooB(t); fooMTA(t); } - )"; - std::string Code = R"( - #include "a.h" - void user() { fooA(0); } - )"; - - setupProfiler(); - ASSERT_TRUE(compileFromString(Code, "-std=c++20", "test.cc", - /*Headers=*/{{"a.h", A_H}, {"b.h", B_H}})); - std::string Json = teardownProfiler(); - ASSERT_EQ(R"( -Frontend -| ParseFunctionDefinition (fooB) -| ParseFunctionDefinition (fooMTA) -| ParseFunctionDefinition (fooA) -| ParseDeclarationOrFunctionDefinition (test.cc:3:5) -| | ParseFunctionDefinition (user) -| PerformPendingInstantiations -| | InstantiateFunction (fooA, ./a.h:7) -| | | InstantiateFunction (fooB, ./b.h:3) -| | | InstantiateFunction (fooMTA, ./a.h:4) -)", - buildTraceGraph(Json)); + // NOTE: If this test is failing, run this test with + // `llvm::errs() << TraceGraph;` and change the assert above. } TEST(TimeProfilerTest, ConstantEvaluationC99) { - std::string Code = R"( + constexpr StringRef Code = R"( struct { short quantval[4]; // 3rd line } value; @@ -288,12 +218,15 @@ struct { setupProfiler(); ASSERT_TRUE(compileFromString(Code, "-std=c99", "test.c")); std::string Json = teardownProfiler(); - ASSERT_EQ(R"( + std::string TraceGraph = buildTraceGraph(Json); + ASSERT_TRUE(TraceGraph == R"( Frontend | ParseDeclarationOrFunctionDefinition (test.c:2:1) | | isIntegerConstantExpr () | | EvaluateKnownConstIntCheckOverflow () | PerformPendingInstantiations -)", - buildTraceGraph(Json)); +)"); + + // NOTE: If this test is failing, run this test with + // `llvm::errs() << TraceGraph;` and change the assert above. } diff --git a/llvm/include/llvm/Support/TimeProfiler.h b/llvm/include/llvm/Support/TimeProfiler.h index 6eb92930b36fdc..31f7df10916db9 100644 --- a/llvm/include/llvm/Support/TimeProfiler.h +++ b/llvm/include/llvm/Support/TimeProfiler.h @@ -83,28 +83,16 @@ namespace llvm { class raw_pwrite_stream; -struct TimeTraceMetadata { - std::string Detail; - // Source file and line number information for the event. - std::string File; - int Line; - - bool isEmpty() const { return Detail.empty() && File.empty(); } -}; - struct TimeTraceProfiler; TimeTraceProfiler *getTimeTraceProfilerInstance(); -bool isTimeTraceVerbose(); - struct TimeTraceProfilerEntry; /// Initialize the time trace profiler. /// This sets up the global \p TimeTraceProfilerInstance /// variable to be the profiler instance. void timeTraceProfilerInitialize(unsigned TimeTraceGranularity, - StringRef ProcName, - bool TimeTraceVerbose = false); + StringRef ProcName); /// Cleanup the time trace profiler, if it was initialized. void timeTraceProfilerCleanup(); @@ -140,10 +128,6 @@ TimeTraceProfilerEntry * timeTraceProfilerBegin(StringRef Name, llvm::function_ref Detail); -TimeTraceProfilerEntry * -timeTraceProfilerBegin(StringRef Name, - llvm::function_ref MetaData); - /// Manually begin a time section, with the given \p Name and \p Detail. /// This starts Async Events having \p Name as a category which is shown /// separately from other traces. See @@ -180,11 +164,6 @@ class TimeTraceScope { if (getTimeTraceProfilerInstance() != nullptr) Entry = timeTraceProfilerBegin(Name, Detail); } - TimeTraceScope(StringRef Name, - llvm::function_ref Metadata) { - if (getTimeTraceProfilerInstance() != nullptr) - Entry = timeTraceProfilerBegin(Name, Metadata); - } ~TimeTraceScope() { if (getTimeTraceProfilerInstance() != nullptr) timeTraceProfilerEnd(Entry); diff --git a/llvm/lib/Support/TimeProfiler.cpp b/llvm/lib/Support/TimeProfiler.cpp index c2014028ddadca..9612db7d30f98b 100644 --- a/llvm/lib/Support/TimeProfiler.cpp +++ b/llvm/lib/Support/TimeProfiler.cpp @@ -73,20 +73,12 @@ struct llvm::TimeTraceProfilerEntry { const TimePointType Start; TimePointType End; const std::string Name; - TimeTraceMetadata Metadata; - + const std::string Detail; const bool AsyncEvent = false; TimeTraceProfilerEntry(TimePointType &&S, TimePointType &&E, std::string &&N, std::string &&Dt, bool Ae) - : Start(std::move(S)), End(std::move(E)), Name(std::move(N)), Metadata(), - AsyncEvent(Ae) { - Metadata.Detail = std::move(Dt); - } - - TimeTraceProfilerEntry(TimePointType &&S, TimePointType &&E, std::string &&N, - TimeTraceMetadata &&Mt, bool Ae) : Start(std::move(S)), End(std::move(E)), Name(std::move(N)), - Metadata(std::move(Mt)), AsyncEvent(Ae) {} + Detail(std::move(Dt)), AsyncEvent(Ae) {} // Calculate timings for FlameGraph. Cast time points to microsecond precision // rather than casting duration. This avoids truncation issues causing inner @@ -105,12 +97,10 @@ struct llvm::TimeTraceProfilerEntry { }; struct llvm::TimeTraceProfiler { - TimeTraceProfiler(unsigned TimeTraceGranularity = 0, StringRef ProcName = "", - bool TimeTraceVerbose = false) + TimeTraceProfiler(unsigned TimeTraceGranularity = 0, StringRef ProcName = "") : BeginningOfTime(system_clock::now()), StartTime(ClockType::now()), ProcName(ProcName), Pid(sys::Process::getProcessId()), - Tid(llvm::get_threadid()), TimeTraceGranularity(TimeTraceGranularity), - TimeTraceVerbose(TimeTraceVerbose) { + Tid(llvm::get_threadid()), TimeTraceGranularity(TimeTraceGranularity) { llvm::get_thread_name(ThreadName); } @@ -123,15 +113,6 @@ struct llvm::TimeTraceProfiler { return Stack.back().get(); } - TimeTraceProfilerEntry * - begin(std::string Name, llvm::function_ref Metadata, - bool AsyncEvent = false) { - Stack.emplace_back(std::make_unique( - ClockType::now(), TimePointType(), std::move(Name), Metadata(), - AsyncEvent)); - return Stack.back().get(); - } - void end() { assert(!Stack.empty() && "Must call begin() first"); end(*Stack.back()); @@ -203,15 +184,8 @@ struct llvm::TimeTraceProfiler { J.attribute("dur", DurUs); } J.attribute("name", E.Name); - if (!E.Metadata.isEmpty()) { - J.attributeObject("args", [&] { - if (!E.Metadata.Detail.empty()) - J.attribute("detail", E.Metadata.Detail); - if (!E.Metadata.File.empty()) - J.attribute("file", E.Metadata.File); - if (E.Metadata.Line > 0) - J.attribute("line", E.Metadata.Line); - }); + if (!E.Detail.empty()) { + J.attributeObject("args", [&] { J.attribute("detail", E.Detail); }); } }); @@ -333,25 +307,14 @@ struct llvm::TimeTraceProfiler { // Minimum time granularity (in microseconds) const unsigned TimeTraceGranularity; - - // Make time trace capture verbose event details (e.g. source filenames). This - // can increase the size of the output by 2-3 times. - const bool TimeTraceVerbose; }; -bool llvm::isTimeTraceVerbose() { - return getTimeTraceProfilerInstance() && - getTimeTraceProfilerInstance()->TimeTraceVerbose; -} - void llvm::timeTraceProfilerInitialize(unsigned TimeTraceGranularity, - StringRef ProcName, - bool TimeTraceVerbose) { + StringRef ProcName) { assert(TimeTraceProfilerInstance == nullptr && "Profiler should not be initialized"); TimeTraceProfilerInstance = new TimeTraceProfiler( - TimeTraceGranularity, llvm::sys::path::filename(ProcName), - TimeTraceVerbose); + TimeTraceGranularity, llvm::sys::path::filename(ProcName)); } // Removes all TimeTraceProfilerInstances. @@ -418,14 +381,6 @@ llvm::timeTraceProfilerBegin(StringRef Name, return nullptr; } -TimeTraceProfilerEntry * -llvm::timeTraceProfilerBegin(StringRef Name, - llvm::function_ref Metadata) { - if (TimeTraceProfilerInstance != nullptr) - return TimeTraceProfilerInstance->begin(std::string(Name), Metadata, false); - return nullptr; -} - TimeTraceProfilerEntry *llvm::timeTraceAsyncProfilerBegin(StringRef Name, StringRef Detail) { if (TimeTraceProfilerInstance != nullptr)