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

Context implementation (3/N)

Browse Source 
Add object creators.

Change-Id: Ic656a1bd3735bce1d995c407011ef7c26eab848e
Signed-off: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
This commit is contained in:
Jaime Arteaga
2020-07-22 10:40:20 -07:00
parent a6d4cb1a21
commit 63a801ee07
14 changed files with 427 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
level_zero/api/core/ze_cmdlist.cpp
View File

@@ -6,6 +6,7 @@
*/
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/source/context/context.h"
#include <level_zero/ze_api.h>
#include "third_party/level_zero/ze_api_ext.h"
@@ -20,6 +21,15 @@ zeCommandListCreate(
return L0::Device::fromHandle(hDevice)->createCommandList(desc, phCommandList);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *phCommandList) {
return L0::Context::fromHandle(hContext)->createCommandList(hDevice, desc, phCommandList);
}
__zedllexport ze_result_t __zecall
zeCommandListCreateImmediate(
ze_device_handle_t hDevice,
@@ -28,6 +38,15 @@ zeCommandListCreateImmediate(
return L0::Device::fromHandle(hDevice)->createCommandListImmediate(altdesc, phCommandList);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreateImmediateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *altdesc,
ze_command_list_handle_t *phCommandList) {
return L0::Context::fromHandle(hContext)->createCommandListImmediate(hDevice, altdesc, phCommandList);
}
__zedllexport ze_result_t __zecall
zeCommandListDestroy(
ze_command_list_handle_t hCommandList) {

10
level_zero/api/core/ze_cmdqueue.cpp
View File

@@ -6,6 +6,7 @@
*/
#include "level_zero/core/source/cmdqueue/cmdqueue.h"
#include "level_zero/core/source/context/context.h"
#include <level_zero/ze_api.h>
extern "C" {
@@ -18,6 +19,15 @@ zeCommandQueueCreate(
return L0::Device::fromHandle(hDevice)->createCommandQueue(desc, phCommandQueue);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueCreateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *phCommandQueue) {
return L0::Context::fromHandle(hContext)->createCommandQueue(hDevice, desc, phCommandQueue);
}
__zedllexport ze_result_t __zecall
zeCommandQueueDestroy(
ze_command_queue_handle_t hCommandQueue) {

10
level_zero/api/core/ze_module.cpp
View File

@@ -21,6 +21,16 @@ zeModuleCreate(
return L0::Device::fromHandle(hDevice)->createModule(desc, phModule, phBuildLog);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleCreateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog) {
return L0::Context::fromHandle(hContext)->createModule(hDevice, desc, phModule, phBuildLog);
}
__zedllexport ze_result_t __zecall
zeModuleDestroy(
ze_module_handle_t hModule) {

10
level_zero/api/core/ze_sampler.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "level_zero/core/source/context/context.h"
#include "level_zero/core/source/sampler/sampler.h"
#include <level_zero/ze_api.h>
@@ -18,6 +19,15 @@ zeSamplerCreate(
return L0::Device::fromHandle(hDevice)->createSampler(desc, phSampler);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zeSamplerCreateExt(
ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_sampler_desc_t *desc,
ze_sampler_handle_t *phSampler) {
return L0::Context::fromHandle(hContext)->createSampler(hDevice, desc, phSampler);
}
__zedllexport ze_result_t __zecall
zeSamplerDestroy(
ze_sampler_handle_t hSampler) {

16
level_zero/core/source/context/context.h
View File

@@ -52,6 +52,22 @@ struct Context : _ze_context_handle_t {
virtual ze_result_t getMemAllocProperties(const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) = 0;
virtual ze_result_t createModule(ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog) = 0;
virtual ze_result_t createSampler(ze_device_handle_t hDevice,
const ze_sampler_desc_t *pDesc,
ze_sampler_handle_t *phSampler) = 0;
virtual ze_result_t createCommandQueue(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *commandQueue) = 0;
virtual ze_result_t createCommandList(ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *commandList) = 0;
virtual ze_result_t createCommandListImmediate(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_list_handle_t *commandList) = 0;
static Context *fromHandle(ze_context_handle_t handle) { return static_cast<Context *>(handle); }
inline ze_context_handle_t toHandle() { return this; }

33
level_zero/core/source/context/context_imp.cpp
View File

@@ -7,6 +7,8 @@
#include "level_zero/core/source/context/context_imp.h"
#include "level_zero/core/source/device/device.h"
namespace L0 {
ze_result_t ContextImp::destroy() {
@@ -111,4 +113,35 @@ ze_result_t ContextImp::getMemAllocProperties(const void *ptr,
phDevice);
}
ze_result_t ContextImp::createModule(ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog) {
return L0::Device::fromHandle(hDevice)->createModule(desc, phModule, phBuildLog);
}
ze_result_t ContextImp::createSampler(ze_device_handle_t hDevice,
const ze_sampler_desc_t *pDesc,
ze_sampler_handle_t *phSampler) {
return L0::Device::fromHandle(hDevice)->createSampler(pDesc, phSampler);
}
ze_result_t ContextImp::createCommandQueue(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *commandQueue) {
return L0::Device::fromHandle(hDevice)->createCommandQueue(desc, commandQueue);
}
ze_result_t ContextImp::createCommandList(ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *commandList) {
return L0::Device::fromHandle(hDevice)->createCommandList(desc, commandList);
}
ze_result_t ContextImp::createCommandListImmediate(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_list_handle_t *commandList) {
return L0::Device::fromHandle(hDevice)->createCommandListImmediate(desc, commandList);
}
} // namespace L0

16
level_zero/core/source/context/context_imp.h
View File

@@ -46,6 +46,22 @@ struct ContextImp : Context {
ze_result_t getMemAllocProperties(const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice) override;
ze_result_t createModule(ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog) override;
ze_result_t createSampler(ze_device_handle_t hDevice,
const ze_sampler_desc_t *pDesc,
ze_sampler_handle_t *phSampler) override;
ze_result_t createCommandQueue(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *commandQueue) override;
ze_result_t createCommandList(ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *commandList) override;
ze_result_t createCommandListImmediate(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_list_handle_t *commandList) override;
protected:
DriverHandle *driverHandle = nullptr;

1
level_zero/core/source/module/module.h
View File

@@ -8,6 +8,7 @@
#pragma once
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/source/context/context.h"
#include "level_zero/core/source/kernel/kernel.h"
#include "level_zero/core/source/module/module_build_log.h"
#include <level_zero/ze_api.h>

31
level_zero/core/test/unit_tests/mocks/mock_context.h
View File

@@ -93,6 +93,37 @@ struct Mock<Context> : public Context {
ze_ipc_memory_flags_t flags,
void **ptr),
(override));
MOCK_METHOD(ze_result_t,
createModule,
(ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog),
(override));
MOCK_METHOD(ze_result_t,
createSampler,
(ze_device_handle_t hDevice,
const ze_sampler_desc_t *pDesc,
ze_sampler_handle_t *phSampler),
(override));
MOCK_METHOD(ze_result_t,
createCommandQueue,
(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *commandQueue),
(override));
MOCK_METHOD(ze_result_t,
createCommandList,
(ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *commandList),
(override));
MOCK_METHOD(ze_result_t,
createCommandListImmediate,
(ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_list_handle_t *commandList),
(override));
};
} // namespace ult

26
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
View File

@@ -14,6 +14,7 @@
#include "test.h"
#include "level_zero/core/source/builtin/builtin_functions_lib_impl.h"
#include "level_zero/core/source/context/context.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/core/source/image/image_hw.h"
#include "level_zero/core/source/kernel/kernel_imp.h"
@@ -25,6 +26,31 @@
namespace L0 {
namespace ult {
using ContextCommandListCreate = Test<ContextFixture>;
TEST_F(ContextCommandListCreate, whenCreatingCommandListFromContextThenSuccessIsReturned) {
ze_command_list_desc_t desc = {};
ze_command_list_handle_t hCommandList = {};
ze_result_t result = context->createCommandList(device, &desc, &hCommandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
L0::CommandList *commandList = L0::CommandList::fromHandle(hCommandList);
commandList->destroy();
}
TEST_F(ContextCommandListCreate, whenCreatingCommandListImmediateFromContextThenSuccessIsReturned) {
ze_command_queue_desc_t desc = {};
ze_command_list_handle_t hCommandList = {};
ze_result_t result = context->createCommandListImmediate(device, &desc, &hCommandList);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
L0::CommandList *commandList = L0::CommandList::fromHandle(hCommandList);
commandList->destroy();
}
using CommandListCreate = Test<DeviceFixture>;
TEST(zeCommandListCreateImmediate, redirectsToObject) {

17
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue.cpp
View File

@@ -13,6 +13,7 @@
#include "test.h"
#include "level_zero/core/source/context/context.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/fixtures/module_fixture.h"
@@ -420,5 +421,21 @@ HWTEST_F(CommandQueueIndirectAllocations, givenCommandQueueWhenExecutingCommandL
commandQueue->destroy();
}
using ContextCreateCommandQueueTest = Test<ContextFixture>;
TEST_F(ContextCreateCommandQueueTest, givenCallToContextCreateCommandQueueThenCallSucceeds) {
ze_command_queue_desc_t desc = {};
desc.version = ZE_COMMAND_QUEUE_DESC_VERSION_CURRENT;
desc.ordinal = 0u;
ze_command_queue_handle_t commandQueue = {};
ze_result_t res = context->createCommandQueue(device, &desc, &commandQueue);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
EXPECT_NE(nullptr, commandQueue);
L0::CommandQueue::fromHandle(commandQueue)->destroy();
}
} // namespace ult
} // namespace L0

29
level_zero/core/test/unit_tests/sources/module/test_module.cpp
View File

@@ -9,8 +9,10 @@
#include "test.h"
#include "level_zero/core/source/context/context.h"
#include "level_zero/core/source/kernel/kernel_imp.h"
#include "level_zero/core/source/module/module_imp.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/fixtures/module_fixture.h"
#include "level_zero/core/test/unit_tests/mocks/mock_module.h"
@@ -283,5 +285,32 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
}
}
using ContextModuleCreateTest = Test<ContextFixture>;
HWTEST_F(ContextModuleCreateTest, givenCallToCreateModuleThenModuleIsReturned) {
std::string testFile;
retrieveBinaryKernelFilename(testFile, "test_kernel_", ".bin");
size_t size = 0;
auto src = loadDataFromFile(testFile.c_str(), size);
ASSERT_NE(0u, size);
ASSERT_NE(nullptr, src);
ze_module_desc_t moduleDesc = {ZE_MODULE_DESC_VERSION_CURRENT};
moduleDesc.format = ZE_MODULE_FORMAT_NATIVE;
moduleDesc.pInputModule = reinterpret_cast<const uint8_t *>(src.get());
moduleDesc.inputSize = size;
ze_module_handle_t hModule;
ze_device_handle_t hDevice = device->toHandle();
ze_result_t res = context->createModule(hDevice, &moduleDesc, &hModule, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
L0::Module *pModule = L0::Module::fromHandle(hModule);
res = pModule->destroy();
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
}
} // namespace ult
} // namespace L0

23
level_zero/core/test/unit_tests/sources/sampler/test_sampler.cpp
View File

@@ -151,5 +151,28 @@ INSTANTIATE_TEST_CASE_P(SamplerDescCombinations, SamplerCreateTest,
samplerFilterMode,
samplerIsNormalized));
using ContextCreateSamplerTest = Test<ContextFixture>;
HWTEST2_F(ContextCreateSamplerTest, givenDifferentDescriptorValuesThenSamplerIsCorrectlyCreated, SamplerCreateSupport) {
ze_sampler_address_mode_t addressMode = ZE_SAMPLER_ADDRESS_MODE_NONE;
ze_sampler_filter_mode_t filterMode = ZE_SAMPLER_FILTER_MODE_LINEAR;
ze_bool_t isNormalized = false;
ze_sampler_desc_t desc = {};
desc.version = ZE_SAMPLER_DESC_VERSION_CURRENT;
desc.addressMode = addressMode;
desc.filterMode = filterMode;
desc.isNormalized = isNormalized;
ze_sampler_handle_t hSampler;
ze_result_t res = context->createSampler(device, &desc, &hSampler);
EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto sampler = reinterpret_cast<L0::SamplerImp *>(L0::Sampler::fromHandle(hSampler));
EXPECT_NE(nullptr, sampler);
sampler->destroy();
}
} // namespace ult
} // namespace L0

186
third_party/level_zero/ze_api_ext.h vendored
View File

@@ -735,6 +735,192 @@ zeMemGetIpcHandle(
ze_ipc_mem_handle_t *pIpcHandle ///< [out] Returned IPC memory handle
);
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates a module on the context.
///
/// @details
/// - Compiles the module for execution on the device.
/// - The application must only use the module for the device, or its
/// sub-devices, which was provided during creation.
/// - The module can be copied to other devices and contexts within the same
/// driver instance by using ::zeModuleGetNativeBinary.
/// - A build log can optionally be returned to the caller. The caller is
/// responsible for destroying build log using ::zeModuleBuildLogDestroy.
/// - The module descriptor constants are only supported for SPIR-V
/// specialization constants.
/// - The application may call this function from simultaneous threads.
/// - The implementation of this function must be thread-safe.
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
/// - ::ZE_RESULT_ERROR_UNINITIALIZED
/// - ::ZE_RESULT_ERROR_DEVICE_LOST
/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
/// + `nullptr == hContext`
/// + `nullptr == hDevice`
/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
/// + `nullptr == desc`
/// + `nullptr == desc->pInputModule`
/// + `nullptr == phModule`
/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
/// + `::ZE_MODULE_FORMAT_NATIVE < desc->format`
/// - ::ZE_RESULT_ERROR_INVALID_NATIVE_BINARY
/// - ::ZE_RESULT_ERROR_INVALID_SIZE
/// + `0 == desc->inputSize`
/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
/// - ::ZE_RESULT_ERROR_MODULE_BUILD_FAILURE
ZE_APIEXPORT ze_result_t ZE_APICALL
zeModuleCreateExt(
ze_context_handle_t hContext, ///< [in] handle of the context object
ze_device_handle_t hDevice, ///< [in] handle of the device
const ze_module_desc_t *desc, ///< [in] pointer to module descriptor
ze_module_handle_t *phModule, ///< [out] pointer to handle of module object created
ze_module_build_log_handle_t *phBuildLog ///< [out][optional] pointer to handle of module's build log.
);
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates sampler on the context.
///
/// @details
/// - The application must only use the sampler for the device, or its
/// sub-devices, which was provided during creation.
/// - The application may call this function from simultaneous threads.
/// - The implementation of this function must be thread-safe.
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
/// - ::ZE_RESULT_ERROR_UNINITIALIZED
/// - ::ZE_RESULT_ERROR_DEVICE_LOST
/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
/// + `nullptr == hContext`
/// + `nullptr == hDevice`
/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
/// + `nullptr == desc`
/// + `nullptr == phSampler`
/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
/// + `::ZE_SAMPLER_ADDRESS_MODE_MIRROR < desc->addressMode`
/// + `::ZE_SAMPLER_FILTER_MODE_LINEAR < desc->filterMode`
/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
ZE_APIEXPORT ze_result_t ZE_APICALL
zeSamplerCreateExt(
ze_context_handle_t hContext, ///< [in] handle of the context object
ze_device_handle_t hDevice, ///< [in] handle of the device
const ze_sampler_desc_t *desc, ///< [in] pointer to sampler descriptor
ze_sampler_handle_t *phSampler ///< [out] handle of the sampler
);
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates a command queue on the context.
///
/// @details
/// - A command queue represents a logical input stream to the device, tied
/// to a physical input stream.
/// - The application must only use the command queue for the device, or its
/// sub-devices, which was provided during creation.
/// - The application may call this function from simultaneous threads.
/// - The implementation of this function must be thread-safe.
///
/// @remarks
/// _Analogues_
/// - **clCreateCommandQueue**
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
/// - ::ZE_RESULT_ERROR_UNINITIALIZED
/// - ::ZE_RESULT_ERROR_DEVICE_LOST
/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
/// + `nullptr == hContext`
/// + `nullptr == hDevice`
/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
/// + `nullptr == desc`
/// + `nullptr == phCommandQueue`
/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
/// + `0x1 < desc->flags`
/// + `::ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS < desc->mode`
/// + `::ZE_COMMAND_QUEUE_PRIORITY_PRIORITY_HIGH < desc->priority`
/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandQueueCreateExt(
ze_context_handle_t hContext, ///< [in] handle of the context object
ze_device_handle_t hDevice, ///< [in] handle of the device object
const ze_command_queue_desc_t *desc, ///< [in] pointer to command queue descriptor
ze_command_queue_handle_t *phCommandQueue ///< [out] pointer to handle of command queue object created
);
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates a command list on the context.
///
/// @details
/// - A command list represents a sequence of commands for execution on a
/// command queue.
/// - The command list is created in the 'open' state.
/// - The application must only use the command list for the device, or its
/// sub-devices, which was provided during creation.
/// - The application may call this function from simultaneous threads.
/// - The implementation of this function must be thread-safe.
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
/// - ::ZE_RESULT_ERROR_UNINITIALIZED
/// - ::ZE_RESULT_ERROR_DEVICE_LOST
/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
/// + `nullptr == hContext`
/// + `nullptr == hDevice`
/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
/// + `nullptr == desc`
/// + `nullptr == phCommandList`
/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
/// + `0x7 < desc->flags`
/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreateExt(
ze_context_handle_t hContext, ///< [in] handle of the context object
ze_device_handle_t hDevice, ///< [in] handle of the device object
const ze_command_list_desc_t *desc, ///< [in] pointer to command list descriptor
ze_command_list_handle_t *phCommandList ///< [out] pointer to handle of command list object created
);
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates an immediate command list on the context.
///
/// @details
/// - An immediate command list is used for low-latency submission of
/// commands.
/// - An immediate command list creates an implicit command queue.
/// - The command list is created in the 'open' state and never needs to be
/// closed.
/// - The application must only use the command list for the device, or its
/// sub-devices, which was provided during creation.
/// - The application may call this function from simultaneous threads.
/// - The implementation of this function must be thread-safe.
///
/// @returns
/// - ::ZE_RESULT_SUCCESS
/// - ::ZE_RESULT_ERROR_UNINITIALIZED
/// - ::ZE_RESULT_ERROR_DEVICE_LOST
/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
/// + `nullptr == hContext`
/// + `nullptr == hDevice`
/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
/// + `nullptr == altdesc`
/// + `nullptr == phCommandList`
/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION
/// + `0x1 < altdesc->flags`
/// + `::ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS < altdesc->mode`
/// + `::ZE_COMMAND_QUEUE_PRIORITY_PRIORITY_HIGH < altdesc->priority`
/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
ZE_APIEXPORT ze_result_t ZE_APICALL
zeCommandListCreateImmediateExt(
ze_context_handle_t hContext, ///< [in] handle of the context object
ze_device_handle_t hDevice, ///< [in] handle of the device object
const ze_command_queue_desc_t *altdesc, ///< [in] pointer to command queue descriptor
ze_command_list_handle_t *phCommandList ///< [out] pointer to handle of command list object created
);
} //extern C
#endif // _ZE_API_EXT_H