1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
/*
* 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"
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 GetQueue(CmQueueRT *&queue);
protected:
CmEventRT(uint32_t index,
CmQueueRT *queue,
CmTaskInternal *task,
int32_t taskDriverId,
CmDeviceRT *device,
bool isVisible);
~CmEventRT();
int32_t Initialize();
int32_t Query();
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;
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:
CmEventRT(const CmEventRT& other);
CmEventRT& operator=(const CmEventRT& other);
};
}
#endif // MEDIADRIVER_AGNOSTIC_COMMON_CM_CMEVENTRT_H_
|
