OpenClTimer Class Reference

OpenClTimer instrument that times all OpenCl kernels executed between calls to Start() and Stop(). More...

#include <OpenClTimer.hpp>

Inheritance diagram for OpenClTimer:

Collaboration diagram for OpenClTimer:

Public Member Functions
	OpenClTimer ()
	~OpenClTimer ()=default
void	Start () override
	Start the OpenCl timer.
void	Stop () override
	Stop the OpenCl timer.
bool	HasKernelMeasurements () const override
	Return true if this Instrument has kernels for recording measurements.
const char *	GetName () const override
	Get the name of the timer.
std::vector< Measurement >	GetMeasurements () const override
	Get the recorded measurements.
Public Member Functions inherited from Instrument
virtual	~Instrument ()

Detailed Description

OpenClTimer instrument that times all OpenCl kernels executed between calls to Start() and Stop().

Definition at line 20 of file OpenClTimer.hpp.

Constructor & Destructor Documentation

OpenClTimer()

OpenClTimer

(

)

Definition at line 17 of file OpenClTimer.cpp.

{
}

~OpenClTimer()

~OpenClTimer ( )

default

Member Function Documentation

GetMeasurements()

std::vector< Measurement > GetMeasurements ( ) const

overridevirtual

Get the recorded measurements.

This will be a list of the execution durations for all the OpenCl kernels.

Returns

Recorded measurements

Implements Instrument.

Definition at line 93 of file OpenClTimer.cpp.

{
    std::vector<Measurement> measurements;
 
    cl_command_queue_properties clQueueProperties = CLScheduler::get().queue().getInfo<CL_QUEUE_PROPERTIES>();
 
    int idx = 0;
    for (auto& kernel : m_Kernels)
    {
        std::string name = std::string(this->GetName()) + "/" + std::to_string(idx++) + ": " + kernel.m_Name;
 
        double timeUs = 0.0;
        if((clQueueProperties & CL_QUEUE_PROFILING_ENABLE) != 0)
        {
            // Wait for the event to finish before accessing profile results.
            kernel.m_Event.wait();
 
            cl_ulong start = kernel.m_Event.getProfilingInfo<CL_PROFILING_COMMAND_START>();
            cl_ulong end   = kernel.m_Event.getProfilingInfo<CL_PROFILING_COMMAND_END>();
            timeUs = static_cast<double>(end - start) / 1000.0;
        }
 
        measurements.emplace_back(name, timeUs, Measurement::Unit::TIME_US);
    }
 
    return measurements;
}

References GetName(), and Measurement::TIME_US.

GetName()

const char * GetName ( ) const

inlineoverridevirtual

Get the name of the timer.

Returns

Name of the timer

Implements Instrument.

Definition at line 37 of file OpenClTimer.hpp.

{ return "OpenClKernelTimer"; }

Referenced by GetMeasurements().

HasKernelMeasurements()

bool HasKernelMeasurements ( ) const

overridevirtual

Return true if this Instrument has kernels for recording measurements.

Reimplemented from Instrument.

Definition at line 88 of file OpenClTimer.cpp.

{
    return m_Kernels.size() > 0;
}

Start()

void Start ( )

overridevirtual

Start the OpenCl timer.

Implements Instrument.

Definition at line 21 of file OpenClTimer.cpp.

{
    m_Kernels.clear();
 
    auto interceptor = [this](  cl_command_queue command_queue,
                                cl_kernel        kernel,
                                cl_uint          work_dim,
                                const size_t    *gwo,
                                const size_t    *gws,
                                const size_t    *lws,
                                cl_uint          num_events_in_wait_list,
                                const cl_event * event_wait_list,
                                cl_event *       event)
        {
            IgnoreUnused(event);
            cl_int retVal = 0;
 
            // Get the name of the kernel
            cl::Kernel retainedKernel(kernel, true);
            std::stringstream ss;
            ss << retainedKernel.getInfo<CL_KERNEL_FUNCTION_NAME>();
 
            // Embed workgroup sizes into the name
            if(gws != nullptr)
            {
                ss << " GWS[" << gws[0] << "," << gws[1] << "," << gws[2] << "]";
            }
            if(lws != nullptr)
            {
                ss << " LWS[" << lws[0] << "," << lws[1] << "," << lws[2] << "]";
            }
 
            cl_event customEvent;
 
            // Forward to original OpenCl function
            retVal = m_OriginalEnqueueFunction( command_queue,
                                                kernel,
                                                work_dim,
                                                gwo,
                                                gws,
                                                lws,
                                                num_events_in_wait_list,
                                                event_wait_list,
                                                &customEvent);
 
            // Store the Kernel info for later GetMeasurements() call
            m_Kernels.emplace_back(ss.str(), customEvent);
 
            if(event != nullptr)
            {
                //return cl_event from the intercepted call
                clRetainEvent(customEvent);
                *event = customEvent;
            }
 
            return retVal;
        };
 
    m_OriginalEnqueueFunction = CLSymbols::get().clEnqueueNDRangeKernel_ptr;
    CLSymbols::get().clEnqueueNDRangeKernel_ptr = interceptor;
}

References armnn::IgnoreUnused().

Stop()

void Stop ( )

overridevirtual

Stop the OpenCl timer.

Implements Instrument.

Definition at line 83 of file OpenClTimer.cpp.

{
    CLSymbols::get().clEnqueueNDRangeKernel_ptr = m_OriginalEnqueueFunction;
}

---

The documentation for this class was generated from the following files:

• src/backends/cl/OpenClTimer.hpp
• src/backends/cl/OpenClTimer.cpp