Skip to content

Commit b3813d9

Browse files
Jaime ArteagaCompute-Runtime-Automation
Jaime Arteaga
authored and
Compute-Runtime-Automation
committed
Cleanup mock_device.h
Change-Id: I05cd308f1fe364ad3592d8aff897f8cbc6da10cd Signed-off: Jaime Arteaga <[email protected]>
1 parent 32117f1 commit b3813d9

File tree

1 file changed

+236
-83
lines changed

1 file changed

+236
-83
lines changed

‎level_zero/core/test/unit_tests/mocks/mock_device.h‎

Lines changed: 236 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -18,11 +18,6 @@
1818
#include "level_zero/core/test/unit_tests/white_box.h"
1919
#include "level_zero/tools/source/metrics/metric.h"
2020

21-
#if defined(__clang__)
22-
#pragma clang diagnostic push
23-
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
24-
#endif
25-
2621
namespace L0 {
2722
namespace ult {
2823

@@ -36,86 +31,248 @@ struct Mock<Device> : public Device {
3631
Mock();
3732
~Mock() override;
3833

39-
MOCK_METHOD0(getRootDeviceIndex, uint32_t());
40-
MOCK_METHOD2(canAccessPeer, ze_result_t(ze_device_handle_t hPeerDevice, ze_bool_t *value));
41-
MOCK_METHOD2(createCommandList, ze_result_t(const ze_command_list_desc_t *desc,
42-
ze_command_list_handle_t *commandList));
43-
44-
MOCK_METHOD2(createCommandListImmediate, ze_result_t(const ze_command_queue_desc_t *desc,
45-
ze_command_list_handle_t *commandList));
46-
47-
MOCK_METHOD2(createCommandQueue, ze_result_t(const ze_command_queue_desc_t *desc,
48-
ze_command_queue_handle_t *commandQueue));
49-
50-
MOCK_METHOD2(createEventPool,
51-
ze_result_t(const ze_event_pool_desc_t *desc, ze_event_pool_handle_t *eventPool));
52-
MOCK_METHOD2(createImage, ze_result_t(const ze_image_desc_t *desc, ze_image_handle_t *phImage));
53-
54-
MOCK_METHOD3(createModule, ze_result_t(const ze_module_desc_t *desc, ze_module_handle_t *module,
55-
ze_module_build_log_handle_t *buildLog));
56-
MOCK_METHOD2(createSampler,
57-
ze_result_t(const ze_sampler_desc_t *pDesc, ze_sampler_handle_t *phSampler));
58-
MOCK_METHOD1(evictImage, ze_result_t(ze_image_handle_t hImage));
59-
MOCK_METHOD2(evictMemory, ze_result_t(void *ptr, size_t size));
60-
MOCK_METHOD1(getComputeProperties,
61-
ze_result_t(ze_device_compute_properties_t *pComputeProperties));
62-
MOCK_METHOD2(getP2PProperties, ze_result_t(ze_device_handle_t hPeerDevice,
63-
ze_device_p2p_properties_t *pP2PProperties));
64-
MOCK_METHOD1(getKernelProperties, ze_result_t(ze_device_kernel_properties_t *pKernelProperties));
65-
MOCK_METHOD2(getMemoryProperties, ze_result_t(uint32_t *pCount, ze_device_memory_properties_t *pMemProperties));
66-
MOCK_METHOD1(getMemoryAccessProperties, ze_result_t(ze_device_memory_access_properties_t *pMemAccessProperties));
67-
MOCK_METHOD1(getProperties, ze_result_t(ze_device_properties_t *pDeviceProperties));
68-
MOCK_METHOD2(getSubDevice, ze_result_t(uint32_t ordinal, ze_device_handle_t *phSubDevice));
69-
MOCK_METHOD2(getSubDevices, ze_result_t(uint32_t *pCount, ze_device_handle_t *phSubdevices));
70-
MOCK_METHOD1(makeImageResident, ze_result_t(ze_image_handle_t hImage));
71-
MOCK_METHOD2(makeMemoryResident, ze_result_t(void *ptr, size_t size));
72-
MOCK_METHOD1(setIntermediateCacheConfig, ze_result_t(ze_cache_config_t CacheConfig));
73-
MOCK_METHOD1(setLastLevelCacheConfig, ze_result_t(ze_cache_config_t CacheConfig));
74-
MOCK_METHOD1(getCacheProperties, ze_result_t(ze_device_cache_properties_t *pCacheProperties));
75-
76-
MOCK_METHOD2(imageGetProperties,
77-
ze_result_t(const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties));
34+
MOCK_METHOD(uint32_t,
35+
getRootDeviceIndex,
36+
(),
37+
(override));
38+
MOCK_METHOD(ze_result_t,
39+
canAccessPeer,
40+
(ze_device_handle_t hPeerDevice,
41+
ze_bool_t *value),
42+
(override));
43+
MOCK_METHOD(ze_result_t,
44+
createCommandList,
45+
(const ze_command_list_desc_t *desc,
46+
ze_command_list_handle_t *commandList),
47+
(override));
48+
49+
MOCK_METHOD(ze_result_t,
50+
createCommandListImmediate,
51+
(const ze_command_queue_desc_t *desc,
52+
ze_command_list_handle_t *commandList),
53+
(override));
54+
55+
MOCK_METHOD(ze_result_t,
56+
createCommandQueue,
57+
(const ze_command_queue_desc_t *desc,
58+
ze_command_queue_handle_t *commandQueue),
59+
(override));
60+
MOCK_METHOD(ze_result_t,
61+
createImage,
62+
(const ze_image_desc_t *desc,
63+
ze_image_handle_t *phImage),
64+
(override));
65+
66+
MOCK_METHOD(ze_result_t,
67+
createModule,
68+
(const ze_module_desc_t *desc,
69+
ze_module_handle_t *module,
70+
ze_module_build_log_handle_t *buildLog),
71+
(override));
72+
MOCK_METHOD(ze_result_t,
73+
createSampler,
74+
(const ze_sampler_desc_t *pDesc,
75+
ze_sampler_handle_t *phSampler),
76+
(override));
77+
MOCK_METHOD(ze_result_t,
78+
evictImage,
79+
(ze_image_handle_t hImage),
80+
(override));
81+
MOCK_METHOD(ze_result_t,
82+
evictMemory,
83+
(void *ptr,
84+
size_t size),
85+
(override));
86+
MOCK_METHOD(ze_result_t,
87+
getComputeProperties,
88+
(ze_device_compute_properties_t * pComputeProperties),
89+
(override));
90+
MOCK_METHOD(ze_result_t,
91+
getP2PProperties,
92+
(ze_device_handle_t hPeerDevice,
93+
ze_device_p2p_properties_t *pP2PProperties),
94+
(override));
95+
MOCK_METHOD(ze_result_t,
96+
getKernelProperties,
97+
(ze_device_kernel_properties_t * pKernelProperties),
98+
(override));
99+
MOCK_METHOD(ze_result_t,
100+
getMemoryProperties,
101+
(uint32_t * pCount,
102+
ze_device_memory_properties_t *pMemProperties),
103+
(override));
104+
MOCK_METHOD(ze_result_t,
105+
getMemoryAccessProperties,
106+
(ze_device_memory_access_properties_t * pMemAccessProperties),
107+
(override));
108+
MOCK_METHOD(ze_result_t,
109+
getProperties,
110+
(ze_device_properties_t * pDeviceProperties),
111+
(override));
112+
MOCK_METHOD(ze_result_t,
113+
getSubDevices,
114+
(uint32_t * pCount,
115+
ze_device_handle_t *phSubdevices),
116+
(override));
117+
MOCK_METHOD(ze_result_t,
118+
makeImageResident,
119+
(ze_image_handle_t hImage),
120+
(override));
121+
MOCK_METHOD(ze_result_t,
122+
makeMemoryResident,
123+
(void *ptr,
124+
size_t size),
125+
(override));
126+
MOCK_METHOD(ze_result_t,
127+
setIntermediateCacheConfig,
128+
(ze_cache_config_t CacheConfig),
129+
(override));
130+
MOCK_METHOD(ze_result_t,
131+
setLastLevelCacheConfig,
132+
(ze_cache_config_t CacheConfig),
133+
(override));
134+
MOCK_METHOD(ze_result_t,
135+
getCacheProperties,
136+
137+
(ze_device_cache_properties_t * pCacheProperties),
138+
(override));
139+
140+
MOCK_METHOD(ze_result_t,
141+
imageGetProperties,
142+
(const ze_image_desc_t *desc,
143+
ze_image_properties_t *pImageProperties),
144+
(override));
78145
MOCK_METHOD(ze_result_t,
79146
getCommandQueueGroupProperties,
80147
(uint32_t * pCount,
81148
ze_command_queue_group_properties_t *pCommandQueueGroupProperties),
82149
(override));
83-
MOCK_METHOD1(getDeviceImageProperties,
84-
ze_result_t(ze_device_image_properties_t *pDeviceImageProperties));
85-
MOCK_METHOD0(systemBarrier, ze_result_t());
86-
MOCK_METHOD3(registerCLMemory, ze_result_t(cl_context context, cl_mem mem, void **ptr));
87-
MOCK_METHOD3(registerCLProgram,
88-
ze_result_t(cl_context context, cl_program program, ze_module_handle_t *phModule));
89-
MOCK_METHOD3(registerCLCommandQueue,
90-
ze_result_t(cl_context context, cl_command_queue commandQueue,
91-
ze_command_queue_handle_t *phCommandQueue));
150+
MOCK_METHOD(ze_result_t,
151+
getDeviceImageProperties,
152+
(ze_device_image_properties_t * pDeviceImageProperties),
153+
(override));
154+
MOCK_METHOD(ze_result_t,
155+
systemBarrier,
156+
157+
(),
158+
(override));
159+
MOCK_METHOD(ze_result_t,
160+
registerCLMemory,
161+
162+
(cl_context context,
163+
cl_mem mem,
164+
void **ptr),
165+
(override));
166+
MOCK_METHOD(ze_result_t,
167+
registerCLProgram,
168+
169+
(cl_context context,
170+
cl_program program,
171+
ze_module_handle_t *phModule),
172+
(override));
173+
MOCK_METHOD(ze_result_t,
174+
registerCLCommandQueue,
175+
176+
(cl_context context,
177+
cl_command_queue commandQueue,
178+
ze_command_queue_handle_t *phCommandQueue),
179+
(override));
92180
// Runtime internal methods
93-
MOCK_METHOD0(getMemoryManager, NEO::MemoryManager *());
94-
MOCK_METHOD0(getExecEnvironment, void *());
95-
MOCK_METHOD0(getHwHelper, NEO::HwHelper &());
96-
MOCK_CONST_METHOD0(isMultiDeviceCapable, bool());
97-
MOCK_METHOD0(getBuiltinFunctionsLib, BuiltinFunctionsLib *());
98-
MOCK_METHOD2(getMOCS, uint32_t(bool l3enabled, bool l1enabled));
99-
MOCK_CONST_METHOD0(getMaxNumHwThreads, uint32_t());
100-
101-
MOCK_METHOD2(activateMetricGroups,
102-
ze_result_t(uint32_t count, zet_metric_group_handle_t *phMetricGroups));
103-
MOCK_METHOD0(getOsInterface, NEO::OSInterface &());
104-
MOCK_CONST_METHOD0(getPlatformInfo, uint32_t());
105-
MOCK_METHOD0(getMetricContext, MetricContext &());
106-
MOCK_CONST_METHOD0(getHwInfo, const NEO::HardwareInfo &());
107-
MOCK_METHOD0(getDriverHandle, L0::DriverHandle *());
108-
MOCK_METHOD1(setDriverHandle, void(L0::DriverHandle *));
109-
110-
MOCK_CONST_METHOD0(getDevicePreemptionMode, NEO::PreemptionMode());
111-
MOCK_CONST_METHOD0(getDeviceInfo, const NEO::DeviceInfo &());
112-
MOCK_METHOD0(getNEODevice, NEO::Device *());
113-
MOCK_METHOD0(activateMetricGroups, void());
114-
MOCK_CONST_METHOD0(getDebugSurface, NEO::GraphicsAllocation *());
115-
MOCK_METHOD3(allocateManagedMemoryFromHostPtr, NEO::GraphicsAllocation *(void *buffer, size_t size, struct L0::CommandList *commandList));
116-
MOCK_METHOD2(allocateMemoryFromHostPtr, NEO::GraphicsAllocation *(const void *buffer, size_t size));
117-
MOCK_METHOD1(setSysmanHandle, void(SysmanDevice *));
118-
MOCK_METHOD0(getSysmanHandle, SysmanDevice *());
181+
MOCK_METHOD(void *,
182+
getExecEnvironment,
183+
(),
184+
(override));
185+
MOCK_METHOD(NEO::HwHelper &,
186+
getHwHelper,
187+
(),
188+
(override));
189+
MOCK_METHOD(bool,
190+
isMultiDeviceCapable,
191+
(),
192+
(const, override));
193+
MOCK_METHOD(BuiltinFunctionsLib *,
194+
getBuiltinFunctionsLib,
195+
(),
196+
(override));
197+
MOCK_METHOD(uint32_t,
198+
getMOCS,
199+
(bool l3enabled,
200+
bool l1enabled),
201+
(override));
202+
MOCK_METHOD(uint32_t,
203+
getMaxNumHwThreads,
204+
(),
205+
(const, override));
206+
207+
MOCK_METHOD(ze_result_t,
208+
activateMetricGroups,
209+
(uint32_t count,
210+
zet_metric_group_handle_t *phMetricGroups),
211+
(override));
212+
MOCK_METHOD(NEO::OSInterface &,
213+
getOsInterface,
214+
(),
215+
(override));
216+
MOCK_METHOD(uint32_t,
217+
getPlatformInfo,
218+
(),
219+
(const, override));
220+
MOCK_METHOD(MetricContext &,
221+
getMetricContext,
222+
(),
223+
(override));
224+
MOCK_METHOD(const NEO::HardwareInfo &,
225+
getHwInfo,
226+
(),
227+
(const, override));
228+
MOCK_METHOD(L0::DriverHandle *,
229+
getDriverHandle,
230+
(),
231+
(override));
232+
MOCK_METHOD(void,
233+
setDriverHandle,
234+
(L0::DriverHandle *),
235+
(override));
236+
237+
MOCK_METHOD(NEO::PreemptionMode,
238+
getDevicePreemptionMode,
239+
(),
240+
(const, override));
241+
MOCK_METHOD(const NEO::DeviceInfo &,
242+
getDeviceInfo,
243+
(),
244+
(const, override));
245+
MOCK_METHOD(NEO::Device *,
246+
getNEODevice,
247+
(),
248+
(override));
249+
MOCK_METHOD(void,
250+
activateMetricGroups,
251+
(),
252+
(override));
253+
MOCK_METHOD(NEO::GraphicsAllocation *,
254+
getDebugSurface,
255+
(),
256+
(const, override));
257+
MOCK_METHOD(NEO::GraphicsAllocation *,
258+
allocateManagedMemoryFromHostPtr,
259+
(void *buffer,
260+
size_t size,
261+
struct L0::CommandList *commandList),
262+
(override));
263+
MOCK_METHOD(NEO::GraphicsAllocation *,
264+
allocateMemoryFromHostPtr,
265+
(const void *buffer,
266+
size_t size),
267+
(override));
268+
MOCK_METHOD(void,
269+
setSysmanHandle,
270+
(SysmanDevice *),
271+
(override));
272+
MOCK_METHOD(SysmanDevice *,
273+
getSysmanHandle,
274+
(),
275+
(override));
119276
};
120277

121278
template <>
@@ -132,7 +289,3 @@ struct Mock<L0::DeviceImp> : public L0::DeviceImp {
132289

133290
} // namespace ult
134291
} // namespace L0
135-
136-
#if defined(__clang__)
137-
#pragma clang diagnostic pop
138-
#endif

0 commit comments

Comments
 (0)