intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 06:24:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Set external semaphore version in L0

Browse Source 
Related-To: NEO-14295

Signed-off-by: Raiyan Latif <raiyan.latif@intel.com>
This commit is contained in:
Raiyan Latif
2025-03-08 19:30:50 +00:00
committed by Compute-Runtime-Automation
parent 570e05774d
commit 80168b194f
22 changed files with 222 additions and 438 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
level_zero/api/core/ze_cmdlist_api_entrypoints.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -106,6 +106,28 @@ ze_result_t zeCommandListImmediateAppendCommandListsExp(
return L0::CommandList::fromHandle(hCommandListImmediate)->appendCommandLists(numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents);
}
ze_result_t zeCommandListAppendSignalExternalSemaphoreExt(
ze_command_list_handle_t hCommandList,
uint32_t numSemaphores,
ze_external_semaphore_ext_handle_t *phSemaphores,
ze_external_semaphore_signal_params_ext_t *signalParams,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendSignalExternalSemaphores(numSemaphores, phSemaphores, signalParams, hSignalEvent, numWaitEvents, phWaitEvents);
}
ze_result_t zeCommandListAppendWaitExternalSemaphoreExt(
ze_command_list_handle_t hCommandList,
uint32_t numSemaphores,
ze_external_semaphore_ext_handle_t *phSemaphores,
ze_external_semaphore_wait_params_ext_t *waitParams,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendWaitExternalSemaphores(numSemaphores, phSemaphores, waitParams, hSignalEvent, numWaitEvents, phWaitEvents);
}
} // namespace L0
extern "C" {
@@ -220,4 +242,26 @@ ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListImmediateAppendCommandListsExp(
numWaitEvents,
phWaitEvents);
}
ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListAppendSignalExternalSemaphoreExt(
ze_command_list_handle_t hCommandList,
uint32_t numSemaphores,
ze_external_semaphore_ext_handle_t *phSemaphores,
ze_external_semaphore_signal_params_ext_t *signalParams,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendSignalExternalSemaphores(numSemaphores, phSemaphores, signalParams, hSignalEvent, numWaitEvents, phWaitEvents);
}
ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListAppendWaitExternalSemaphoreExt(
ze_command_list_handle_t hCommandList,
uint32_t numSemaphores,
ze_external_semaphore_ext_handle_t *phSemaphores,
ze_external_semaphore_wait_params_ext_t *waitParams,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCommandList)->appendWaitExternalSemaphores(numSemaphores, phSemaphores, waitParams, hSignalEvent, numWaitEvents, phWaitEvents);
}
}

25
level_zero/api/core/ze_device_api_entrypoints.h
View File

@@ -10,6 +10,7 @@
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/driver/driver.h"
#include "level_zero/core/source/driver/driver_handle.h"
#include "level_zero/core/source/semaphore/external_semaphore_imp.h"
#include <level_zero/ze_api.h>
#include <level_zero/ze_ddi.h>
@@ -138,6 +139,18 @@ ze_result_t zeDeviceGetRootDevice(
return L0::Device::fromHandle(hDevice)->getRootDevice(phRootDevice);
}
ze_result_t zeDeviceImportExternalSemaphoreExt(
ze_device_handle_t hDevice,
const ze_external_semaphore_ext_desc_t *desc,
ze_external_semaphore_ext_handle_t *phSemaphore) {
return L0::ExternalSemaphore::importExternalSemaphore(hDevice, desc, phSemaphore);
}
ze_result_t zeDeviceReleaseExternalSemaphoreExt(
ze_external_semaphore_ext_handle_t hSemaphore) {
return L0::ExternalSemaphoreImp::fromHandle(hSemaphore)->releaseExternalSemaphore();
}
} // namespace L0
extern "C" {
@@ -295,4 +308,16 @@ ze_result_t zeDevicePciGetPropertiesExt(
ze_pci_ext_properties_t *pPciProperties) {
return L0::zeDevicePciGetPropertiesExt(hDevice, pPciProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL zeDeviceImportExternalSemaphoreExt(
ze_device_handle_t hDevice,
const ze_external_semaphore_ext_desc_t *desc,
ze_external_semaphore_ext_handle_t *phSemaphore) {
return L0::ExternalSemaphore::importExternalSemaphore(hDevice, desc, phSemaphore);
}
ZE_APIEXPORT ze_result_t ZE_APICALL zeDeviceReleaseExternalSemaphoreExt(
ze_external_semaphore_ext_handle_t hSemaphore) {
return L0::ExternalSemaphoreImp::fromHandle(hSemaphore)->releaseExternalSemaphore();
}
}

1
level_zero/api/driver_experimental/public/CMakeLists.txt
View File

@@ -9,7 +9,6 @@ target_sources(${L0_STATIC_LIB_NAME}
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/zex_cmdlist.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zex_context.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zex_device.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zex_driver.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zex_event.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zex_memory.cpp

26
level_zero/api/driver_experimental/public/zex_cmdlist.cpp
View File

@@ -71,28 +71,4 @@ zexCommandListAppendWriteToMemory(
return ZE_RESULT_ERROR_UNKNOWN;
}
}
} // namespace L0
ze_result_t ZE_APICALL
zeIntelCommandListAppendWaitExternalSemaphoresExp(
ze_command_list_handle_t hCmdList,
unsigned int numExternalSemaphores,
const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCmdList)->appendWaitExternalSemaphores(numExternalSemaphores, hSemaphores, params, hSignalEvent, numWaitEvents, phWaitEvents);
}
ze_result_t ZE_APICALL
zeIntelCommandListAppendSignalExternalSemaphoresExp(
ze_command_list_handle_t hCmdList,
size_t numExternalSemaphores,
const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) {
return L0::CommandList::fromHandle(hCmdList)->appendSignalExternalSemaphores(numExternalSemaphores, hSemaphores, params, hSignalEvent, numWaitEvents, phWaitEvents);
}
} // namespace L0

23
level_zero/api/driver_experimental/public/zex_device.cpp
View File

@@ -1,23 +0,0 @@
/*
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/core/source/semaphore/external_semaphore_imp.h"
#include "level_zero/ze_intel_gpu.h"
ze_result_t ZE_APICALL
zeIntelDeviceImportExternalSemaphoreExp(
ze_device_handle_t device,
const ze_intel_external_semaphore_exp_desc_t *semaphoreDesc,
ze_intel_external_semaphore_exp_handle_t *phSemaphore) {
return L0::ExternalSemaphore::importExternalSemaphore(device, semaphoreDesc, phSemaphore);
}
ze_result_t ZE_APICALL
zeIntelDeviceReleaseExternalSemaphoreExp(
ze_intel_external_semaphore_exp_handle_t hSemaphore) {
return L0::ExternalSemaphoreImp::fromHandle(hSemaphore)->releaseExternalSemaphore();
}

8
level_zero/core/source/cmdlist/cmdlist.h
View File

@@ -173,11 +173,11 @@ struct CommandList : _ze_command_list_handle_t {
virtual ze_result_t appendWaitOnMemory(void *desc, void *ptr, uint64_t data, ze_event_handle_t signalEventHandle, bool useQwordData) = 0;
virtual ze_result_t appendWriteToMemory(void *desc, void *ptr,
uint64_t data) = 0;
virtual ze_result_t appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
virtual ze_result_t appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_wait_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) = 0;
virtual ze_result_t appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
virtual ze_result_t appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_signal_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) = 0;
virtual ze_result_t hostSynchronize(uint64_t timeout) = 0;

8
level_zero/core/source/cmdlist/cmdlist_hw.h
View File

@@ -174,11 +174,11 @@ struct CommandListCoreFamily : public CommandListImp {
ze_result_t appendWriteToMemory(void *desc, void *ptr,
uint64_t data) override;
ze_result_t appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
ze_result_t appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_wait_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;
ze_result_t appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
ze_result_t appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_signal_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;
ze_result_t appendQueryKernelTimestamps(uint32_t numEvents, ze_event_handle_t *phEvents, void *dstptr,

8
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@@ -3898,15 +3898,15 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWriteToMemory(void *desc
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_wait_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_signal_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}

8
level_zero/core/source/cmdlist/cmdlist_hw_immediate.h
View File

@@ -176,11 +176,11 @@ struct CommandListCoreFamilyImmediate : public CommandListCoreFamily<gfxCoreFami
ze_result_t appendWriteToMemory(void *desc, void *ptr,
uint64_t data) override;
ze_result_t appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
ze_result_t appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_wait_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;
ze_result_t appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
ze_result_t appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_signal_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) override;
ze_result_t hostSynchronize(uint64_t timeout) override;

8
level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
View File

@@ -1006,8 +1006,8 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWriteToMemory(v
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitExternalSemaphores(uint32_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_wait_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
checkAvailableSpace(0, false, commonImmediateCommandSize, false);
@@ -1051,8 +1051,8 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendWaitExternalSem
}
template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendSignalExternalSemaphores(size_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_signal_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
checkAvailableSpace(0, false, commonImmediateCommandSize, false);

1
level_zero/core/source/driver/driver_handle_imp_helper.cpp
View File

@@ -35,6 +35,7 @@ const std::vector<std::pair<std::string, uint32_t>> DriverHandleImp::extensionsS
{ZE_LINKAGE_INSPECTION_EXT_NAME, ZE_LINKAGE_INSPECTION_EXT_VERSION_CURRENT},
{ZE_IMMEDIATE_COMMAND_LIST_APPEND_EXP_NAME, ZE_IMMEDIATE_COMMAND_LIST_APPEND_EXP_VERSION_1_0},
{ZE_GET_KERNEL_BINARY_EXP_NAME, ZE_KERNEL_GET_BINARY_EXP_VERSION_1_0},
{ZE_EXTERNAL_SEMAPHORES_EXTENSION_NAME, ZE_EXTERNAL_SEMAPHORE_EXT_VERSION_1_0},
// Driver experimental extensions
{ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_NAME, ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_VERSION_CURRENT},

4
level_zero/core/source/driver/extension_function_address.cpp
View File

@@ -58,10 +58,6 @@ void *ExtensionFunctionAddressHelper::getExtensionFunctionAddress(const std::str
RETURN_FUNC_PTR_IF_EXIST(zexIntelAllocateNetworkInterrupt);
RETURN_FUNC_PTR_IF_EXIST(zexIntelReleaseNetworkInterrupt);
RETURN_FUNC_PTR_IF_EXIST(zeIntelDeviceImportExternalSemaphoreExp);
RETURN_FUNC_PTR_IF_EXIST(zeIntelCommandListAppendWaitExternalSemaphoresExp);
RETURN_FUNC_PTR_IF_EXIST(zeIntelCommandListAppendSignalExternalSemaphoresExp);
RETURN_FUNC_PTR_IF_EXIST(zeIntelDeviceReleaseExternalSemaphoreExp);
RETURN_FUNC_PTR_IF_EXIST(zetIntelCommandListAppendMarkerExp);
RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricTracerCreateExp);
RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricTracerDestroyExp);

12
level_zero/core/source/semaphore/external_semaphore.h
View File

@@ -19,23 +19,23 @@
#include <memory>
#include <mutex>
struct _ze_intel_external_semaphore_exp_handle_t {
struct _ze_external_semaphore_ext_handle_t {
const uint64_t objMagic = objMagicValue;
};
namespace L0 {
struct ExternalSemaphore : _ze_intel_external_semaphore_exp_handle_t {
struct ExternalSemaphore : _ze_external_semaphore_ext_handle_t {
virtual ~ExternalSemaphore() = default;
static ze_result_t importExternalSemaphore(ze_device_handle_t device, const ze_intel_external_semaphore_exp_desc_t *semaphoreDesc, ze_intel_external_semaphore_exp_handle_t *phSemaphore);
static ze_result_t importExternalSemaphore(ze_device_handle_t device, const ze_external_semaphore_ext_desc_t *semaphoreDesc, ze_external_semaphore_ext_handle_t *phSemaphore);
virtual ze_result_t releaseExternalSemaphore() = 0;
static ExternalSemaphore *fromHandle(ze_intel_external_semaphore_exp_handle_t handle) { return static_cast<ExternalSemaphore *>(handle); }
inline ze_intel_external_semaphore_exp_handle_t toHandle() { return this; }
static ExternalSemaphore *fromHandle(ze_external_semaphore_ext_handle_t handle) { return static_cast<ExternalSemaphore *>(handle); }
inline ze_external_semaphore_ext_handle_t toHandle() { return this; }
protected:
ze_intel_external_semaphore_exp_desc_t desc;
ze_external_semaphore_ext_desc_t desc;
};
} // namespace L0

36
level_zero/core/source/semaphore/external_semaphore_imp.cpp
View File

@@ -16,7 +16,7 @@
namespace L0 {
ze_result_t
ExternalSemaphore::importExternalSemaphore(ze_device_handle_t device, const ze_intel_external_semaphore_exp_desc_t *semaphoreDesc, ze_intel_external_semaphore_exp_handle_t *phSemaphore) {
ExternalSemaphore::importExternalSemaphore(ze_device_handle_t device, const ze_external_semaphore_ext_desc_t *semaphoreDesc, ze_external_semaphore_ext_handle_t *phSemaphore) {
auto externalSemaphore = new ExternalSemaphoreImp();
if (externalSemaphore == nullptr) {
return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -42,7 +42,7 @@ ExternalSemaphore::importExternalSemaphore(ze_device_handle_t device, const ze_i
return result;
}
ze_result_t ExternalSemaphoreImp::initialize(ze_device_handle_t device, const ze_intel_external_semaphore_exp_desc_t *semaphoreDesc) {
ze_result_t ExternalSemaphoreImp::initialize(ze_device_handle_t device, const ze_external_semaphore_ext_desc_t *semaphoreDesc) {
this->device = Device::fromHandle(device);
auto deviceImp = static_cast<DeviceImp *>(this->device);
this->desc = semaphoreDesc;
@@ -53,13 +53,13 @@ ze_result_t ExternalSemaphoreImp::initialize(ze_device_handle_t device, const ze
if (semaphoreDesc->pNext != nullptr) {
const ze_base_desc_t *extendedDesc =
reinterpret_cast<const ze_base_desc_t *>(semaphoreDesc->pNext);
if (extendedDesc->stype == ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC) { // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
const ze_intel_external_semaphore_win32_exp_desc_t *extendedSemaphoreDesc =
reinterpret_cast<const ze_intel_external_semaphore_win32_exp_desc_t *>(extendedDesc);
if (extendedDesc->stype == ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXT_DESC) { // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
const ze_external_semaphore_win32_ext_desc_t *extendedSemaphoreDesc =
reinterpret_cast<const ze_external_semaphore_win32_ext_desc_t *>(extendedDesc);
handle = extendedSemaphoreDesc->handle;
} else if (extendedDesc->stype == ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_FD_EXP_DESC) { // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
const ze_intel_external_semaphore_desc_fd_exp_desc_t *extendedSemaphoreDesc =
reinterpret_cast<const ze_intel_external_semaphore_desc_fd_exp_desc_t *>(extendedDesc);
} else if (extendedDesc->stype == ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_FD_EXT_DESC) { // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
const ze_external_semaphore_fd_ext_desc_t *extendedSemaphoreDesc =
reinterpret_cast<const ze_external_semaphore_fd_ext_desc_t *>(extendedDesc);
fd = extendedSemaphoreDesc->fd;
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -69,31 +69,31 @@ ze_result_t ExternalSemaphoreImp::initialize(ze_device_handle_t device, const ze
}
switch (semaphoreDesc->flags) {
case ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_FD:
case ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_FD:
externalSemaphoreType = NEO::ExternalSemaphore::Type::OpaqueFd;
break;
case ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32:
case ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32:
externalSemaphoreType = NEO::ExternalSemaphore::Type::OpaqueWin32;
break;
case ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32_KMT:
case ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32_KMT:
externalSemaphoreType = NEO::ExternalSemaphore::Type::OpaqueWin32Kmt;
break;
case ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_D3D12_FENCE:
case ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_D3D12_FENCE:
externalSemaphoreType = NEO::ExternalSemaphore::Type::D3d12Fence;
break;
case ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_D3D11_FENCE:
case ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_D3D11_FENCE:
externalSemaphoreType = NEO::ExternalSemaphore::Type::D3d11Fence;
break;
case ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_KEYED_MUTEX:
case ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_KEYED_MUTEX:
externalSemaphoreType = NEO::ExternalSemaphore::Type::KeyedMutex;
break;
case ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_KEYED_MUTEX_KMT:
case ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_KEYED_MUTEX_KMT:
externalSemaphoreType = NEO::ExternalSemaphore::Type::KeyedMutexKmt;
break;
case ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_TIMELINE_SEMAPHORE_FD:
case ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_VK_TIMELINE_SEMAPHORE_FD:
externalSemaphoreType = NEO::ExternalSemaphore::Type::TimelineSemaphoreFd;
break;
case ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_TIMELINE_SEMAPHORE_WIN32:
case ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_VK_TIMELINE_SEMAPHORE_WIN32:
externalSemaphoreType = NEO::ExternalSemaphore::Type::TimelineSemaphoreWin32;
break;
default:
@@ -118,7 +118,7 @@ std::unique_ptr<ExternalSemaphoreController> ExternalSemaphoreController::create
return std::make_unique<ExternalSemaphoreController>();
}
ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_intel_external_semaphore_exp_handle_t hExtSemaphore, ze_device_handle_t hDevice, ze_context_handle_t hContext, uint64_t fenceValue, ze_event_handle_t *phEvent, ExternalSemaphoreController::SemaphoreOperation operation) {
ze_result_t ExternalSemaphoreController::allocateProxyEvent(ze_external_semaphore_ext_handle_t hExtSemaphore, ze_device_handle_t hDevice, ze_context_handle_t hContext, uint64_t fenceValue, ze_event_handle_t *phEvent, ExternalSemaphoreController::SemaphoreOperation operation) {
std::lock_guard<std::mutex> lock(this->semControllerMutex);
if (this->eventPoolsMap.find(hDevice) == this->eventPoolsMap.end()) {

6
level_zero/core/source/semaphore/external_semaphore_imp.h
View File

@@ -25,14 +25,14 @@ namespace L0 {
class ExternalSemaphoreImp : public ExternalSemaphore {
public:
ze_result_t initialize(ze_device_handle_t device, const ze_intel_external_semaphore_exp_desc_t *semaphoreDesc);
ze_result_t initialize(ze_device_handle_t device, const ze_external_semaphore_ext_desc_t *semaphoreDesc);
ze_result_t releaseExternalSemaphore() override;
std::unique_ptr<NEO::ExternalSemaphore> neoExternalSemaphore;
protected:
Device *device = nullptr;
const ze_intel_external_semaphore_exp_desc_t *desc;
const ze_external_semaphore_ext_desc_t *desc;
};
class ExternalSemaphoreController : NEO::NonCopyableAndNonMovableClass {
@@ -81,7 +81,7 @@ class ExternalSemaphoreController : NEO::NonCopyableAndNonMovableClass {
}
}
ze_result_t allocateProxyEvent(ze_intel_external_semaphore_exp_handle_t hExtSemaphore, ze_device_handle_t hDevice, ze_context_handle_t hContext, uint64_t fenceValue, ze_event_handle_t *phEvent, SemaphoreOperation operation);
ze_result_t allocateProxyEvent(ze_external_semaphore_ext_handle_t hExtSemaphore, ze_device_handle_t hDevice, ze_context_handle_t hContext, uint64_t fenceValue, ze_event_handle_t *phEvent, SemaphoreOperation operation);
void processProxyEvents();
std::mutex semControllerMutex;

8
level_zero/core/test/unit_tests/mocks/mock_cmdlist.h
View File

@@ -572,12 +572,12 @@ struct MockCommandList : public CommandList {
(void *desc, void *ptr, uint64_t data, ze_event_handle_t signalEventHandle, bool useQwordData));
ADDMETHOD_NOBASE(appendWaitExternalSemaphores, ze_result_t, ZE_RESULT_SUCCESS,
(uint32_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_wait_params_exp_t *params, ze_event_handle_t hSignalEvent,
(uint32_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_wait_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents));
ADDMETHOD_NOBASE(appendSignalExternalSemaphores, ze_result_t, ZE_RESULT_SUCCESS,
(size_t numExternalSemaphores, const ze_intel_external_semaphore_exp_handle_t *hSemaphores,
const ze_intel_external_semaphore_signal_params_exp_t *params, ze_event_handle_t hSignalEvent,
(size_t numExternalSemaphores, const ze_external_semaphore_ext_handle_t *hSemaphores,
const ze_external_semaphore_signal_params_ext_t *params, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents));
ADDMETHOD_NOBASE(appendWriteToMemory, ze_result_t, ZE_RESULT_SUCCESS,

14
level_zero/core/test/unit_tests/sources/semaphore/linux/test_semaphore_linux.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -47,20 +47,20 @@ using DrmExternalSemaphoreTest = Test<DrmSemaphoreFixture>;
HWTEST_F(DrmExternalSemaphoreTest, givenDriverModelDrmWhenImportExternalSemaphoreExpIsCalledThenUnsupportedFeatureIsReturned) {
MockDeviceImp l0Device(neoDevice, neoDevice->getExecutionEnvironment());
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
int fd = 0;
ze_intel_external_semaphore_desc_fd_exp_desc_t fdDesc = {};
ze_external_semaphore_fd_ext_desc_t fdDesc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_FD;
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_FD;
fdDesc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_FD_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
fdDesc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_FD_EXT_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
fdDesc.fd = fd;
desc.pNext = &fdDesc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device.toHandle(), &desc, &hSemaphore);
ze_result_t result = zeDeviceImportExternalSemaphoreExt(l0Device.toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}

60
level_zero/core/test/unit_tests/sources/semaphore/test_semaphore.cpp
View File

@@ -28,9 +28,9 @@ namespace ult {
using ExternalSemaphoreTest = Test<DeviceFixture>;
HWTEST_F(ExternalSemaphoreTest, givenInvalidDescriptorAndImportExternalSemaphoreExpIsCalledThenInvalidArgumentsIsReturned) {
ze_device_handle_t hDevice = device->toHandle();
const ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(hDevice, &desc, &hSemaphore);
const ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
ze_result_t result = zeDeviceImportExternalSemaphoreExt(hDevice, &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_ERROR_INVALID_ARGUMENT);
}
@@ -42,7 +42,7 @@ HWTEST_F(ExternalSemaphoreTest, givenValidParametersWhenReleaseExternalSemaphore
HWTEST_F(ExternalSemaphoreTest, givenInvalidDescriptorWhenInitializeIsCalledThenInvalidArgumentIsReturned) {
ze_device_handle_t hDevice = device->toHandle();
const ze_intel_external_semaphore_exp_desc_t desc = {};
const ze_external_semaphore_ext_desc_t desc = {};
auto externalSemaphoreImp = new ExternalSemaphoreImp();
ze_result_t result = externalSemaphoreImp->initialize(hDevice, &desc);
EXPECT_EQ(result, ZE_RESULT_ERROR_INVALID_ARGUMENT);
@@ -69,8 +69,8 @@ HWTEST2_F(ExternalSemaphoreTest, givenRegularCommandListWhenAppendWaitExternalSe
MockCommandListCoreFamily<gfxCoreFamily> cmdList;
cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore = reinterpret_cast<ze_intel_external_semaphore_exp_handle_t>(0x1);
ze_external_semaphore_wait_params_ext_t waitParams = {};
ze_external_semaphore_ext_handle_t hSemaphore = reinterpret_cast<ze_external_semaphore_ext_handle_t>(0x1);
ze_result_t result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_ERROR_INVALID_ARGUMENT);
}
@@ -79,8 +79,8 @@ HWTEST2_F(ExternalSemaphoreTest, givenRegularCommandListWhenAppendSignalExternal
MockCommandListCoreFamily<gfxCoreFamily> cmdList;
cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore = reinterpret_cast<ze_intel_external_semaphore_exp_handle_t>(0x1);
ze_external_semaphore_signal_params_ext_t signalParams = {};
ze_external_semaphore_ext_handle_t hSemaphore = reinterpret_cast<ze_external_semaphore_ext_handle_t>(0x1);
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_ERROR_INVALID_ARGUMENT);
}
@@ -142,10 +142,10 @@ HWTEST2_F(ExternalSemaphoreTest, givenImmediateCommandListWhenAppendSignalExtern
cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
cmdList.setCmdListContext(context);
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
ze_external_semaphore_signal_params_ext_t signalParams = {};
signalParams.value = 1u;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 0u);
@@ -174,11 +174,11 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendWaitOnEventFailsWhenAppendSignalExte
cmdList.setCmdListContext(context);
cmdList.failingWaitOnEvents = true;
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
ze_external_semaphore_signal_params_ext_t signalParams = {};
signalParams.value = 1u;
ze_event_handle_t event;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 1, &event);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 1u);
@@ -205,10 +205,10 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalInternalProxyEventFailsWhenApp
cmdList.setCmdListContext(context);
cmdList.failingSignalEvent = true;
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
ze_external_semaphore_signal_params_ext_t signalParams = {};
signalParams.value = 1u;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 0, nullptr);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 0u);
@@ -236,12 +236,12 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalEventFailsWhenAppendSignalExte
cmdList.setCmdListContext(context);
cmdList.failOnSecondSignalEvent = true;
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
ze_external_semaphore_signal_params_ext_t signalParams = {};
signalParams.value = 1u;
ze_event_handle_t waitEvent = {};
MockEvent signalEvent;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_event_handle_t hSignalEvent = signalEvent.toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, hSignalEvent, 1, &waitEvent);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
@@ -269,8 +269,8 @@ HWTEST2_F(ExternalSemaphoreTest, givenFailingMemoryManagerWhenAppendSignalExtern
cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
cmdList.setCmdListContext(context);
ze_intel_external_semaphore_signal_params_exp_t signalParams = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_signal_params_ext_t signalParams = {};
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendSignalExternalSemaphores(1, &hSemaphore, &signalParams, nullptr, 0, nullptr);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 0u);
@@ -297,9 +297,9 @@ HWTEST2_F(ExternalSemaphoreTest, givenImmediateCommandListWhenAppendWaitExternal
cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
cmdList.setCmdListContext(context);
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 1u);
@@ -327,10 +327,10 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendWaitOnEventFailsWhenAppendWaitExtern
cmdList.setCmdListContext(context);
cmdList.failingWaitOnEvents = true;
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
ze_event_handle_t event;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 1, &event);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 1u);
@@ -357,9 +357,9 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendWaitOnInternalProxyEventFailsWhenApp
cmdList.setCmdListContext(context);
cmdList.failingWaitOnEvents = true;
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 1u);
@@ -387,11 +387,11 @@ HWTEST2_F(ExternalSemaphoreTest, givenAppendSignalEventFailsWhenAppendWaitExtern
cmdList.setCmdListContext(context);
cmdList.failingSignalEvent = true;
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
ze_event_handle_t waitEvent = {};
MockEvent signalEvent;
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_event_handle_t hSignalEvent = signalEvent.toHandle();
ze_result_t result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, hSignalEvent, 1, &waitEvent);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
@@ -419,8 +419,8 @@ HWTEST2_F(ExternalSemaphoreTest, givenFailingMemoryManagerWhenAppendWaitExternal
cmdList.initialize(l0Device.get(), NEO::EngineGroupType::renderCompute, 0u);
cmdList.setCmdListContext(context);
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_wait_params_ext_t waitParams = {};
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 0u);
@@ -601,9 +601,9 @@ HWTEST2_F(ExternalSemaphoreTest, DISABLED_givenNEOExternalSemaphoreWhenAppendWai
auto mockNEOExternalSemaphore = static_cast<MockNEOExternalSemaphore *>(externalSemaphore->neoExternalSemaphore.get());
EXPECT_EQ(mockNEOExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Initial);
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore = externalSemaphore->toHandle();
ze_external_semaphore_ext_handle_t hSemaphore = externalSemaphore->toHandle();
ze_result_t result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(cmdList.appendWaitOnEventsCalledTimes, 1u);

122
level_zero/core/test/unit_tests/sources/semaphore/windows/test_semaphore_windows.cpp
View File

@@ -50,24 +50,24 @@ using MockDriverHandleImp = Mock<L0::DriverHandleImp>;
HWTEST_F(WddmExternalSemaphoreTest, DISABLED_givenValidExternalSemaphoreWhenImportExternalSemaphoreExpIsCalledThenSuccessIsReturned) {
auto l0Device = std::make_unique<MockDeviceImp>(neoDevice, neoDevice->getExecutionEnvironment());
auto driverHandleImp = std::make_unique<MockDriverHandleImp>();
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
l0Device->setDriverHandle(driverHandleImp.get());
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
ze_external_semaphore_win32_ext_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXT_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
ze_result_t result = zeDeviceImportExternalSemaphoreExt(l0Device->toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
result = zeDeviceReleaseExternalSemaphoreExt(hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
@@ -108,19 +108,19 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenEnqueueSignalFailsWhenExterna
static_cast<OsEnvironmentWin *>(l0Device->neoDevice->getExecutionEnvironment()->osEnvironment.get())->gdi.reset(mockGdi);
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
ze_external_semaphore_win32_ext_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXT_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
ze_result_t result = zeDeviceImportExternalSemaphoreExt(l0Device->toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
@@ -141,7 +141,7 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenEnqueueSignalFailsWhenExterna
EXPECT_EQ(neoExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Initial);
lock.unlock();
result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
result = zeDeviceReleaseExternalSemaphoreExt(hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
@@ -152,19 +152,19 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSemaphoreSignalOperationEvent
driverHandleImp->setMemoryManager(mockMemoryManager.get());
l0Device->setDriverHandle(driverHandleImp.get());
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
ze_external_semaphore_win32_ext_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXT_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
ze_result_t result = zeDeviceImportExternalSemaphoreExt(l0Device->toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
driverHandleImp->externalSemaphoreController = ExternalSemaphoreController::create();
@@ -185,13 +185,13 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSemaphoreSignalOperationEvent
EXPECT_EQ(neoExternalSemaphore->getState(), NEO::ExternalSemaphore::SemaphoreState::Signaled);
lock.unlock();
result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
result = zeDeviceReleaseExternalSemaphoreExt(hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenImmediateCommandListWhenAppendWaitExternalSemaphoresExpIsCalledThenSuccessIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
@@ -210,29 +210,29 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenImmediateCommandListWhenAppen
commandList->setCmdListContext(context);
auto &cmdList = static_cast<MockCommandListImmediate<gfxCoreFamily> &>(*commandList);
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
ze_external_semaphore_win32_ext_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXT_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
ze_result_t result = zeDeviceImportExternalSemaphoreExt(l0Device->toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
result = zeDeviceReleaseExternalSemaphoreExt(hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenRegularCommandListWhenAppendWaitExternalSemaphoresExpIsCalledThenInvalidArgumentIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
@@ -244,23 +244,23 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenRegularCommandListWhenAppendW
MockCommandListCoreFamily<gfxCoreFamily> cmdList;
cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
ze_external_semaphore_win32_ext_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXT_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
ze_result_t result = zeDeviceImportExternalSemaphoreExt(l0Device->toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_ERROR_INVALID_ARGUMENT);
result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
result = zeDeviceReleaseExternalSemaphoreExt(hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
@@ -293,8 +293,8 @@ struct MockCommandListImmediateExtSem : public WhiteBox<::L0::CommandListCoreFam
};
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenInternalProxyEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
@@ -313,29 +313,29 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenInternalProxyEventFailsToAppe
cmdList.setCmdListContext(context);
cmdList.failingWaitOnEvents = true;
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
ze_external_semaphore_win32_ext_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXT_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
ze_result_t result = zeDeviceImportExternalSemaphoreExt(l0Device->toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 0, nullptr);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
result = zeDeviceReleaseExternalSemaphoreExt(hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenWaitEventFailsToAppendWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
@@ -354,30 +354,30 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenWaitEventFailsToAppendWhenApp
cmdList.setCmdListContext(context);
cmdList.failingWaitOnEvents = true;
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
ze_external_semaphore_win32_ext_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXT_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
ze_result_t result = zeDeviceImportExternalSemaphoreExt(l0Device->toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
ze_event_handle_t waitEvent;
result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, nullptr, 1, &waitEvent);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
result = zeDeviceReleaseExternalSemaphoreExt(hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}
HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSignalEventFailsWhenAppendWaitExternalSemaphoresExpIsCalledThenErrorIsReturned, MatchAny) {
ze_intel_external_semaphore_exp_desc_t desc = {};
ze_intel_external_semaphore_exp_handle_t hSemaphore;
ze_external_semaphore_ext_desc_t desc = {};
ze_external_semaphore_ext_handle_t hSemaphore;
HANDLE extSemaphoreHandle = 0;
auto mockMemoryManager = std::make_unique<MockMemoryManager>();
@@ -396,25 +396,25 @@ HWTEST2_F(WddmExternalSemaphoreTest, DISABLED_givenSignalEventFailsWhenAppendWai
cmdList.setCmdListContext(context);
cmdList.failingSignalEvent = true;
ze_intel_external_semaphore_win32_exp_desc_t win32Desc = {};
ze_external_semaphore_win32_ext_desc_t win32Desc = {};
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32;
desc.flags = ZE_EXTERNAL_SEMAPHORE_EXT_FLAG_OPAQUE_WIN32;
win32Desc.stype = ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.stype = ZE_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXT_DESC; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
win32Desc.handle = reinterpret_cast<void *>(extSemaphoreHandle);
desc.pNext = &win32Desc;
ze_result_t result = zeIntelDeviceImportExternalSemaphoreExp(l0Device->toHandle(), &desc, &hSemaphore);
ze_result_t result = zeDeviceImportExternalSemaphoreExt(l0Device->toHandle(), &desc, &hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ze_intel_external_semaphore_wait_params_exp_t waitParams = {};
ze_external_semaphore_wait_params_ext_t waitParams = {};
MockEvent signalEvent;
result = cmdList.appendWaitExternalSemaphores(1, &hSemaphore, &waitParams, signalEvent.toHandle(), 0, nullptr);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
result = zeIntelDeviceReleaseExternalSemaphoreExp(hSemaphore);
result = zeDeviceReleaseExternalSemaphoreExt(hSemaphore);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
}

131
level_zero/doc/experimental_extensions/EXTERNAL_SEMAPHORE.md
View File

@@ -1,131 +0,0 @@
<!---
Copyright (C) 2024 Intel Corporation
SPDX-License-Identifier: MIT
-->
# External Semaphore Extension
* [Overview](#Overview)
* [Definitions](#Definitions)
* [Known Issues and Limitations](#Known-Issues-and-Limitations)
# Overview
Users need a solution that allows for a fully asynchronous rendering pipeline in interop applications, as the existing solutions only allow for synchronization in the host level in these scenarios. This extension provides an API that will take the external semaphores from other graphics APIs and use it to synchronize to support the interoperability.
# Definitions
```cpp
#define ZE_INTEL_EXTERNAL_SEMAPHORE_EXP_NAME "ZE_intel_experimental_external_semaphore"
typedef enum _ze_intel_external_semaphore_exp_version_t {
ZE_EXTERNAL_SEMAPHORE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0), ///< version 1.0
ZE_EXTERNAL_SEMAPHORE_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
ZE_EXTERNAL_SEMAPHORE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
} ze_intel_external_semaphore_exp_version_t;
typedef enum _ze_intel_external_semaphore_exp_flags_t {
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_FD,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32_KMT,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_D3D12_FENCE,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_D3D11_FENCE,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_KEYED_MUTEX,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_KEYED_MUTEX_KMT,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_TIMELINE_SEMAPHORE_FD,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_TIMELINE_SEMAPHORE_WIN32
} ze_intel_external_semaphore_exp_flags_t;
typedef struct _ze_intel_external_semaphore_exp_desc_t {
ze_structure_type_t stype;
const void *pNext;
ze_intel_external_semaphore_exp_flags_t flags;
} ze_intel_external_semaphore_exp_desc_t;
typedef struct _ze_intel_external_semaphore_win32_exp_desc_t {
ze_structure_type_t stype;
const void *pNext;
const char *name;
} ze_intel_external_semaphore_win32_exp_desc_t;
typedef struct _ze_intel_external_semaphore_fd_exp_desc_t {
ze_structure_type_t stype;
const void *pNext;
int fd;
} ze_intel_external_semaphore_desc_fd_exp_desc_t;
typedef struct _ze_intel_external_semaphore_signal_exp_params_t {
ze_structure_type_t stype;
const void *pNext;
uint64_t value;
} ze_intel_external_semaphore_signal_exp_params_t;
typedef struct _ze_intel_external_semaphore_wait_exp_params_t {
ze_structure_type_t stype;
const void *pNext;
uint64_t value;
} ze_intel_external_semaphore_wait_exp_params_t;
```
## Interfaces
```cpp
/// @brief Import External Semaphore
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
ze_result_t ZE_APICALL
zeIntelDeviceImportExternalSemaphoreExp(
ze_device_handle_t device, ///< [in] handle of the device
const ze_intel_external_semaphore_exp_desc_t *semaphoreDesc, ///< [in] pointer to external semaphore descriptor
ze_intel_external_semaphore_exp_handle_t *phSemaphore ///< [out] pointer to handle of the external semaphore
);
/// @brief Wait on External Semaphores
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
ze_result_t ZE_APICALL
zeIntelCommandListAppendWaitExternalSemaphoresExp(
ze_command_list_handle_t hCmdList, ///< [in] handle of the command list
unsigned int numExternalSemaphores, ///< [in] number of external semaphores
const ze_intel_external_semaphore_exp_handle_t *phSemaphores, ///< [in] pointer to array of external semaphore handles
const ze_intel_external_semaphore_wait_params_exp_t *params, ///< [in] pointer to array of wait parameters
ze_event_handle_t hSignalEvent, ///< [in][optional] handle of the event to signal on completion
uint32_t numWaitEvents, ///< [in][optional] number of events to wait on before continuing
ze_event_handle_t *phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handles of the events to wait on before continuing
);
/// @brief Signal External Semaphores
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
ze_result_t ZE_APICALL
zeIntelCommandListAppendSignalExternalSemaphoresExp(
ze_command_list_handle_t hCmdList, ///< [in] handle of the command list
size_t numExternalSemaphores, ///< [in] number of external semaphores
const ze_intel_external_semaphore_exp_handle_t *phSemaphores, ///< [in] pointer to array of external semaphore handles
const ze_intel_external_semaphore_signal_params_exp_t *params, ///< [in] pointer to array of signal parameters
ze_event_handle_t hSignalEvent, ///< [in][optional] handle of the event to signal on completion
uint32_t numWaitEvents, ///< [in][optional] number of events to wait on before continuing
ze_event_handle_t *phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handles of the events to wait on before continuing
);
/// @brief Release External Semaphore
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
ze_result_t ZE_APICALL
zeIntelDeviceReleaseExternalSemaphoreExp(
ze_intel_external_semaphore_exp_handle_t *hSemaphore ///< [in] semaphore that is no longer used thus released by level-zero
);
```
## Programming example
# Known Issues and Limitations

100
level_zero/include/level_zero/ze_intel_gpu.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2024 Intel Corporation
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -275,104 +275,6 @@ zeIntelKernelGetBinaryExp(
char *pKernelBinary ///< [in,out] pointer to storage area for GEN ISA binary function
);
///////////////////////////////////////////////////////////////////////////////
#ifndef ZE_INTEL_EXTERNAL_SEMAPHORE_EXP_NAME
/// @brief External semaphore extension name
#define ZE_INTEL_EXTERNAL_SEMAPHORE_EXP_NAME "ZE_intel_experimental_external_semaphore"
#endif // ZE_INTEL_EXTERNAL_SEMAPHORE_EXP_NAME
typedef enum _ze_intel_external_semaphore_exp_version_t {
ZE_EXTERNAL_SEMAPHORE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0), ///< version 1.0
ZE_EXTERNAL_SEMAPHORE_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
ZE_EXTERNAL_SEMAPHORE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
} ze_intel_external_semaphore_exp_version_t;
typedef enum _ze_intel_external_semaphore_exp_flags_t {
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_FD,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_OPAQUE_WIN32_KMT,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_D3D12_FENCE,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_D3D11_FENCE,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_KEYED_MUTEX,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_KEYED_MUTEX_KMT,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_TIMELINE_SEMAPHORE_FD,
ZE_EXTERNAL_SEMAPHORE_EXP_FLAGS_TIMELINE_SEMAPHORE_WIN32
} ze_intel_external_semaphore_exp_flags_t;
typedef struct _ze_intel_external_semaphore_exp_desc_t {
ze_structure_type_t stype; ///< [in] type of this structure
const void *pNext; ///< [in] must be null or a pointer to an extension-specific
///< structure (i.e. contains stype and pNext). When importing
///< a semaphore, this can be a pointer to either ze_intel_external_semaphore_win32_exp_desc_t
///< or ze_intel_external_semaphore_fd_exp_desc_t.
ze_intel_external_semaphore_exp_flags_t flags; ///< [in] External semaphore flags. Must be 0 or a valid combination of ::ze_intel_external_semaphore_exp_flags_t
} ze_intel_external_semaphore_exp_desc_t;
typedef struct _ze_intel_external_semaphore_win32_exp_desc_t {
ze_structure_type_t stype; ///< [in] type of this structure
const void *pNext; ///< [in] must be null or a pointer to an extension-specific
///< structure (i.e. contains stype and pNext).
void *handle; ///< [in] Win32 HANDLE for semaphore
const char *name; ///< [in] Name of the semaphore. Must be valid NULL terminated string.
} ze_intel_external_semaphore_win32_exp_desc_t;
typedef struct _ze_intel_external_semaphore_fd_exp_desc_t {
ze_structure_type_t stype; ///< [in] type of this structure
const void *pNext; ///< [in] must be null or a pointer to an extension-specific
///< structure (i.e. contains stype and pNext).
int fd; ///< [in] File descriptor for semaphore. Must be valid file descriptor.
} ze_intel_external_semaphore_desc_fd_exp_desc_t;
typedef struct _ze_intel_external_semaphore_signal_params_exp_t {
ze_structure_type_t stype; ///< [in] type of this structure
const void *pNext; ///< [in] must be null or a pointer to an extension-specific
///< structure (i.e. contains stype and pNext).
uint64_t value; /// [in] [optional] Value to signal the semaphore with
} ze_intel_external_semaphore_signal_params_exp_t;
typedef struct _ze_intel_external_semaphore_wait_params_exp_t {
ze_structure_type_t stype; ///< [in] type of this structure
const void *pNext; ///< [in] must be null or a pointer to an extension-specific
///< structure (i.e. contains stype and pNext).
uint64_t value; /// [in] [optional] Value to wait on the semaphore for
} ze_intel_external_semaphore_wait_params_exp_t;
typedef struct _ze_intel_external_semaphore_exp_handle_t *ze_intel_external_semaphore_exp_handle_t;
ZE_APIEXPORT ze_result_t ZE_APICALL
zeIntelDeviceImportExternalSemaphoreExp(
ze_device_handle_t device, ///< [in] handle of the device
const ze_intel_external_semaphore_exp_desc_t *semaphoreDesc, ///< [in] pointer to external semaphore descriptor
ze_intel_external_semaphore_exp_handle_t *phSemaphore ///< [out] pointer to handle of the external semaphore
);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeIntelCommandListAppendWaitExternalSemaphoresExp(
ze_command_list_handle_t hCmdList, ///< [in] handle of the command list
unsigned int numExternalSemaphores, ///< [in] number of external semaphores
const ze_intel_external_semaphore_exp_handle_t *phSemaphores, ///< [in] pointer to array of external semaphore handles
const ze_intel_external_semaphore_wait_params_exp_t *params, ///< [in] pointer to array of wait parameters
ze_event_handle_t hSignalEvent, ///< [in][optional] handle of the event to signal on completion
uint32_t numWaitEvents, ///< [in][optional] number of events to wait on before continuing
ze_event_handle_t *phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handles of the events to wait on before continuing
);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeIntelCommandListAppendSignalExternalSemaphoresExp(
ze_command_list_handle_t hCmdList, ///< [in] handle of the command list
size_t numExternalSemaphores, ///< [in] number of external semaphores
const ze_intel_external_semaphore_exp_handle_t *phSemaphores, ///< [in] pointer to array of external semaphore handles
const ze_intel_external_semaphore_signal_params_exp_t *params, ///< [in] pointer to array of signal parameters
ze_event_handle_t hSignalEvent, ///< [in][optional] handle of the event to signal on completion
uint32_t numWaitEvents, ///< [in][optional] number of events to wait on before continuing
ze_event_handle_t *phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handles of the events to wait on before continuing
);
ZE_APIEXPORT ze_result_t ZE_APICALL
zeIntelDeviceReleaseExternalSemaphoreExp(
ze_intel_external_semaphore_exp_handle_t hSemaphore ///< [in] handle of the external semaphore
);
#if defined(__cplusplus)
} // extern "C"
#endif

5
level_zero/include/level_zero/ze_stypes.h
View File

@@ -29,11 +29,6 @@
#define ZE_STRUCTURE_INTEL_DEVICE_MEMORY_CXL_EXP_PROPERTIES (ze_structure_type_t)0x00030019
#define ZEX_STRUCTURE_COUNTER_BASED_EVENT_DESC (ze_structure_type_t)0x0003001C
#define ZEX_STRUCTURE_COUNTER_BASED_EVENT_EXTERNAL_SYNC_ALLOC_PROPERTIES (ze_structure_type_t)0x0003001D
#define ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_EXP_DESC (ze_structure_type_t)0x0003001E
#define ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WIN32_EXP_DESC (ze_structure_type_t)0x0003001F
#define ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_FD_EXP_DESC (ze_structure_type_t)0x00030023
#define ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_EXP (ze_structure_type_t)0x00030024
#define ZE_INTEL_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_WAIT_PARAMS_EXP (ze_structure_type_t)0x00030025
#define ZEX_STRUCTURE_COUNTER_BASED_EVENT_EXTERNAL_STORAGE_ALLOC_PROPERTIES (ze_structure_type_t)0x00030027
// Metric structure types