/* * Copyright (c) 2017, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //! //! \file cm_event_rt.h //! \brief Contains CmEventRT declarations. //! #ifndef MEDIADRIVER_AGNOSTIC_COMMON_CM_CMEVENTRT_H_ #define MEDIADRIVER_AGNOSTIC_COMMON_CM_CMEVENTRT_H_ #include "cm_event.h" #include "cm_csync.h" #include "cm_hal.h" #include "cm_log.h" namespace CMRT_UMD { class CmDeviceRT; class CmEventRT; class CmQueueRT; class CmTaskRT; class CmTaskInternal; class CmThreadGroupSpace; class CmThreadSpaceRT; }; #define CM_CALLBACK __cdecl typedef void (CM_CALLBACK *EventCallBackFunction)(CMRT_UMD::CmEventRT*, void*); namespace CMRT_UMD { class CmEventRT: public CmEvent { public: static int32_t Create(uint32_t index, CmQueueRT *queue, CmTaskInternal *task, int32_t taskDriverId, CmDeviceRT *device, bool isVisible, CmEventRT *&event); static int32_t Destroy(CmEventRT *&event); CM_RT_API int32_t GetStatus(CM_STATUS &status); CM_RT_API int32_t GetExecutionTime(uint64_t &time); CM_RT_API int32_t WaitForTaskFinished(uint32_t timeOutMs = CM_MAX_TIMEOUT_MS); CM_RT_API int32_t GetSurfaceDetails(uint32_t kernIndex, uint32_t surfBTI, CM_SURFACE_DETAILS &outDetails); CM_RT_API int32_t GetProfilingInfo(CM_EVENT_PROFILING_INFO infoType, size_t paramSize, void *inputValue, void *value); CM_RT_API int32_t GetExecutionTickTime(uint64_t &ticks); int32_t GetIndex(uint32_t &index); int32_t SetTaskDriverId(int32_t id); int32_t GetTaskDriverId(int32_t &id); int32_t SetTaskOsData(void *data); int32_t SetSurfaceDetails(CM_HAL_SURFACE_ENTRY_INFO_ARRAYS surfaceInfo); int32_t Acquire(void); int32_t SafeRelease(void); int32_t SetKernelNames(CmTaskRT *task, CmThreadSpaceRT *threadSpace, CmThreadGroupSpace *threadGroupSpace); int32_t SetEnqueueTime(LARGE_INTEGER time); int32_t SetCompleteTime(LARGE_INTEGER time); int32_t GetSubmitTime(LARGE_INTEGER *time); int32_t GetHWStartTime(LARGE_INTEGER *time); int32_t GetHWEndTime(LARGE_INTEGER *time); int32_t GetCompleteTime(LARGE_INTEGER *time); uint32_t GetKernelCount(); int32_t GetEnqueueTime(LARGE_INTEGER *time); int32_t SetCallBack(EventCallBackFunction function, void *userData); int32_t GetStatusNoFlush(CM_STATUS &status); int32_t ModifyStatus(CM_STATUS status, uint64_t elapsedTime); int32_t GetQueue(CmQueueRT *&queue); int32_t Query(); CM_STATUS GetStatusWithoutFlush(); #if CM_LOG_ON std::string Log(const char *callerFuncName); CM_HAL_STATE* GetHalState(); #endif // #if CM_LOG_ON protected: CmEventRT(uint32_t index, CmQueueRT *queue, CmTaskInternal *task, int32_t taskDriverId, CmDeviceRT *device, bool isVisible); ~CmEventRT(); int32_t Initialize(); void UnreferenceIfNeeded(void *pdata); uint32_t m_index; int32_t m_taskDriverId; void *m_osData; CM_STATUS m_status; uint64_t m_time; uint64_t m_ticks; uint64_t m_hwStartTimeStampInTicks; uint64_t m_hwEndTimeStampInTicks; LARGE_INTEGER m_globalSubmitTimeCpu; // The CM task submission time in CPU LARGE_INTEGER m_submitTimeGpu; // The CM task submission time in GPU LARGE_INTEGER m_hwStartTimeStamp; // The task start execution time in GPU LARGE_INTEGER m_hwEndTimeStamp; // The task end execution time in GPU LARGE_INTEGER m_completeTime; // The task complete time in CPU LARGE_INTEGER m_enqueueTime; // The time when the task is pushed into enqueued // queue char **m_kernelNames; uint32_t *m_threadSpace; uint32_t m_kernelCount; CmDeviceRT* m_device; CmQueueRT *m_queue; int32_t m_refCount; bool m_isVisible; // if the event is Visible to user or not CM_HAL_SURFACE_ENTRY_INFO_ARRAYS m_surEntryInfoArrays; CmTaskInternal *m_task; CSync m_criticalSectionQuery; //Vtune call back EventCallBackFunction m_callbackFunction; //CallBack Function void *m_callbackUserData; //Pdata for Callback private: bool m_osSignalTriggered; CmEventRT(const CmEventRT& other); CmEventRT& operator=(const CmEventRT& other); }; } #endif // MEDIADRIVER_AGNOSTIC_COMMON_CM_CMEVENTRT_H_