Skip to content

Commit 4638cd1

Browse files
mateuszpnmateuszpn
committed
update mako files
1 parent b32de12 commit 4638cd1

7 files changed

Lines changed: 162 additions & 40 deletions

File tree

‎scripts/templates/validation/entry_points.h.mako‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,11 @@ ${line} \
3838
%endfor
3939
, ze_result_t result) {return ZE_RESULT_SUCCESS;}
4040
%endfor
41+
%if n == 'ze':
42+
// Experimental Intel extension for counter-based events
43+
virtual ze_result_t zexCounterBasedEventCreate2Prologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* desc, ze_event_handle_t* phEvent ) {return ZE_RESULT_SUCCESS;}
44+
virtual ze_result_t zexCounterBasedEventCreate2Epilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* desc, ze_event_handle_t* phEvent , ze_result_t result) {return ZE_RESULT_SUCCESS;}
45+
%endif
4146
virtual ~${N}ValidationEntryPoints() {}
4247
};
4348
}

‎scripts/templates/validation/handle_lifetime.cpp.mako‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -91,4 +91,21 @@ namespace validation_layer
9191
}
9292
%endif
9393
%endfor
94+
%if n == 'ze':
95+
ze_result_t ZEHandleLifetimeValidation::zexCounterBasedEventCreate2Prologue(
96+
ze_context_handle_t hContext, ///< [in] handle of the context object
97+
ze_device_handle_t hDevice, ///< [in] handle of the device
98+
const void *desc, ///< [in] pointer to counter-based event descriptor
99+
ze_event_handle_t *phEvent ///< [out] pointer to handle of event object created
100+
)
101+
{
102+
if (!context.handleLifetime->isHandleValid(hContext)) {
103+
return ZE_RESULT_ERROR_INVALID_NULL_HANDLE;
104+
}
105+
if (!context.handleLifetime->isHandleValid(hDevice)) {
106+
return ZE_RESULT_ERROR_INVALID_NULL_HANDLE;
107+
}
108+
return ZE_RESULT_SUCCESS;
109+
}
110+
%endif
94111
}

‎scripts/templates/validation/handle_lifetime.h.mako‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,10 @@ ${line} \
3838
%endfor
3939
) override;
4040
%endfor
41+
%if n == 'ze':
42+
// Experimental function for Intel counter-based events
43+
ze_result_t zexCounterBasedEventCreate2Prologue(ze_context_handle_t hContext, ze_device_handle_t hDevice, const void *desc, ze_event_handle_t *phEvent) override;
44+
%endif
4145
};
4246

4347
}

‎scripts/templates/validation/valddi.cpp.mako‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,17 @@ from templates import helper as th
2222

2323
namespace validation_layer
2424
{
25+
%if n == 'ze':
26+
// Forward declaration for Intel experimental extension
27+
// This is needed because zeDriverGetExtensionFunctionAddress needs to reference zexCounterBasedEventCreate2
28+
__zedlllocal ze_result_t ZE_APICALL zexCounterBasedEventCreate2(
29+
ze_context_handle_t hContext,
30+
ze_device_handle_t hDevice,
31+
const void *desc,
32+
ze_event_handle_t *phEvent
33+
);
34+
35+
%endif
2536
static ze_result_t logAndPropagateResult(const char* fname, ze_result_t result) {
2637
if (result != ${X}_RESULT_SUCCESS) {
2738
context.logger->log_trace("Error (" + loader::to_string(result) + ") in " + std::string(fname));
@@ -78,6 +89,17 @@ ${line} \
7889
}
7990

8091
auto driver_result = ${th.make_pfn_name(n, tags, obj)}( ${", ".join(th.make_param_lines(n, tags, obj, format=["name"]))} );
92+
%if 'ppFunctionAddress' in [p.get('name', '') for p in obj.get('params', [])] and n == 'ze':
93+
94+
// For Intel experimental extensions, we need to return our validation layer function
95+
// instead of the raw driver function so that validation/leak tracking works
96+
if (driver_result == ZE_RESULT_SUCCESS && ppFunctionAddress && name) {
97+
if (strcmp(name, "zexCounterBasedEventCreate2") == 0) {
98+
// Return our validation layer intercept function instead of the raw driver function
99+
*ppFunctionAddress = (void*)zexCounterBasedEventCreate2;
100+
}
101+
}
102+
%endif
81103

82104
for (size_t i = 0; i < numValHandlers; i++) {
83105
auto result = context.validationHandlers[i]->${n}Validation->${th.make_func_name(n, tags, obj)}Epilogue( \
@@ -127,6 +149,89 @@ ${line} \
127149
%endif
128150

129151
%endfor
152+
%if n == 'ze':
153+
///////////////////////////////////////////////////////////////////////////////
154+
/// @brief Intercept function for zexCounterBasedEventCreate2
155+
__zedlllocal ze_result_t ZE_APICALL zexCounterBasedEventCreate2(
156+
ze_context_handle_t hContext, ///< [in] handle of the context object
157+
ze_device_handle_t hDevice, ///< [in] handle of the device
158+
const void* desc, ///< [in] pointer to counter-based event descriptor
159+
ze_event_handle_t* phEvent ///< [out] pointer to handle of event object created
160+
)
161+
{
162+
context.logger->log_trace("zexCounterBasedEventCreate2(hContext, hDevice, desc, phEvent)");
163+
164+
// Note: This is an experimental function that may not have a DDI table entry.
165+
// For now, we'll return unsupported feature as this function should be
166+
// accessed through zeDriverGetExtensionFunctionAddress mechanism, but we
167+
// still want to track it in the validation layers for leak checking purposes.
168+
169+
auto numValHandlers = context.validationHandlers.size();
170+
for (size_t i = 0; i < numValHandlers; i++) {
171+
auto result = context.validationHandlers[i]->zeValidation->zexCounterBasedEventCreate2Prologue( hContext, hDevice, desc, phEvent );
172+
if(result!=ZE_RESULT_SUCCESS) return logAndPropagateResult("zexCounterBasedEventCreate2", result);
173+
}
174+
175+
if(context.enableThreadingValidation){
176+
//Unimplemented
177+
}
178+
179+
if(context.enableHandleLifetime){
180+
auto result = context.handleLifetime->zeHandleLifetime.zexCounterBasedEventCreate2Prologue( hContext, hDevice, desc, phEvent );
181+
if(result!=ZE_RESULT_SUCCESS) return logAndPropagateResult("zexCounterBasedEventCreate2", result);
182+
}
183+
184+
// This is an experimental function that must be accessed through the extension mechanism
185+
// We need to get the function pointer through zeDriverGetExtensionFunctionAddress
186+
ze_result_t driver_result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
187+
188+
// Get the real Intel experimental function through the extension mechanism
189+
auto pfnGetExtensionFunctionAddress = context.zeDdiTable.Driver.pfnGetExtensionFunctionAddress;
190+
191+
if (pfnGetExtensionFunctionAddress) {
192+
// Get the driver handle - use the first available driver
193+
ze_driver_handle_t hDriver = nullptr;
194+
195+
if (context.zeDdiTable.Driver.pfnGet) {
196+
uint32_t driverCount = 1;
197+
ze_driver_handle_t drivers[1] = {nullptr};
198+
auto result = context.zeDdiTable.Driver.pfnGet(&driverCount, drivers);
199+
if (result == ZE_RESULT_SUCCESS && driverCount > 0) {
200+
hDriver = drivers[0];
201+
}
202+
}
203+
204+
if (hDriver) {
205+
// Get the real Intel experimental function
206+
typedef ze_result_t (*zexCounterBasedEventCreate2_t)(ze_context_handle_t, ze_device_handle_t, const void*, ze_event_handle_t*);
207+
zexCounterBasedEventCreate2_t pfnRealFunction = nullptr;
208+
209+
auto ext_result = pfnGetExtensionFunctionAddress(hDriver, "zexCounterBasedEventCreate2", (void**)&pfnRealFunction);
210+
211+
if (ext_result == ZE_RESULT_SUCCESS && pfnRealFunction) {
212+
// Call the real Intel experimental function
213+
driver_result = pfnRealFunction(hContext, hDevice, desc, phEvent);
214+
} else {
215+
// Extension not available in this driver
216+
driver_result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
217+
}
218+
}
219+
}
220+
221+
for (size_t i = 0; i < numValHandlers; i++) {
222+
auto result = context.validationHandlers[i]->zeValidation->zexCounterBasedEventCreate2Epilogue( hContext, hDevice, desc, phEvent, driver_result);
223+
if(result!=ZE_RESULT_SUCCESS) return logAndPropagateResult("zexCounterBasedEventCreate2", result);
224+
}
225+
226+
if(driver_result == ZE_RESULT_SUCCESS && context.enableHandleLifetime){
227+
if (phEvent){
228+
context.handleLifetime->addHandle( *phEvent );
229+
// Note: counter-based events may not have a traditional event pool dependency
230+
}
231+
}
232+
return logAndPropagateResult("zexCounterBasedEventCreate2", driver_result);
233+
}
234+
%endif
130235
} // namespace validation_layer
131236

132237
#if defined(__cplusplus)

‎source/layers/validation/common/ze_entry_points.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -423,9 +423,9 @@ class ZEValidationEntryPoints {
423423
virtual ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpEpilogue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) {return ZE_RESULT_SUCCESS;}
424424
virtual ze_result_t zeCommandListUpdateMutableCommandKernelsExpPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) {return ZE_RESULT_SUCCESS;}
425425
virtual ze_result_t zeCommandListUpdateMutableCommandKernelsExpEpilogue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels , ze_result_t result) {return ZE_RESULT_SUCCESS;}
426-
// Experimental Intel extension for counter-based events
426+
// Experimental Intel extension for counter-based events
427427
virtual ze_result_t zexCounterBasedEventCreate2Prologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* desc, ze_event_handle_t* phEvent ) {return ZE_RESULT_SUCCESS;}
428428
virtual ze_result_t zexCounterBasedEventCreate2Epilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* desc, ze_event_handle_t* phEvent , ze_result_t result) {return ZE_RESULT_SUCCESS;}
429-
virtual ~ZEValidationEntryPoints() {}
429+
virtual ~ZEValidationEntryPoints() {}
430430
};
431431
}

‎source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3495,10 +3495,10 @@ namespace validation_layer
34953495
return ZE_RESULT_SUCCESS;
34963496
}
34973497
ze_result_t ZEHandleLifetimeValidation::zexCounterBasedEventCreate2Prologue(
3498-
ze_context_handle_t hContext, ///< [in] handle of the context object
3499-
ze_device_handle_t hDevice, ///< [in] handle of the device
3500-
const void *desc, ///< [in] pointer to counter-based event descriptor
3501-
ze_event_handle_t *phEvent ///< [out] pointer to handle of event object created
3498+
ze_context_handle_t hContext, ///< [in] handle of the context object
3499+
ze_device_handle_t hDevice, ///< [in] handle of the device
3500+
const void *desc, ///< [in] pointer to counter-based event descriptor
3501+
ze_event_handle_t *phEvent ///< [out] pointer to handle of event object created
35023502
)
35033503
{
35043504
if (!context.handleLifetime->isHandleValid(hContext)) {

‎source/layers/validation/ze_valddi.cpp‎

Lines changed: 25 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -9429,16 +9429,17 @@ namespace validation_layer
94299429

94309430
return logAndPropagateResult("zeCommandListUpdateMutableCommandKernelsExp", driver_result);
94319431
}
9432+
94329433
///////////////////////////////////////////////////////////////////////////////
94339434
/// @brief Intercept function for zexCounterBasedEventCreate2
94349435
__zedlllocal ze_result_t ZE_APICALL zexCounterBasedEventCreate2(
94359436
ze_context_handle_t hContext, ///< [in] handle of the context object
94369437
ze_device_handle_t hDevice, ///< [in] handle of the device
9437-
const void *desc, ///< [in] pointer to counter-based event descriptor
9438-
ze_event_handle_t *phEvent ///< [out] pointer to handle of event object created
9439-
) {
9440-
context.logger->log_trace(
9441-
"zexCounterBasedEventCreate2(hContext, hDevice, desc, phEvent)");
9438+
const void* desc, ///< [in] pointer to counter-based event descriptor
9439+
ze_event_handle_t* phEvent ///< [out] pointer to handle of event object created
9440+
)
9441+
{
9442+
context.logger->log_trace("zexCounterBasedEventCreate2(hContext, hDevice, desc, phEvent)");
94429443

94439444
// Note: This is an experimental function that may not have a DDI table entry.
94449445
// For now, we'll return unsupported feature as this function should be
@@ -9447,36 +9448,30 @@ namespace validation_layer
94479448

94489449
auto numValHandlers = context.validationHandlers.size();
94499450
for (size_t i = 0; i < numValHandlers; i++) {
9450-
auto result = context.validationHandlers[i]
9451-
->zeValidation->zexCounterBasedEventCreate2Prologue(
9452-
hContext, hDevice, desc, phEvent);
9453-
if (result != ZE_RESULT_SUCCESS)
9454-
return logAndPropagateResult("zexCounterBasedEventCreate2", result);
9451+
auto result = context.validationHandlers[i]->zeValidation->zexCounterBasedEventCreate2Prologue( hContext, hDevice, desc, phEvent );
9452+
if(result!=ZE_RESULT_SUCCESS) return logAndPropagateResult("zexCounterBasedEventCreate2", result);
94559453
}
94569454

9457-
if (context.enableThreadingValidation) {
9458-
// Unimplemented
9455+
if(context.enableThreadingValidation){
9456+
//Unimplemented
94599457
}
94609458

9461-
if (context.enableHandleLifetime) {
9462-
auto result = context.handleLifetime->zeHandleLifetime
9463-
.zexCounterBasedEventCreate2Prologue(hContext, hDevice,
9464-
desc, phEvent);
9465-
if (result != ZE_RESULT_SUCCESS)
9466-
return logAndPropagateResult("zexCounterBasedEventCreate2", result);
9459+
if(context.enableHandleLifetime){
9460+
auto result = context.handleLifetime->zeHandleLifetime.zexCounterBasedEventCreate2Prologue( hContext, hDevice, desc, phEvent );
9461+
if(result!=ZE_RESULT_SUCCESS) return logAndPropagateResult("zexCounterBasedEventCreate2", result);
94679462
}
94689463

94699464
// This is an experimental function that must be accessed through the extension mechanism
94709465
// We need to get the function pointer through zeDriverGetExtensionFunctionAddress
94719466
ze_result_t driver_result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
9472-
9467+
94739468
// Get the real Intel experimental function through the extension mechanism
94749469
auto pfnGetExtensionFunctionAddress = context.zeDdiTable.Driver.pfnGetExtensionFunctionAddress;
9475-
9470+
94769471
if (pfnGetExtensionFunctionAddress) {
94779472
// Get the driver handle - use the first available driver
94789473
ze_driver_handle_t hDriver = nullptr;
9479-
9474+
94809475
if (context.zeDdiTable.Driver.pfnGet) {
94819476
uint32_t driverCount = 1;
94829477
ze_driver_handle_t drivers[1] = {nullptr};
@@ -9485,14 +9480,14 @@ namespace validation_layer
94859480
hDriver = drivers[0];
94869481
}
94879482
}
9488-
9483+
94899484
if (hDriver) {
94909485
// Get the real Intel experimental function
94919486
typedef ze_result_t (*zexCounterBasedEventCreate2_t)(ze_context_handle_t, ze_device_handle_t, const void*, ze_event_handle_t*);
94929487
zexCounterBasedEventCreate2_t pfnRealFunction = nullptr;
9493-
9488+
94949489
auto ext_result = pfnGetExtensionFunctionAddress(hDriver, "zexCounterBasedEventCreate2", (void**)&pfnRealFunction);
9495-
9490+
94969491
if (ext_result == ZE_RESULT_SUCCESS && pfnRealFunction) {
94979492
// Call the real Intel experimental function
94989493
driver_result = pfnRealFunction(hContext, hDevice, desc, phEvent);
@@ -9504,18 +9499,14 @@ namespace validation_layer
95049499
}
95059500

95069501
for (size_t i = 0; i < numValHandlers; i++) {
9507-
auto result = context.validationHandlers[i]
9508-
->zeValidation->zexCounterBasedEventCreate2Epilogue(
9509-
hContext, hDevice, desc, phEvent, driver_result);
9510-
if (result != ZE_RESULT_SUCCESS)
9511-
return logAndPropagateResult("zexCounterBasedEventCreate2", result);
9502+
auto result = context.validationHandlers[i]->zeValidation->zexCounterBasedEventCreate2Epilogue( hContext, hDevice, desc, phEvent, driver_result);
9503+
if(result!=ZE_RESULT_SUCCESS) return logAndPropagateResult("zexCounterBasedEventCreate2", result);
95129504
}
95139505

9514-
if (driver_result == ZE_RESULT_SUCCESS && context.enableHandleLifetime) {
9515-
if (phEvent) {
9516-
context.handleLifetime->addHandle(*phEvent);
9517-
// Note: counter-based events may not have a traditional event pool
9518-
// dependency
9506+
if(driver_result == ZE_RESULT_SUCCESS && context.enableHandleLifetime){
9507+
if (phEvent){
9508+
context.handleLifetime->addHandle( *phEvent );
9509+
// Note: counter-based events may not have a traditional event pool dependency
95199510
}
95209511
}
95219512
return logAndPropagateResult("zexCounterBasedEventCreate2", driver_result);

0 commit comments

Comments
 (0)