/*

* Copyright (C) 2024-2025 Intel Corporation

*

* Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.

* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

*/

#include "utils_level_zero.h"

#include <memory>

#include <stdlib.h>

#include "utils_concurrency.h"

#include "utils_load_library.h"

struct libze_ops {

ze_result_t (*zeInit)(ze_init_flags_t flags);

ze_result_t (*zeDriverGet)(uint32_t *pCount, ze_driver_handle_t *phDrivers);

ze_result_t (*zeDeviceGet)(ze_driver_handle_t hDriver, uint32_t *pCount,

ze_device_handle_t *phDevices);

ze_result_t (*zeDeviceGetProperties)(

ze_device_handle_t hDevice, ze_device_properties_t *pDeviceProperties);

ze_result_t (*zeContextCreate)(ze_driver_handle_t hDriver,

const ze_context_desc_t *desc,

ze_context_handle_t *phContext);

ze_result_t (*zeContextDestroy)(ze_context_handle_t hContext);

ze_result_t (*zeCommandQueueCreate)(

ze_context_handle_t hContext, ze_device_handle_t hDevice,

const ze_command_queue_desc_t *desc,

ze_command_queue_handle_t *phCommandQueue);

ze_result_t (*zeCommandQueueDestroy)(

ze_command_queue_handle_t hCommandQueue);

ze_result_t (*zeCommandQueueExecuteCommandLists)(

ze_command_queue_handle_t hCommandQueue, uint32_t numCommandLists,

ze_command_list_handle_t *phCommandLists, ze_fence_handle_t hFence);

ze_result_t (*zeCommandQueueSynchronize)(

ze_command_queue_handle_t hCommandQueue, uint64_t timeout);

ze_result_t (*zeCommandListCreate)(ze_context_handle_t hContext,

ze_device_handle_t hDevice,

const ze_command_list_desc_t *desc,

ze_command_list_handle_t *phCommandList);

ze_result_t (*zeCommandListDestroy)(ze_command_list_handle_t hCommandList);

ze_result_t (*zeCommandListClose)(ze_command_list_handle_t hCommandList);

ze_result_t (*zeCommandListAppendMemoryCopy)(

ze_command_list_handle_t hCommandList, void *dstptr, const void *srcptr,

size_t size, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,

ze_event_handle_t *phWaitEvents);

ze_result_t (*zeCommandListAppendMemoryFill)(

ze_command_list_handle_t hCommandList, void *ptr, const void *pattern,

size_t pattern_size, size_t size, ze_event_handle_t hSignalEvent,

uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents);

ze_result_t (*zeMemGetAllocProperties)(

ze_context_handle_t hContext, const void *ptr,

ze_memory_allocation_properties_t *pMemAllocProperties,

ze_device_handle_t *phDevice);

ze_result_t (*zeMemAllocDevice)(ze_context_handle_t,

const ze_device_mem_alloc_desc_t *, size_t,

size_t, ze_device_handle_t, void **);

ze_result_t (*zeMemFree)(ze_context_handle_t, void *);

ze_result_t (*zeDeviceGetMemoryProperties)(

ze_device_handle_t hDevice, uint32_t *pCount,

ze_device_memory_properties_t *pMemProperties);

} libze_ops;

#if USE_DLOPEN

// Generic no-op stub function for all callbacks

template <typename... Args> ze_result_t noop_stub(Args &&...) {

return ZE_RESULT_SUCCESS; // Always return ZE_RESULT_SUCCESS

}

struct DlHandleCloser {

void operator()(void *dlHandle) {

if (dlHandle) {

// Reset all function pointers to no-op stubs in case the library

// but some other global object still try to call Level Zero functions.

libze_ops.zeInit = [](auto... args) { return noop_stub(args...); };

libze_ops.zeDriverGet = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeDeviceGet = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeDeviceGetProperties = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeContextCreate = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeContextDestroy = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeCommandQueueCreate = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeCommandQueueDestroy = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeCommandQueueExecuteCommandLists = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeCommandQueueSynchronize = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeCommandListCreate = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeCommandListDestroy = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeCommandListClose = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeCommandListAppendMemoryCopy = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeCommandListAppendMemoryFill = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeMemGetAllocProperties = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeMemAllocDevice = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeMemFree = [](auto... args) {

return noop_stub(args...);

};

libze_ops.zeDeviceGetMemoryProperties = [](auto... args) {

return noop_stub(args...);

};

utils_close_library(dlHandle);

}

}

};

std::unique_ptr<void, DlHandleCloser> zeDlHandle = nullptr;

int InitLevelZeroOps() {

#ifdef _WIN32

const char *lib_name = "ze_loader.dll";

#else

const char *lib_name = "libze_loader.so.1";

#endif

// Load Level Zero symbols

#if OPEN_ZE_LIBRARY_GLOBAL

// NOTE UMF_UTIL_OPEN_LIBRARY_GLOBAL adds all loaded symbols to the

// global symbol table.

int open_flags = UMF_UTIL_OPEN_LIBRARY_GLOBAL;

#else

int open_flags = 0;

#endif

zeDlHandle = std::unique_ptr<void, DlHandleCloser>(

utils_open_library(lib_name, open_flags));

*(void **)&libze_ops.zeInit =

utils_get_symbol_addr(zeDlHandle.get(), "zeInit", lib_name);

if (libze_ops.zeInit == nullptr) {

fprintf(stderr, "zeInit symbol not found in %s\n", lib_name);

return -1;

}

*(void **)&libze_ops.zeDriverGet =

utils_get_symbol_addr(zeDlHandle.get(), "zeDriverGet", lib_name);

if (libze_ops.zeDriverGet == nullptr) {

fprintf(stderr, "zeDriverGet symbol not found in %s\n", lib_name);

return -1;

}

*(void **)&libze_ops.zeDeviceGet =

utils_get_symbol_addr(zeDlHandle.get(), "zeDeviceGet", lib_name);

if (libze_ops.zeDeviceGet == nullptr) {

fprintf(stderr, "zeDeviceGet symbol not found in %s\n", lib_name);

return -1;

}

*(void **)&libze_ops.zeDeviceGetProperties = utils_get_symbol_addr(

zeDlHandle.get(), "zeDeviceGetProperties", lib_name);

if (libze_ops.zeDeviceGetProperties == nullptr) {

fprintf(stderr, "zeDeviceGetProperties symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeContextCreate =

utils_get_symbol_addr(zeDlHandle.get(), "zeContextCreate", lib_name);

if (libze_ops.zeContextCreate == nullptr) {

fprintf(stderr, "zeContextCreate symbol not found in %s\n", lib_name);

return -1;

}

*(void **)&libze_ops.zeContextDestroy =

utils_get_symbol_addr(zeDlHandle.get(), "zeContextDestroy", lib_name);

if (libze_ops.zeContextDestroy == nullptr) {

fprintf(stderr, "zeContextDestroy symbol not found in %s\n", lib_name);

return -1;

}

*(void **)&libze_ops.zeCommandQueueCreate = utils_get_symbol_addr(

zeDlHandle.get(), "zeCommandQueueCreate", lib_name);

if (libze_ops.zeCommandQueueCreate == nullptr) {

fprintf(stderr, "zeCommandQueueCreate symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeCommandQueueDestroy = utils_get_symbol_addr(

zeDlHandle.get(), "zeCommandQueueDestroy", lib_name);

if (libze_ops.zeCommandQueueDestroy == nullptr) {

fprintf(stderr, "zeCommandQueueDestroy symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeCommandQueueExecuteCommandLists =

utils_get_symbol_addr(zeDlHandle.get(),

"zeCommandQueueExecuteCommandLists", lib_name);

if (libze_ops.zeCommandQueueExecuteCommandLists == nullptr) {

fprintf(stderr,

"zeCommandQueueExecuteCommandLists symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeCommandQueueSynchronize = utils_get_symbol_addr(

zeDlHandle.get(), "zeCommandQueueSynchronize", lib_name);

if (libze_ops.zeCommandQueueSynchronize == nullptr) {

fprintf(stderr, "zeCommandQueueSynchronize symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeCommandListCreate = utils_get_symbol_addr(

zeDlHandle.get(), "zeCommandListCreate", lib_name);

if (libze_ops.zeCommandListCreate == nullptr) {

fprintf(stderr, "zeCommandListCreate symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeCommandListDestroy = utils_get_symbol_addr(

zeDlHandle.get(), "zeCommandListDestroy", lib_name);

if (libze_ops.zeCommandListDestroy == nullptr) {

fprintf(stderr, "zeCommandListDestroy symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeCommandListClose =

utils_get_symbol_addr(zeDlHandle.get(), "zeCommandListClose", lib_name);

if (libze_ops.zeCommandListClose == nullptr) {

fprintf(stderr, "zeCommandListClose symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeCommandListAppendMemoryCopy = utils_get_symbol_addr(

zeDlHandle.get(), "zeCommandListAppendMemoryCopy", lib_name);

if (libze_ops.zeCommandListAppendMemoryCopy == nullptr) {

fprintf(stderr,

"zeCommandListAppendMemoryCopy symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeCommandListAppendMemoryFill = utils_get_symbol_addr(

zeDlHandle.get(), "zeCommandListAppendMemoryFill", lib_name);

if (libze_ops.zeCommandListAppendMemoryFill == nullptr) {

fprintf(stderr,

"zeCommandListAppendMemoryFill symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeMemGetAllocProperties = utils_get_symbol_addr(

zeDlHandle.get(), "zeMemGetAllocProperties", lib_name);

if (libze_ops.zeMemGetAllocProperties == nullptr) {

fprintf(stderr, "zeMemGetAllocProperties symbol not found in %s\n",

lib_name);

return -1;

}

*(void **)&libze_ops.zeMemAllocDevice =

utils_get_symbol_addr(zeDlHandle.get(), "zeMemAllocDevice", lib_name);

if (libze_ops.zeMemAllocDevice == nullptr) {

fprintf(stderr, "zeMemAllocDevice symbol not found in %s\n", lib_name);

return -1;

}

*(void **)&libze_ops.zeMemFree =

utils_get_symbol_addr(zeDlHandle.get(), "zeMemFree", lib_name);

if (libze_ops.zeMemFree == nullptr) {

fprintf(stderr, "zeMemFree symbol not found in %s\n", lib_name);

return -1;

}

*(void **)&libze_ops.zeDeviceGetMemoryProperties = utils_get_symbol_addr(

zeDlHandle.get(), "zeDeviceGetMemoryProperties", lib_name);

if (libze_ops.zeDeviceGetMemoryProperties == nullptr) {

fprintf(stderr, "zeDeviceGetMemoryProperties symbol not found in %s\n",

lib_name);

return -1;

}

return 0;

}

#else // USE_DLOPEN

int InitLevelZeroOps() {

// Level Zero is linked statically but we prepare ops structure to

// make test code consistent

libze_ops.zeInit = zeInit;

libze_ops.zeDriverGet = zeDriverGet;

libze_ops.zeDeviceGet = zeDeviceGet;

libze_ops.zeDeviceGetProperties = zeDeviceGetProperties;

libze_ops.zeContextCreate = zeContextCreate;

libze_ops.zeContextDestroy = zeContextDestroy;

libze_ops.zeCommandQueueCreate = zeCommandQueueCreate;

libze_ops.zeCommandQueueDestroy = zeCommandQueueDestroy;

libze_ops.zeCommandQueueExecuteCommandLists =

zeCommandQueueExecuteCommandLists;

libze_ops.zeCommandQueueSynchronize = zeCommandQueueSynchronize;

libze_ops.zeCommandListCreate = zeCommandListCreate;

libze_ops.zeCommandListDestroy = zeCommandListDestroy;

libze_ops.zeCommandListClose = zeCommandListClose;

libze_ops.zeCommandListAppendMemoryCopy = zeCommandListAppendMemoryCopy;

libze_ops.zeCommandListAppendMemoryFill = zeCommandListAppendMemoryFill;

libze_ops.zeMemGetAllocProperties = zeMemGetAllocProperties;

libze_ops.zeMemAllocDevice = zeMemAllocDevice;

libze_ops.zeMemFree = zeMemFree;

libze_ops.zeDeviceGetMemoryProperties = zeDeviceGetMemoryProperties;

return 0;

}

#endif // USE_DLOPEN

static int utils_ze_init_level_zero_lib(void) {

ze_init_flag_t flags = ZE_INIT_FLAG_GPU_ONLY;

ze_result_t result = libze_ops.zeInit(flags);

if (result != ZE_RESULT_SUCCESS) {

return -1;

}

return 0;

}

static UTIL_ONCE_FLAG level_zero_init_flag = UTIL_ONCE_FLAG_INIT;

static int InitResult;

static void utils_ze_init_level_zero_once(void) {

InitResult = InitLevelZeroOps();

if (InitResult != 0) {

return;

}

InitResult = utils_ze_init_level_zero_lib();

}

int utils_ze_init_level_zero(void) {

utils_init_once(&level_zero_init_flag, utils_ze_init_level_zero_once);

return InitResult;

}

int utils_ze_get_drivers(uint32_t *drivers_num_,

ze_driver_handle_t **drivers_) {

int ret = 0;

ze_result_t ze_result;

ze_driver_handle_t *drivers = NULL;

uint32_t drivers_num = 0;

ze_result = libze_ops.zeDriverGet(&drivers_num, NULL);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeDriverGet() failed!\n");

ret = -1;

goto fn_fail;

}

if (drivers_num == 0) {

goto fn_exit;

}

drivers =

(ze_driver_handle_t *)malloc(drivers_num * sizeof(ze_driver_handle_t));

if (!drivers) {

ret = -1;

goto fn_fail;

}

ze_result = libze_ops.zeDriverGet(&drivers_num, drivers);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeDriverGet() failed!\n");

ret = -1;

goto fn_fail;

}

fn_exit:

*drivers_num_ = drivers_num;

*drivers_ = drivers;

return ret;

fn_fail:

*drivers_num_ = 0;

if (drivers) {

free(drivers);

*drivers_ = NULL;

}

return ret;

}

int utils_ze_get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,

ze_device_handle_t **devices_) {

ze_result_t ze_result;

int ret = 0;

uint32_t devices_num = 0;

ze_device_handle_t *devices = NULL;

ze_result = libze_ops.zeDeviceGet(driver, &devices_num, NULL);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeDeviceGet() failed!\n");

ret = -1;

goto fn_fail;

}

if (devices_num == 0) {

goto fn_exit;

}

devices =

(ze_device_handle_t *)malloc(devices_num * sizeof(ze_device_handle_t));

if (!devices) {

ret = -1;

goto fn_fail;

}

ze_result = libze_ops.zeDeviceGet(driver, &devices_num, devices);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeDeviceGet() failed!\n");

ret = -1;

goto fn_fail;

}

fn_exit:

*devices_num_ = devices_num;

*devices_ = devices;

return ret;

fn_fail:

devices_num = 0;

if (devices) {

free(devices);

devices = NULL;

}

return ret;

}

int utils_ze_find_driver_with_gpu(uint32_t *driver_idx,

ze_driver_handle_t *driver_) {

int ret = 0;

ze_result_t ze_result;

uint32_t drivers_num = 0;

ze_device_handle_t *devices = NULL;

ze_driver_handle_t *drivers = NULL;

ze_driver_handle_t driver_with_gpus = NULL;

ret = utils_ze_get_drivers(&drivers_num, &drivers);

if (ret) {

goto fn_fail;

}

/* Find a driver with GPU */

for (uint32_t i = 0; i < drivers_num; ++i) {

uint32_t devices_num = 0;

ze_driver_handle_t driver = drivers[i];

ret = utils_ze_get_devices(driver, &devices_num, &devices);

if (ret) {

goto fn_fail;

}

for (uint32_t d = 0; d < devices_num; ++d) {

ze_device_handle_t device = devices[d];

ze_device_properties_t device_properties;

device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;

device_properties.pNext = NULL;

ze_result =

libze_ops.zeDeviceGetProperties(device, &device_properties);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeDeviceGetProperties() failed!\n");

ret = -1;

goto fn_fail;

}

if (device_properties.type == ZE_DEVICE_TYPE_GPU) {

driver_with_gpus = driver;

*driver_idx = i;

break;

}

}

if (devices) {

free(devices);

devices = NULL;

}

if (driver_with_gpus != NULL) {

goto fn_exit;

}

}

fn_fail:

if (devices) {

free(devices);

}

fn_exit:

*driver_ = driver_with_gpus;

if (drivers) {

free(drivers);

}

return ret;

}

int utils_ze_find_gpu_device(ze_driver_handle_t driver,

ze_device_handle_t *device_) {

int ret = -1;

uint32_t devices_num = 0;

ze_device_handle_t *devices = NULL;

ze_device_handle_t device;

ret = utils_ze_get_devices(driver, &devices_num, &devices);

if (ret) {

return ret;

}

for (uint32_t d = 0; d < devices_num; ++d) {

device = devices[d];

ze_device_properties_t device_properties;

device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;

device_properties.pNext = NULL;

ze_result_t ze_result =

libze_ops.zeDeviceGetProperties(device, &device_properties);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeDeviceGetProperties() failed!\n");

ret = -1;

break;

}

if (device_properties.type == ZE_DEVICE_TYPE_GPU) {

*device_ = device;

ret = 0;

break;

}

}

if (devices) {

free(devices);

}

return ret;

}

int utils_ze_level_zero_fill(ze_context_handle_t context,

ze_device_handle_t device, void *ptr, size_t size,

const void *pattern, size_t pattern_size) {

int ret = 0;

ze_command_queue_desc_t commandQueueDesc = {

ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,

NULL,

0,

0,

0,

ZE_COMMAND_QUEUE_MODE_DEFAULT,

ZE_COMMAND_QUEUE_PRIORITY_NORMAL};

ze_command_list_desc_t commandListDesc = {

ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC, 0, 0,

ZE_COMMAND_LIST_FLAG_RELAXED_ORDERING};

ze_command_queue_handle_t hCommandQueue;

ze_result_t ze_result = libze_ops.zeCommandQueueCreate(

context, device, &commandQueueDesc, &hCommandQueue);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandQueueCreate() failed!\n");

return -1;

}

ze_command_list_handle_t hCommandList;

ze_result = libze_ops.zeCommandListCreate(context, device, &commandListDesc,

&hCommandList);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandListCreate() failed!\n");

ret = -1;

goto err_queue_destroy;

}

// fill memory with a pattern

ze_result = libze_ops.zeCommandListAppendMemoryFill(

hCommandList, ptr, pattern, pattern_size, size, NULL, 0, NULL);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandListAppendMemoryFill() failed!\n");

ret = -1;

goto err_list_destroy;

}

// close and execute the command list

ze_result = libze_ops.zeCommandListClose(hCommandList);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandListClose() failed!\n");

ret = -1;

goto err_list_destroy;

}

ze_result = libze_ops.zeCommandQueueExecuteCommandLists(

hCommandQueue, 1, &hCommandList, NULL);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandQueueExecuteCommandLists() failed!\n");

ret = -1;

goto err_list_destroy;

}

// sync

ze_result = libze_ops.zeCommandQueueSynchronize(hCommandQueue, UINT64_MAX);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandQueueSynchronize() failed!\n");

ret = -1;

goto err_list_destroy;

}

// cleanup

err_list_destroy:

ze_result = libze_ops.zeCommandListDestroy(hCommandList);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandListDestroy() failed!\n");

ret = -1;

}

err_queue_destroy:

ze_result = libze_ops.zeCommandQueueDestroy(hCommandQueue);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandQueueDestroy() failed!\n");

ret = -1;

}

return ret;

}

int utils_ze_level_zero_copy(ze_context_handle_t context,

ze_device_handle_t device, void *dst_ptr,

const void *src_ptr, size_t size) {

int ret = 0;

ze_command_queue_desc_t commandQueueDesc = {

ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,

NULL,

0,

0,

0,

ZE_COMMAND_QUEUE_MODE_DEFAULT,

ZE_COMMAND_QUEUE_PRIORITY_NORMAL};

ze_command_list_desc_t commandListDesc = {

ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC, 0, 0,

ZE_COMMAND_LIST_FLAG_RELAXED_ORDERING};

ze_command_queue_handle_t hCommandQueue;

ze_result_t ze_result = libze_ops.zeCommandQueueCreate(

context, device, &commandQueueDesc, &hCommandQueue);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandQueueCreate() failed!\n");

return -1;

}

ze_command_list_handle_t hCommandList;

ze_result = libze_ops.zeCommandListCreate(context, device, &commandListDesc,

&hCommandList);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandListCreate() failed!\n");

ret = -1;

goto err_queue_destroy;

}

// copy from device memory to host memory

ze_result = libze_ops.zeCommandListAppendMemoryCopy(

hCommandList, dst_ptr, src_ptr, size, NULL, 0, NULL);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandListAppendMemoryCopy() failed!\n");

ret = -1;

goto err_list_destroy;

}

// close and execute the command list

ze_result = libze_ops.zeCommandListClose(hCommandList);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandListClose() failed!\n");

ret = -1;

goto err_list_destroy;

}

ze_result = libze_ops.zeCommandQueueExecuteCommandLists(

hCommandQueue, 1, &hCommandList, NULL);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandQueueExecuteCommandLists() failed!\n");

ret = -1;

goto err_list_destroy;

}

ze_result = libze_ops.zeCommandQueueSynchronize(hCommandQueue, UINT64_MAX);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandQueueSynchronize() failed!\n");

ret = -1;

goto err_list_destroy;

}

// cleanup

err_list_destroy:

ze_result = libze_ops.zeCommandListDestroy(hCommandList);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandListDestroy() failed!\n");

ret = -1;

}

err_queue_destroy:

ze_result = libze_ops.zeCommandQueueDestroy(hCommandQueue);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeCommandQueueDestroy() failed!\n");

ret = -1;

}

return ret;

}

int utils_ze_create_context(ze_driver_handle_t driver,

ze_context_handle_t *context) {

ze_result_t ze_result;

ze_context_desc_t ctxtDesc;

ctxtDesc.stype = ZE_STRUCTURE_TYPE_CONTEXT_DESC;

ctxtDesc.pNext = NULL;

ctxtDesc.flags = 0;

ze_result = libze_ops.zeContextCreate(driver, &ctxtDesc, context);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeContextCreate() failed!\n");

return -1;

}

return 0;

}

int utils_ze_destroy_context(ze_context_handle_t context) {

ze_result_t ze_result;

ze_result = libze_ops.zeContextDestroy(context);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeContextDestroy() failed!\n");

return -1;

}

return 0;

}

ze_memory_type_t utils_ze_get_mem_type(ze_context_handle_t context, void *ptr) {

ze_device_handle_t device = NULL;

ze_memory_allocation_properties_t alloc_props;

alloc_props.stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES;

alloc_props.pNext = NULL;

alloc_props.type = ZE_MEMORY_TYPE_UNKNOWN;

alloc_props.id = 0;

alloc_props.pageSize = 0;

libze_ops.zeMemGetAllocProperties(context, ptr, &alloc_props, &device);

return alloc_props.type;

}

int64_t utils_ze_get_num_memory_properties(ze_device_handle_t device) {

uint32_t pCount = 0;

ze_result_t ze_result =

libze_ops.zeDeviceGetMemoryProperties(device, &pCount, nullptr);

if (ze_result != ZE_RESULT_SUCCESS) {

fprintf(stderr, "zeDeviceGetMemoryProperties() failed!\n");

return -1;

}

return static_cast<int64_t>(pCount);

}