Add trace event to angle Program compilation API

bergeret · Commit Bot · commit 7685a79eb4a3 · 2020-06-04T20:42:40.000Z
Bug: chromium:1064662 Change-Id: I2ee48718ff3946ab9307ba27177a02858bf436b0 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2230789 Commit-Queue: Etienne Bergeron <etienneb@chromium.org> Reviewed-by: Jamie Madill <jmadill@chromium.org>
diff --git a/src/libANGLE/WorkerThread.cpp b/src/libANGLE/WorkerThread.cpp
@@ -10,6 +10,8 @@
 
 #include "libANGLE/WorkerThread.h"
 
+#include "libANGLE/trace.h"
+
 #if (ANGLE_STD_ASYNC_WORKERS == ANGLE_ENABLED)
 #    include <condition_variable>
 #    include <future>
@@ -88,7 +90,7 @@ class AsyncWaitableEvent final : public WaitableEvent
     friend class AsyncWorkerPool;
     void setFuture(std::future<void> &&future);
 
-    // To block wait() when the task is stil in queue to be run.
+    // To block wait() when the task is still in queue to be run.
     // Also to protect the concurrent accesses from both main thread and
     // background threads to the member fields.
     std::mutex mMutex;
@@ -105,6 +107,7 @@ void AsyncWaitableEvent::setFuture(std::future<void> &&future)
 
 void AsyncWaitableEvent::wait()
 {
+    ANGLE_TRACE_EVENT0("gpu.angle", "AsyncWaitableEvent::wait");
     {
         std::unique_lock<std::mutex> lock(mMutex);
         mCondition.wait(lock, [this] { return !mIsPending; });
@@ -186,7 +189,10 @@ void AsyncWorkerPool::checkToRunPendingTasks()
         auto closure  = task.second;
 
         auto future = std::async(std::launch::async, [closure, this] {
-            (*closure)();
+            {
+                ANGLE_TRACE_EVENT0("gpu.angle", "AsyncWorkerPool::RunTask");
+                (*closure)();
+            }
             {
                 std::lock_guard<std::mutex> lock(mMutex);
                 ASSERT(mRunningThreads != 0);
diff --git a/src/libANGLE/renderer/ShaderImpl.cpp b/src/libANGLE/renderer/ShaderImpl.cpp
@@ -9,6 +9,7 @@
 #include "libANGLE/renderer/ShaderImpl.h"
 
 #include "libANGLE/Context.h"
+#include "libANGLE/trace.h"
 
 namespace rx
 {
@@ -46,6 +47,7 @@ class TranslateTask : public angle::Closure
 
     void operator()() override
     {
+        ANGLE_TRACE_EVENT1("gpu.angle", "TranslateTask::run", "source", mSource);
         const char *source = mSource.c_str();
         mResult            = sh::Compile(mHandle, &source, 1, mOptions);
     }
diff --git a/src/libANGLE/renderer/d3d/HLSLCompiler.cpp b/src/libANGLE/renderer/d3d/HLSLCompiler.cpp
@@ -236,7 +236,7 @@ angle::Result HLSLCompiler::compileToBinary(d3d::Context *context,
         HRESULT result         = S_OK;
 
         {
-            ANGLE_TRACE_EVENT0("gpu.angle", "D3DCompile");
+            ANGLE_TRACE_EVENT1("gpu.angle", "D3DCompile", "source", hlsl);
             SCOPED_ANGLE_HISTOGRAM_TIMER("GPU.ANGLE.D3DCompileMS");
             result = mD3DCompileFunc(hlsl.c_str(), hlsl.length(), gl::g_fakepath, macros, nullptr,
                                      "main", profile.c_str(), configs[i].flags, 0, &binary,
@@ -247,6 +247,7 @@ angle::Result HLSLCompiler::compileToBinary(d3d::Context *context,
         {
             std::string message = static_cast<const char *>(errorMessage->GetBufferPointer());
             SafeRelease(errorMessage);
+            ANGLE_TRACE_EVENT1("gpu.angle", "D3DCompile::Error", "error", errorMessage);
 
             infoLog.appendSanitized(message.c_str());
 
diff --git a/src/libANGLE/renderer/d3d/ProgramD3D.cpp b/src/libANGLE/renderer/d3d/ProgramD3D.cpp
@@ -29,6 +29,7 @@
 #include "libANGLE/renderer/d3d/ShaderExecutableD3D.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
 #include "libANGLE/renderer/renderer_utils.h"
+#include "libANGLE/trace.h"
 
 using namespace angle;
 
@@ -898,6 +899,7 @@ class ProgramD3D::LoadBinaryTask : public ProgramD3D::GetExecutableTask
 
     angle::Result run() override
     {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::LoadBinaryTask::run");
         if (!mDataCopySucceeded)
         {
             mInfoLog << "Failed to copy program binary data to local buffer.";
@@ -1685,6 +1687,7 @@ class ProgramD3D::GetVertexExecutableTask : public ProgramD3D::GetExecutableTask
     GetVertexExecutableTask(ProgramD3D *program) : GetExecutableTask(program) {}
     angle::Result run() override
     {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetVertexExecutableTask::run");
         if (!mProgram->mState.getAttachedShader(gl::ShaderType::Vertex))
         {
             return angle::Result::Continue;
@@ -1712,6 +1715,7 @@ class ProgramD3D::GetPixelExecutableTask : public ProgramD3D::GetExecutableTask
     GetPixelExecutableTask(ProgramD3D *program) : GetExecutableTask(program) {}
     angle::Result run() override
     {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetPixelExecutableTask::run");
         if (!mProgram->mState.getAttachedShader(gl::ShaderType::Fragment))
         {
             return angle::Result::Continue;
@@ -1747,6 +1751,7 @@ class ProgramD3D::GetGeometryExecutableTask : public ProgramD3D::GetExecutableTa
 
     angle::Result run() override
     {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetGeometryExecutableTask::run");
         // Auto-generate the geometry shader here, if we expect to be using point rendering in
         // D3D11.
         if (mProgram->usesGeometryShader(mState, gl::PrimitiveMode::Points))
@@ -1768,6 +1773,7 @@ class ProgramD3D::GetComputeExecutableTask : public ProgramD3D::GetExecutableTas
     GetComputeExecutableTask(ProgramD3D *program) : GetExecutableTask(program) {}
     angle::Result run() override
     {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetComputeExecutableTask::run");
         mProgram->updateCachedImage2DBindLayoutFromComputeShader();
         ShaderExecutableD3D *computeExecutable = nullptr;
         ANGLE_TRY(mProgram->getComputeExecutableForImage2DBindLayout(this, &computeExecutable,
@@ -1806,6 +1812,7 @@ class ProgramD3D::GraphicsProgramLinkEvent final : public LinkEvent
 
     angle::Result wait(const gl::Context *context) override
     {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GraphicsProgramLinkEvent::wait");
         WaitableEvent::WaitMany(&mWaitEvents);
 
         ANGLE_TRY(checkTask(context, mVertexTask.get()));
@@ -1906,6 +1913,7 @@ class ProgramD3D::ComputeProgramLinkEvent final : public LinkEvent
 
     angle::Result wait(const gl::Context *context) override
     {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::ComputeProgramLinkEvent::wait");
         mWaitEvent->wait();
 
         angle::Result result = mComputeTask->getResult();
@@ -1925,6 +1933,7 @@ class ProgramD3D::ComputeProgramLinkEvent final : public LinkEvent
 std::unique_ptr<LinkEvent> ProgramD3D::compileProgramExecutables(const gl::Context *context,
                                                                  gl::InfoLog &infoLog)
 {
+    ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::compileProgramExecutables");
     // Ensure the compiler is initialized to avoid race conditions.
     angle::Result result = mRenderer->ensureHLSLCompilerInitialized(GetImplAs<ContextD3D>(context));
     if (result != angle::Result::Continue)
@@ -1950,6 +1959,7 @@ std::unique_ptr<LinkEvent> ProgramD3D::compileProgramExecutables(const gl::Conte
 std::unique_ptr<LinkEvent> ProgramD3D::compileComputeExecutable(const gl::Context *context,
                                                                 gl::InfoLog &infoLog)
 {
+    ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::compileComputeExecutable");
     // Ensure the compiler is initialized to avoid race conditions.
     angle::Result result = mRenderer->ensureHLSLCompilerInitialized(GetImplAs<ContextD3D>(context));
     if (result != angle::Result::Continue)
@@ -1982,6 +1992,7 @@ angle::Result ProgramD3D::getComputeExecutableForImage2DBindLayout(
     ShaderExecutableD3D **outExecutable,
     gl::InfoLog *infoLog)
 {
+    ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::getComputeExecutableForImage2DBindLayout");
     if (mCachedComputeExecutableIndex.valid())
     {
         *outExecutable =
@@ -2023,6 +2034,7 @@ std::unique_ptr<LinkEvent> ProgramD3D::link(const gl::Context *context,
                                             const gl::ProgramLinkedResources &resources,
                                             gl::InfoLog &infoLog)
 {
+    ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::link");
     const auto &data = context->getState();
 
     reset();
diff --git a/src/libANGLE/renderer/d3d/ShaderD3D.cpp b/src/libANGLE/renderer/d3d/ShaderD3D.cpp
@@ -16,6 +16,7 @@
 #include "libANGLE/features.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
+#include "libANGLE/trace.h"
 
 namespace rx
 {
@@ -36,6 +37,7 @@ class TranslateTaskD3D : public angle::Closure
 
     void operator()() override
     {
+        ANGLE_TRACE_EVENT1("gpu.angle", "TranslateTask::run", "source", mSource);
         std::vector<const char *> srcStrings;
         if (!mSourcePath.empty())
         {
diff --git a/src/libANGLE/renderer/gl/ProgramGL.cpp b/src/libANGLE/renderer/gl/ProgramGL.cpp
@@ -23,6 +23,7 @@
 #include "libANGLE/renderer/gl/RendererGL.h"
 #include "libANGLE/renderer/gl/ShaderGL.h"
 #include "libANGLE/renderer/gl/StateManagerGL.h"
+#include "libANGLE/trace.h"
 #include "platform/FeaturesGL.h"
 #include "platform/PlatformMethods.h"
 
@@ -59,6 +60,7 @@ std::unique_ptr<LinkEvent> ProgramGL::load(const gl::Context *context,
                                            gl::BinaryInputStream *stream,
                                            gl::InfoLog &infoLog)
 {
+    ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::load");
     preLink();
 
     // Read the binary format, size and blob
@@ -135,7 +137,12 @@ class ProgramGL::LinkTask final : public angle::Closure
     LinkTask(LinkImplFunctor &&functor) : mLinkImplFunctor(functor), mFallbackToMainContext(false)
     {}
 
-    void operator()() override { mFallbackToMainContext = mLinkImplFunctor(mInfoLog); }
+    void operator()() override
+    {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::LinkTask::run");
+        mFallbackToMainContext = mLinkImplFunctor(mInfoLog);
+    }
+
     bool fallbackToMainContext() { return mFallbackToMainContext; }
     const std::string &getInfoLog() { return mInfoLog; }
 
@@ -159,6 +166,8 @@ class ProgramGL::LinkEventNativeParallel final : public LinkEvent
 
     angle::Result wait(const gl::Context *context) override
     {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::LinkEventNativeParallel::wait");
+
         GLint linkStatus = GL_FALSE;
         mFunctions->getProgramiv(mProgramID, GL_LINK_STATUS, &linkStatus);
         if (linkStatus == GL_TRUE)
@@ -196,6 +205,8 @@ class ProgramGL::LinkEventGL final : public LinkEvent
 
     angle::Result wait(const gl::Context *context) override
     {
+        ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::LinkEventGL::wait");
+
         mWaitableEvent->wait();
         return mPostLinkImplFunctor(mLinkTask->fallbackToMainContext(), mLinkTask->getInfoLog());
     }
@@ -212,6 +223,8 @@ std::unique_ptr<LinkEvent> ProgramGL::link(const gl::Context *context,
                                            const gl::ProgramLinkedResources &resources,
                                            gl::InfoLog &infoLog)
 {
+    ANGLE_TRACE_EVENT0("gpu.angle", "ProgramGL::link");
+
     preLink();
 
     if (mState.getAttachedShader(gl::ShaderType::Compute))
diff --git a/src/libANGLE/renderer/gl/ShaderGL.cpp b/src/libANGLE/renderer/gl/ShaderGL.cpp
@@ -13,6 +13,7 @@
 #include "libANGLE/Context.h"
 #include "libANGLE/renderer/gl/FunctionsGL.h"
 #include "libANGLE/renderer/gl/RendererGL.h"
+#include "libANGLE/trace.h"
 #include "platform/FeaturesGL.h"
 
 #include <iostream>
@@ -38,6 +39,7 @@ class TranslateTaskGL : public angle::Closure
 
     void operator()() override
     {
+        ANGLE_TRACE_EVENT1("gpu.angle", "TranslateTaskGL::run", "source", mSource);
         const char *source = mSource.c_str();
         mResult            = sh::Compile(mHandle, &source, 1, mOptions);
         if (mResult)
diff --git a/src/libANGLE/trace.h b/src/libANGLE/trace.h
@@ -20,5 +20,7 @@
 #define ANGLE_TRACE_EVENT_INSTANT0(CATEGORY, EVENT) \
     TRACE_EVENT_INSTANT0(ANGLEPlatformCurrent(), CATEGORY, EVENT)
 #define ANGLE_TRACE_EVENT0(CATEGORY, EVENT) TRACE_EVENT0(ANGLEPlatformCurrent(), CATEGORY, EVENT)
+#define ANGLE_TRACE_EVENT1(CATEGORY, EVENT, NAME, PARAM) \
+    TRACE_EVENT1(ANGLEPlatformCurrent(), CATEGORY, EVENT, NAME, PARAM)
 
 #endif  // LIBANGLE_TRACE_H_

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`#include "libANGLE/renderer/ShaderImpl.h"`
`10`	`10`
`11`	`11`	`#include "libANGLE/Context.h"`
	`12`	`+#include "libANGLE/trace.h"`
`12`	`13`
`13`	`14`	`namespace rx`
`14`	`15`	`{`
`@@ -46,6 +47,7 @@ class TranslateTask : public angle::Closure`
`46`	`47`
`47`	`48`	`void operator()() override`
`48`	`49`	`{`
	`50`	`+ ANGLE_TRACE_EVENT1("gpu.angle", "TranslateTask::run", "source", mSource);`
`49`	`51`	`const char *source = mSource.c_str();`
`50`	`52`	`mResult = sh::Compile(mHandle, &source, 1, mOptions);`
`51`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ angle::Result HLSLCompiler::compileToBinary(d3d::Context *context,`
`236`	`236`	`HRESULT result = S_OK;`
`237`	`237`
`238`	`238`	`{`
`239`		`- ANGLE_TRACE_EVENT0("gpu.angle", "D3DCompile");`
	`239`	`+ ANGLE_TRACE_EVENT1("gpu.angle", "D3DCompile", "source", hlsl);`
`240`	`240`	`SCOPED_ANGLE_HISTOGRAM_TIMER("GPU.ANGLE.D3DCompileMS");`
`241`	`241`	`result = mD3DCompileFunc(hlsl.c_str(), hlsl.length(), gl::g_fakepath, macros, nullptr,`
`242`	`242`	`"main", profile.c_str(), configs[i].flags, 0, &binary,`
`@@ -247,6 +247,7 @@ angle::Result HLSLCompiler::compileToBinary(d3d::Context *context,`
`247`	`247`	`{`
`248`	`248`	`std::string message = static_cast<const char *>(errorMessage->GetBufferPointer());`
`249`	`249`	`SafeRelease(errorMessage);`
	`250`	`+ ANGLE_TRACE_EVENT1("gpu.angle", "D3DCompile::Error", "error", errorMessage);`
`250`	`251`
`251`	`252`	`infoLog.appendSanitized(message.c_str());`
`252`	`253`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@`
`29`	`29`	`#include "libANGLE/renderer/d3d/ShaderExecutableD3D.h"`
`30`	`30`	`#include "libANGLE/renderer/d3d/VertexDataManager.h"`
`31`	`31`	`#include "libANGLE/renderer/renderer_utils.h"`
	`32`	`+#include "libANGLE/trace.h"`
`32`	`33`
`33`	`34`	`using namespace angle;`
`34`	`35`
`@@ -898,6 +899,7 @@ class ProgramD3D::LoadBinaryTask : public ProgramD3D::GetExecutableTask`
`898`	`899`
`899`	`900`	`angle::Result run() override`
`900`	`901`	`{`
	`902`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::LoadBinaryTask::run");`
`901`	`903`	`if (!mDataCopySucceeded)`
`902`	`904`	`{`
`903`	`905`	`mInfoLog << "Failed to copy program binary data to local buffer.";`
`@@ -1685,6 +1687,7 @@ class ProgramD3D::GetVertexExecutableTask : public ProgramD3D::GetExecutableTask`
`1685`	`1687`	`GetVertexExecutableTask(ProgramD3D *program) : GetExecutableTask(program) {}`
`1686`	`1688`	`angle::Result run() override`
`1687`	`1689`	`{`
	`1690`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetVertexExecutableTask::run");`
`1688`	`1691`	`if (!mProgram->mState.getAttachedShader(gl::ShaderType::Vertex))`
`1689`	`1692`	`{`
`1690`	`1693`	`return angle::Result::Continue;`
`@@ -1712,6 +1715,7 @@ class ProgramD3D::GetPixelExecutableTask : public ProgramD3D::GetExecutableTask`
`1712`	`1715`	`GetPixelExecutableTask(ProgramD3D *program) : GetExecutableTask(program) {}`
`1713`	`1716`	`angle::Result run() override`
`1714`	`1717`	`{`
	`1718`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetPixelExecutableTask::run");`
`1715`	`1719`	`if (!mProgram->mState.getAttachedShader(gl::ShaderType::Fragment))`
`1716`	`1720`	`{`
`1717`	`1721`	`return angle::Result::Continue;`
`@@ -1747,6 +1751,7 @@ class ProgramD3D::GetGeometryExecutableTask : public ProgramD3D::GetExecutableTa`
`1747`	`1751`
`1748`	`1752`	`angle::Result run() override`
`1749`	`1753`	`{`
	`1754`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetGeometryExecutableTask::run");`
`1750`	`1755`	`// Auto-generate the geometry shader here, if we expect to be using point rendering in`
`1751`	`1756`	`// D3D11.`
`1752`	`1757`	`if (mProgram->usesGeometryShader(mState, gl::PrimitiveMode::Points))`
`@@ -1768,6 +1773,7 @@ class ProgramD3D::GetComputeExecutableTask : public ProgramD3D::GetExecutableTas`
`1768`	`1773`	`GetComputeExecutableTask(ProgramD3D *program) : GetExecutableTask(program) {}`
`1769`	`1774`	`angle::Result run() override`
`1770`	`1775`	`{`
	`1776`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GetComputeExecutableTask::run");`
`1771`	`1777`	`mProgram->updateCachedImage2DBindLayoutFromComputeShader();`
`1772`	`1778`	`ShaderExecutableD3D *computeExecutable = nullptr;`
`1773`	`1779`	`ANGLE_TRY(mProgram->getComputeExecutableForImage2DBindLayout(this, &computeExecutable,`
`@@ -1806,6 +1812,7 @@ class ProgramD3D::GraphicsProgramLinkEvent final : public LinkEvent`
`1806`	`1812`
`1807`	`1813`	`angle::Result wait(const gl::Context *context) override`
`1808`	`1814`	`{`
	`1815`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::GraphicsProgramLinkEvent::wait");`
`1809`	`1816`	`WaitableEvent::WaitMany(&mWaitEvents);`
`1810`	`1817`
`1811`	`1818`	`ANGLE_TRY(checkTask(context, mVertexTask.get()));`
`@@ -1906,6 +1913,7 @@ class ProgramD3D::ComputeProgramLinkEvent final : public LinkEvent`
`1906`	`1913`
`1907`	`1914`	`angle::Result wait(const gl::Context *context) override`
`1908`	`1915`	`{`
	`1916`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::ComputeProgramLinkEvent::wait");`
`1909`	`1917`	`mWaitEvent->wait();`
`1910`	`1918`
`1911`	`1919`	`angle::Result result = mComputeTask->getResult();`
`@@ -1925,6 +1933,7 @@ class ProgramD3D::ComputeProgramLinkEvent final : public LinkEvent`
`1925`	`1933`	`std::unique_ptr<LinkEvent> ProgramD3D::compileProgramExecutables(const gl::Context *context,`
`1926`	`1934`	`gl::InfoLog &infoLog)`
`1927`	`1935`	`{`
	`1936`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::compileProgramExecutables");`
`1928`	`1937`	`// Ensure the compiler is initialized to avoid race conditions.`
`1929`	`1938`	`angle::Result result = mRenderer->ensureHLSLCompilerInitialized(GetImplAs<ContextD3D>(context));`
`1930`	`1939`	`if (result != angle::Result::Continue)`
`@@ -1950,6 +1959,7 @@ std::unique_ptr<LinkEvent> ProgramD3D::compileProgramExecutables(const gl::Conte`
`1950`	`1959`	`std::unique_ptr<LinkEvent> ProgramD3D::compileComputeExecutable(const gl::Context *context,`
`1951`	`1960`	`gl::InfoLog &infoLog)`
`1952`	`1961`	`{`
	`1962`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::compileComputeExecutable");`
`1953`	`1963`	`// Ensure the compiler is initialized to avoid race conditions.`
`1954`	`1964`	`angle::Result result = mRenderer->ensureHLSLCompilerInitialized(GetImplAs<ContextD3D>(context));`
`1955`	`1965`	`if (result != angle::Result::Continue)`
`@@ -1982,6 +1992,7 @@ angle::Result ProgramD3D::getComputeExecutableForImage2DBindLayout(`
`1982`	`1992`	`ShaderExecutableD3D **outExecutable,`
`1983`	`1993`	`gl::InfoLog *infoLog)`
`1984`	`1994`	`{`
	`1995`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::getComputeExecutableForImage2DBindLayout");`
`1985`	`1996`	`if (mCachedComputeExecutableIndex.valid())`
`1986`	`1997`	`{`
`1987`	`1998`	`*outExecutable =`
`@@ -2023,6 +2034,7 @@ std::unique_ptr<LinkEvent> ProgramD3D::link(const gl::Context *context,`
`2023`	`2034`	`const gl::ProgramLinkedResources &resources,`
`2024`	`2035`	`gl::InfoLog &infoLog)`
`2025`	`2036`	`{`
	`2037`	`+ ANGLE_TRACE_EVENT0("gpu.angle", "ProgramD3D::link");`
`2026`	`2038`	`const auto &data = context->getState();`
`2027`	`2039`
`2028`	`2040`	`reset();`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@`
`16`	`16`	`#include "libANGLE/features.h"`
`17`	`17`	`#include "libANGLE/renderer/d3d/ProgramD3D.h"`
`18`	`18`	`#include "libANGLE/renderer/d3d/RendererD3D.h"`
	`19`	`+#include "libANGLE/trace.h"`
`19`	`20`
`20`	`21`	`namespace rx`
`21`	`22`	`{`
`@@ -36,6 +37,7 @@ class TranslateTaskD3D : public angle::Closure`
`36`	`37`
`37`	`38`	`void operator()() override`
`38`	`39`	`{`
	`40`	`+ ANGLE_TRACE_EVENT1("gpu.angle", "TranslateTask::run", "source", mSource);`
`39`	`41`	`std::vector<const char *> srcStrings;`
`40`	`42`	`if (!mSourcePath.empty())`
`41`	`43`	`{`