itkOpenCLEvent.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkOpenCLEvent_h
#define itkOpenCLEvent_h
 
#include "itkOpenCL.h"
#include "itkOpenCLExtension.h"
#include <ostream>
 
namespace itk
{
// Forward declaration
class OpenCLUserEvent;
 
class ITKOpenCL_EXPORT OpenCLEvent
{
public:
  using Self = OpenCLEvent;
 
  OpenCLEvent();
 
  OpenCLEvent(const cl_event id);
 
  OpenCLEvent(const OpenCLEvent & other);
 
  ~OpenCLEvent();
 
  OpenCLEvent &
  operator=(const OpenCLEvent & other);
 
  bool
  IsNull() const
  {
    return this->m_Id == 0;
  }
 
  cl_event
  GetEventId() const
  {
    return this->m_Id;
  }
 
  bool
  IsQueued() const
  {
    return GetStatus() == CL_QUEUED;
  }
 
  bool
  IsSubmitted() const
  {
    return GetStatus() == CL_SUBMITTED;
  }
 
  bool
  IsRunning() const
  {
    return GetStatus() == CL_RUNNING;
  }
 
  bool
  IsComplete() const
  {
    return GetStatus() == CL_COMPLETE;
  }
 
  bool
  IsError() const
  {
    return GetStatus() < 0;
  }
 
  cl_int
  GetStatus() const;
 
  cl_command_type
  GetCommandType() const;
 
  cl_int
  WaitForFinished();
 
  cl_int
  SetCallback(cl_int type, void(CL_CALLBACK * pfn_notify)(cl_event, cl_int, void *), void * user_data = nullptr);
 
  cl_ulong
  GetQueueTime() const;
 
  cl_ulong
  GetSubmitTime() const;
 
  cl_ulong
  GetRunTime() const;
 
  cl_ulong
  GetFinishTime() const;
 
private:
  cl_event m_Id;
 
  friend class OpenCLUserEvent;
};
 
bool ITKOpenCL_EXPORT
     operator==(const OpenCLEvent & lhs, const OpenCLEvent & rhs);
 
bool ITKOpenCL_EXPORT
     operator!=(const OpenCLEvent & lhs, const OpenCLEvent & rhs);
 
template <typename charT, typename traits>
inline std::basic_ostream<charT, traits> &
operator<<(std::basic_ostream<charT, traits> & strm, const OpenCLEvent & event)
{
  const cl_event id = event.GetEventId();
 
  if (!id)
  {
    strm << "OpenCLEvent()";
    return strm;
  }
 
  const cl_command_type command = event.GetCommandType();
  const cl_int          status = event.GetStatus();
 
  // Get command name, check for clGetEventInfo() specification
  const char * commandName;
  switch (command)
  {
    case CL_COMMAND_NDRANGE_KERNEL:
      commandName = "clEnqueueNDRangeKernel";
      break;
    case CL_COMMAND_TASK:
      commandName = "clEnqueueTask";
      break;
    case CL_COMMAND_NATIVE_KERNEL:
      commandName = "clEnqueueNativeKernel";
      break;
    case CL_COMMAND_READ_BUFFER:
      commandName = "clEnqueueReadBuffer";
      break;
    case CL_COMMAND_WRITE_BUFFER:
      commandName = "clEnqueueWriteBuffer";
      break;
    case CL_COMMAND_COPY_BUFFER:
      commandName = "clEnqueueCopyBuffer";
      break;
    case CL_COMMAND_READ_IMAGE:
      commandName = "clEnqueueReadImage";
      break;
    case CL_COMMAND_WRITE_IMAGE:
      commandName = "clEnqueueWriteImage";
      break;
    case CL_COMMAND_COPY_IMAGE:
      commandName = "clEnqueueCopyImage";
      break;
    case CL_COMMAND_COPY_IMAGE_TO_BUFFER:
      commandName = "clEnqueueCopyImageToBuffer";
      break;
    case CL_COMMAND_COPY_BUFFER_TO_IMAGE:
      commandName = "clEnqueueCopyBufferToImage";
      break;
    case CL_COMMAND_MAP_BUFFER:
      commandName = "clEnqueueMapBuffer";
      break;
    case CL_COMMAND_MAP_IMAGE:
      commandName = "clEnqueueMapImage";
      break;
    case CL_COMMAND_UNMAP_MEM_OBJECT:
      commandName = "clEnqueueUnmapMemObject";
      break;
    case CL_COMMAND_MARKER:
      commandName = "clEnqueueMarker";
      break;
    case CL_COMMAND_ACQUIRE_GL_OBJECTS:
      commandName = "clEnqueueAcquireGLObjects";
      break;
    case CL_COMMAND_RELEASE_GL_OBJECTS:
      commandName = "clEnqueueReleaseGLObjects";
      break;
    // OpenCL 1.1 event types.
    case CL_COMMAND_READ_BUFFER_RECT:
      commandName = "clEnqueueReadBufferRect";
      break;
    case CL_COMMAND_WRITE_BUFFER_RECT:
      commandName = "clEnqueueWriteBufferRect";
      break;
    case CL_COMMAND_COPY_BUFFER_RECT:
      commandName = "clEnqueueCopyBufferRect";
      break;
    case CL_COMMAND_USER:
      commandName = "clCreateUserEvent";
      break;
    // OpenCL 1.2 event types.
    case CL_COMMAND_BARRIER:
      commandName = "clEnqueueBarrierWithWaitList";
      break;
    case CL_COMMAND_MIGRATE_MEM_OBJECTS:
      commandName = "clEnqueueFillImage";
      break;
    case CL_COMMAND_FILL_BUFFER:
      commandName = "clEnqueueFillBuffer";
      break;
    case CL_COMMAND_FILL_IMAGE:
      commandName = "clEnqueueFillImage";
      break;
    default:
      commandName = "Unknown";
      break;
  }
 
  // Get command status
  const char * statusName;
  switch (status)
  {
    case CL_COMPLETE:
      statusName = "completed";
      break;
    case CL_RUNNING:
      statusName = "running";
      break;
    case CL_SUBMITTED:
      statusName = "submitted";
      break;
    case CL_QUEUED:
      statusName = "queued";
      break;
    default:
      statusName = "Unknown";
      break;
  }
  if (status != CL_COMPLETE)
  {
    // Command is not complete : no profiling information available yet.
    strm << "OpenCLEvent(id:" << reinterpret_cast<long>(id) << " command:" << commandName << " status:" << statusName
         << ")";
  }
  else
  {
    cl_ulong queueTime, runTime, finishTime;
    if (clGetEventProfilingInfo(id, CL_PROFILING_COMMAND_QUEUED, sizeof(queueTime), &queueTime, 0) != CL_SUCCESS ||
        clGetEventProfilingInfo(id, CL_PROFILING_COMMAND_START, sizeof(runTime), &runTime, 0) != CL_SUCCESS ||
        clGetEventProfilingInfo(id, CL_PROFILING_COMMAND_END, sizeof(finishTime), &finishTime, 0) != CL_SUCCESS)
    {
      // Profiling information is not available, probably
      // because it was not enabled on the command queue.
      strm << "OpenCLEvent(id:" << reinterpret_cast<long>(id) << " command:" << commandName << " status:" << statusName
           << ")";
    }
    else
    {
      // Include profiling information in the debug output.
      const double fullDuration = (finishTime - queueTime) / 1000000.0f;
      const double runDuration = (finishTime - runTime) / 1000000.0f;
      strm << "OpenCLEvent(id:" << reinterpret_cast<long>(id) << " command:" << commandName << " status:" << statusName
           << " full-time:" << fullDuration << " ms running-time:" << runDuration << "ms)";
    }
  }
 
  return strm;
}
 
 
} // end namespace itk
 
#endif /* itkOpenCLEvent_h */