add record tags for command buffer kernel records

Author: bashbaug

intercept/src/dispatch.cpp

@@ -11425,13 +11425,14 @@ CL_API_ENTRY cl_int CL_API_CALL clCommandNDRangeKernelKHR(
                 command_queue,
                 kernel,
                 argsString.c_str() );
-            GET_TIMING_TAGS_COMMAND_BUFFER_KERNEL(
+            GET_RECORD_TAG_COMMAND_BUFFER_KERNEL(
                 command_buffer,
                 kernel,
                 work_dim,
                 global_work_offset,
                 global_work_size,
-                local_work_size );
+                local_work_size,
+                mutable_handle );
             HOST_PERFORMANCE_TIMING_START();
 
             cl_int  retVal = dispatchX.clCommandNDRangeKernelKHR(

intercept/src/intercept.cpp

@@ -6005,30 +6005,93 @@ void CLIntercept::getTimingTagsKernel(
 
 ///////////////////////////////////////////////////////////////////////////////
 //
-void CLIntercept::getTimingTagsCommandBufferKernel(
+void CLIntercept::getRecordTagCommandBufferKernel(
     const cl_command_buffer_khr cmdbuf,
     const cl_kernel kernel,
     const cl_uint workDim,
     const size_t* gwo,
     const size_t* gws,
     const size_t* lws,
-    std::string& hostTag,
-    std::string& deviceTag )
+    const cl_mutable_command_khr* mutable_handle,
+    std::string& recordTag )
 {
-    cl_command_queue queue = getCommandBufferCommandQueue(
-        0,
-        nullptr,
-        cmdbuf );
+    std::lock_guard<std::mutex> lock(m_Mutex);
 
-    getTimingTagsKernel(
-        queue,
-        kernel,
-        workDim,
-        gwo,
-        gws,
-        lws,
-        hostTag,
-        deviceTag );
+    if( kernel )
+    {
+        std::ostringstream  ss;
+
+        recordTag += getShortKernelNameWithHash(kernel);
+
+        if( gwo )
+        {
+            ss << " GWO[ ";
+            if( workDim >= 1 )
+            {
+                ss << gwo[0];
+            }
+            if( workDim >= 2 )
+            {
+                ss << ", " << gwo[1];
+            }
+            if( workDim >= 3 )
+            {
+                ss << ", " << gwo[2];
+            }
+            ss << " ]";
+        }
+
+        ss << " GWS[ ";
+        if( gws )
+        {
+            if( workDim >= 1 )
+            {
+                ss << gws[0];
+            }
+            if( workDim >= 2 )
+            {
+                ss << " x " << gws[1];
+            }
+            if( workDim >= 3 )
+            {
+                ss << " x " << gws[2];
+            }
+        }
+        else
+        {
+            ss << "NULL";
+        }
+        ss << " ]";
+
+        ss << " LWS[ ";
+        if( lws )
+        {
+            if( workDim >= 1 )
+            {
+                ss << lws[0];
+            }
+            if( workDim >= 2 )
+            {
+                ss << " x " << lws[1];
+            }
+            if( workDim >= 3 )
+            {
+                ss << " x " << lws[2];
+            }
+        }
+        else
+        {
+            ss << "NULL";
+        }
+        ss << " ]";
+
+        if( mutable_handle )
+        {
+            ss << " [MUTABLE]";
+        }
+
+        recordTag += ss.str();
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -7171,6 +7234,7 @@ void CLIntercept::checkRemoveCommandBufferInfo(
             if( errorCode == CL_SUCCESS && refCount == 1 )
             {
                 m_CommandBufferInfoMap.erase( iter );
+                m_CommandBufferRecordMap.erase( cmdbuf );
 
                 CCommandBufferMutableCommandsMap::iterator cmditer =
                     m_CommandBufferMutableCommandsMap.find( cmdbuf );

intercept/src/intercept.h

@@ -419,15 +419,15 @@ class CLIntercept
                 const size_t* lws,
                 std::string& hostTag,
                 std::string& deviceTag );
-    void    getTimingTagsCommandBufferKernel(
+    void    getRecordTagCommandBufferKernel(
                 const cl_command_buffer_khr cmdbuf,
                 const cl_kernel kernel,
                 const cl_uint workDim,
                 const size_t* gwo,
                 const size_t* gws,
                 const size_t* lws,
-                std::string& hostTag,
-                std::string& deviceTag );
+                const cl_mutable_command_khr* mutable_handle,
+                std::string& recordTag);
 
     void    updateHostTimingStats(
                 const char* functionName,
@@ -3203,19 +3203,19 @@ inline bool CLIntercept::checkAubCaptureEnqueueLimits(
             deviceTag );                                                    \
     }
 
-#define GET_TIMING_TAGS_COMMAND_BUFFER_KERNEL( _cmdbuf, _kernel, _dim, _gwo, _gws, _lws )\
-    std::string hostTag, deviceTag;                                         \
+#define GET_RECORD_TAG_COMMAND_BUFFER_KERNEL( _cmdbuf, _kernel, _dim, _gwo, _gws, _lws, _mh )\
+    std::string recordTag;                                                  \
     if( pIntercept->config().DumpCommandBuffers )                           \
     {                                                                       \
-        pIntercept->getTimingTagsCommandBufferKernel(                       \
+        pIntercept->getRecordTagCommandBufferKernel(                        \
             _cmdbuf,                                                        \
             _kernel,                                                        \
             _dim,                                                           \
             _gwo,                                                           \
             _gws,                                                           \
             _lws,                                                           \
-            hostTag,                                                        \
-            deviceTag );                                                    \
+            _mh,                                                            \
+            recordTag );                                                    \
     }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -3518,7 +3518,7 @@ inline void CLIntercept::flushChromeTraceBuffering()
         pIntercept->recordCommandBufferCommand(                             \
             _cmdbuf,                                                        \
             __FUNCTION__,                                                   \
-            hostTag,                                                        \
+            recordTag,                                                      \
             _nspwl,                                                         \
             _spwl,                                                          \
             _sp);                                                           \