update leak checker for experimental function

Signed-off-by: Mateusz P. Nowak <mateusz.p.nowak@intel.com>

Author: mateuszpn

source/layers/validation/checkers/basic_leak/zel_basic_leak_checker.cpp

@@ -51,7 +51,7 @@ namespace validation_layer
             {{"zeKernelCreate"}, {"zeKernelDestroy"}},
             {{"zeEventPoolCreate"}, {"zeEventPoolDestroy"}},
             {{"zeCommandListCreateImmediate", "zeCommandListCreate"}, {"zeCommandListDestroy"}},
-            {{"zeEventCreate"}, {"zeEventDestroy"}},
+            {{"zeEventCreate", "zexCounterBasedEventCreate2"}, {"zeEventDestroy"}},
             {{"zeFenceCreate"}, {"zeFenceDestroy"}},
             {{"zeImageCreate", "zeImageViewCreateExt"}, {"zeImageDestroy"}},
             {{"zeSamplerCreate"}, {"zeSamplerDestroy"}},
@@ -177,6 +177,13 @@ namespace validation_layer
         return result;
     }
 
+    ze_result_t basic_leakChecker::ZEbasic_leakChecker::zexCounterBasedEventCreate2Epilogue(ze_context_handle_t, ze_device_handle_t, const void *, ze_event_handle_t *, ze_result_t result) {
+        if (result == ZE_RESULT_SUCCESS) {
+            countFunctionCall("zexCounterBasedEventCreate2");
+        }
+        return result;
+    }
+
     ze_result_t basic_leakChecker::ZEbasic_leakChecker::zeFenceCreateEpilogue(ze_command_queue_handle_t, const ze_fence_desc_t *, ze_fence_handle_t*, ze_result_t result) {
         if (result == ZE_RESULT_SUCCESS) {
             countFunctionCall("zeFenceCreate");

source/layers/validation/checkers/basic_leak/zel_basic_leak_checker.h

@@ -80,6 +80,8 @@ namespace validation_layer
                 ze_result_t zeMemAllocSharedEpilogue(ze_context_handle_t, const ze_device_mem_alloc_desc_t *, const ze_host_mem_alloc_desc_t *, size_t, size_t, ze_device_handle_t, void **, ze_result_t result) override;
                 ze_result_t zeMemFreeEpilogue(ze_context_handle_t, void *, ze_result_t result) override;
                 ze_result_t zeMemFreeExtEpilogue(ze_context_handle_t, const ze_memory_free_ext_desc_t*, void *, ze_result_t result) override;
+                // Experimental function for Intel counter-based events
+                ze_result_t zexCounterBasedEventCreate2Epilogue(ze_context_handle_t, ze_device_handle_t, const void *, ze_event_handle_t *, ze_result_t result) override;
             private:
                 void countFunctionCall(const std::string &functionName);
                 std::unordered_map<std::string, std::atomic<int64_t>> counts;

source/layers/validation/common/ze_entry_points.h

@@ -423,6 +423,9 @@ class ZEValidationEntryPoints {
     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;}
     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;}
     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;}
-    virtual ~ZEValidationEntryPoints() {}
+     // Experimental Intel extension for counter-based events
+    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;}
+    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;}
+   virtual ~ZEValidationEntryPoints() {}
 };
 }

source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.cpp

@@ -3494,4 +3494,19 @@ namespace validation_layer
         }
         return ZE_RESULT_SUCCESS;
     }
+    ze_result_t ZEHandleLifetimeValidation::zexCounterBasedEventCreate2Prologue(
+        ze_context_handle_t hContext, ///< [in] handle of the context object
+        ze_device_handle_t hDevice,   ///< [in] handle of the device
+        const void *desc, ///< [in] pointer to counter-based event descriptor
+        ze_event_handle_t *phEvent ///< [out] pointer to handle of event object created
+        )
+    {
+        if (!context.handleLifetime->isHandleValid(hContext)) {
+            return ZE_RESULT_ERROR_INVALID_NULL_HANDLE;
+        }
+        if (!context.handleLifetime->isHandleValid(hDevice)) {
+            return ZE_RESULT_ERROR_INVALID_NULL_HANDLE;
+        }
+        return ZE_RESULT_SUCCESS;
+    }
 }

source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.h

@@ -219,6 +219,8 @@ namespace validation_layer
         ze_result_t zeCommandListUpdateMutableCommandSignalEventExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) override;
         ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override;
         ze_result_t zeCommandListUpdateMutableCommandKernelsExpPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) override;
+        // Experimental function for Intel counter-based events
+        ze_result_t zexCounterBasedEventCreate2Prologue(ze_context_handle_t hContext, ze_device_handle_t hDevice, const void *desc, ze_event_handle_t *phEvent) override;
     };
 
 }

source/layers/validation/ze_valddi.cpp

@@ -13,6 +13,15 @@
 
 namespace validation_layer
 {
+    // Forward declaration for Intel experimental extension
+    // This is needed because zeDriverGetExtensionFunctionAddress needs to reference zexCounterBasedEventCreate2
+    __zedlllocal ze_result_t ZE_APICALL zexCounterBasedEventCreate2(
+        ze_context_handle_t hContext,
+        ze_device_handle_t hDevice,
+        const void *desc,
+        ze_event_handle_t *phEvent
+    );
+
     static ze_result_t logAndPropagateResult(const char* fname, ze_result_t result) {
         if (result != ZE_RESULT_SUCCESS) {
             context.logger->log_trace("Error (" + loader::to_string(result) + ") in " + std::string(fname));
@@ -382,6 +391,15 @@ namespace validation_layer
 
         auto driver_result = pfnGetExtensionFunctionAddress( hDriver, name, ppFunctionAddress );
 
+        // For Intel experimental extensions, we need to return our validation layer function
+        // instead of the raw driver function so that validation/leak tracking works
+        if (driver_result == ZE_RESULT_SUCCESS && ppFunctionAddress && name) {
+            if (strcmp(name, "zexCounterBasedEventCreate2") == 0) {
+                // Return our validation layer intercept function instead of the raw driver function
+                *ppFunctionAddress = (void*)zexCounterBasedEventCreate2;
+            }
+        }
+
         for (size_t i = 0; i < numValHandlers; i++) {
             auto result = context.validationHandlers[i]->zeValidation->zeDriverGetExtensionFunctionAddressEpilogue( hDriver, name, ppFunctionAddress ,driver_result);
             if(result!=ZE_RESULT_SUCCESS) return logAndPropagateResult("zeDriverGetExtensionFunctionAddress", result);
@@ -9411,7 +9429,97 @@ namespace validation_layer
 
         return logAndPropagateResult("zeCommandListUpdateMutableCommandKernelsExp", driver_result);
     }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Intercept function for zexCounterBasedEventCreate2
+    __zedlllocal ze_result_t ZE_APICALL zexCounterBasedEventCreate2(
+        ze_context_handle_t hContext,                   ///< [in] handle of the context object
+        ze_device_handle_t hDevice,                     ///< [in] handle of the device
+        const void *desc,                               ///< [in] pointer to counter-based event descriptor
+        ze_event_handle_t *phEvent                      ///< [out] pointer to handle of event object created
+    ) {
+        context.logger->log_trace(
+            "zexCounterBasedEventCreate2(hContext, hDevice, desc, phEvent)");
 
+        // Note: This is an experimental function that may not have a DDI table entry.
+        // For now, we'll return unsupported feature as this function should be
+        // accessed through zeDriverGetExtensionFunctionAddress mechanism, but we
+        // still want to track it in the validation layers for leak checking purposes.
+
+        auto numValHandlers = context.validationHandlers.size();
+        for (size_t i = 0; i < numValHandlers; i++) {
+            auto result = context.validationHandlers[i]
+                            ->zeValidation->zexCounterBasedEventCreate2Prologue(
+                                hContext, hDevice, desc, phEvent);
+            if (result != ZE_RESULT_SUCCESS)
+            return logAndPropagateResult("zexCounterBasedEventCreate2", result);
+        }
+
+        if (context.enableThreadingValidation) {
+            // Unimplemented
+        }
+
+        if (context.enableHandleLifetime) {
+            auto result = context.handleLifetime->zeHandleLifetime
+                            .zexCounterBasedEventCreate2Prologue(hContext, hDevice,
+                                                                desc, phEvent);
+            if (result != ZE_RESULT_SUCCESS)
+            return logAndPropagateResult("zexCounterBasedEventCreate2", result);
+        }
+
+        // This is an experimental function that must be accessed through the extension mechanism
+        // We need to get the function pointer through zeDriverGetExtensionFunctionAddress
+        ze_result_t driver_result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+        
+        // Get the real Intel experimental function through the extension mechanism
+        auto pfnGetExtensionFunctionAddress = context.zeDdiTable.Driver.pfnGetExtensionFunctionAddress;
+        
+        if (pfnGetExtensionFunctionAddress) {
+            // Get the driver handle - use the first available driver
+            ze_driver_handle_t hDriver = nullptr;
+            
+            if (context.zeDdiTable.Driver.pfnGet) {
+                uint32_t driverCount = 1;
+                ze_driver_handle_t drivers[1] = {nullptr};
+                auto result = context.zeDdiTable.Driver.pfnGet(&driverCount, drivers);
+                if (result == ZE_RESULT_SUCCESS && driverCount > 0) {
+                    hDriver = drivers[0];
+                }
+            }
+            
+            if (hDriver) {
+                // Get the real Intel experimental function
+                typedef ze_result_t (*zexCounterBasedEventCreate2_t)(ze_context_handle_t, ze_device_handle_t, const void*, ze_event_handle_t*);
+                zexCounterBasedEventCreate2_t pfnRealFunction = nullptr;
+                
+                auto ext_result = pfnGetExtensionFunctionAddress(hDriver, "zexCounterBasedEventCreate2", (void**)&pfnRealFunction);
+                
+                if (ext_result == ZE_RESULT_SUCCESS && pfnRealFunction) {
+                    // Call the real Intel experimental function
+                    driver_result = pfnRealFunction(hContext, hDevice, desc, phEvent);
+                } else {
+                    // Extension not available in this driver
+                    driver_result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+                }
+            }
+        }
+
+        for (size_t i = 0; i < numValHandlers; i++) {
+            auto result = context.validationHandlers[i]
+                            ->zeValidation->zexCounterBasedEventCreate2Epilogue(
+                                hContext, hDevice, desc, phEvent, driver_result);
+            if (result != ZE_RESULT_SUCCESS)
+            return logAndPropagateResult("zexCounterBasedEventCreate2", result);
+        }
+
+        if (driver_result == ZE_RESULT_SUCCESS && context.enableHandleLifetime) {
+            if (phEvent) {
+            context.handleLifetime->addHandle(*phEvent);
+            // Note: counter-based events may not have a traditional event pool
+            // dependency
+            }
+        }
+        return logAndPropagateResult("zexCounterBasedEventCreate2", driver_result);
+    }
 } // namespace validation_layer
 
 #if defined(__cplusplus)