800d949bb3
Implement the complete initial version of the Offload API, to the extent that is usable for simple offloading programs. Tested with a basic SYCL program. As far as possible, these are simple wrappers over existing functionality in the plugins. * Allocating and freeing memory (host, device, shared). * Creating a program * Creating a queue (wrapper over asynchronous stream resource) * Enqueuing memcpy operations * Enqueuing kernel executions * Waiting on (optional) output events from the enqueue operations * Waiting on a queue to finish Objects created with the API have reference counting semantics to handle their lifetime. They are created with an initial reference count of 1, which can be incremented and decremented with retain and release functions. They are freed when their reference count reaches 0. Platform and device objects are not reference counted, as they are expected to persist as long as the library is in use, and it's not meaningful for users to create or destroy them. Tests have been added to `offload.unittests`, including device code for testing program and kernel related functionality. The API should still be considered unstable and it's very likely we will need to change the existing entry points.
861 lines
29 KiB
C++
861 lines
29 KiB
C++
//===- Auto-generated file, part of the LLVM/Offload project --------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olInit_val() {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
}
|
|
|
|
return llvm::offload::olInit_impl();
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olInit() {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olInit";
|
|
}
|
|
|
|
ol_result_t Result = olInit_val();
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "()";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olInitWithCodeLoc(ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olInit();
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olShutDown_val() {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
}
|
|
|
|
return llvm::offload::olShutDown_impl();
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olShutDown() {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olShutDown";
|
|
}
|
|
|
|
ol_result_t Result = olShutDown_val();
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "()";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olShutDownWithCodeLoc(ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olShutDown();
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olGetPlatformInfo_val(ol_platform_handle_t Platform,
|
|
ol_platform_info_t PropName,
|
|
size_t PropSize, void *PropValue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (PropSize == 0) {
|
|
return OL_ERRC_INVALID_SIZE;
|
|
}
|
|
|
|
if (NULL == Platform) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == PropValue) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olGetPlatformInfo_impl(Platform, PropName, PropSize,
|
|
PropValue);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL
|
|
olGetPlatformInfo(ol_platform_handle_t Platform, ol_platform_info_t PropName,
|
|
size_t PropSize, void *PropValue) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olGetPlatformInfo";
|
|
}
|
|
|
|
ol_result_t Result =
|
|
olGetPlatformInfo_val(Platform, PropName, PropSize, PropValue);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_get_platform_info_params_t Params = {&Platform, &PropName, &PropSize,
|
|
&PropValue};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olGetPlatformInfoWithCodeLoc(ol_platform_handle_t Platform,
|
|
ol_platform_info_t PropName,
|
|
size_t PropSize, void *PropValue,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result =
|
|
::olGetPlatformInfo(Platform, PropName, PropSize, PropValue);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olGetPlatformInfoSize_val(ol_platform_handle_t Platform,
|
|
ol_platform_info_t PropName,
|
|
size_t *PropSizeRet) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Platform) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == PropSizeRet) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olGetPlatformInfoSize_impl(Platform, PropName,
|
|
PropSizeRet);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL
|
|
olGetPlatformInfoSize(ol_platform_handle_t Platform,
|
|
ol_platform_info_t PropName, size_t *PropSizeRet) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olGetPlatformInfoSize";
|
|
}
|
|
|
|
ol_result_t Result =
|
|
olGetPlatformInfoSize_val(Platform, PropName, PropSizeRet);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_get_platform_info_size_params_t Params = {&Platform, &PropName,
|
|
&PropSizeRet};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olGetPlatformInfoSizeWithCodeLoc(ol_platform_handle_t Platform,
|
|
ol_platform_info_t PropName,
|
|
size_t *PropSizeRet,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olGetPlatformInfoSize(Platform, PropName, PropSizeRet);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olIterateDevices_val(ol_device_iterate_cb_t Callback,
|
|
void *UserData) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
}
|
|
|
|
return llvm::offload::olIterateDevices_impl(Callback, UserData);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL
|
|
olIterateDevices(ol_device_iterate_cb_t Callback, void *UserData) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olIterateDevices";
|
|
}
|
|
|
|
ol_result_t Result = olIterateDevices_val(Callback, UserData);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_iterate_devices_params_t Params = {&Callback, &UserData};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olIterateDevicesWithCodeLoc(ol_device_iterate_cb_t Callback,
|
|
void *UserData,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olIterateDevices(Callback, UserData);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olGetDeviceInfo_val(ol_device_handle_t Device,
|
|
ol_device_info_t PropName, size_t PropSize,
|
|
void *PropValue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (PropSize == 0) {
|
|
return OL_ERRC_INVALID_SIZE;
|
|
}
|
|
|
|
if (NULL == Device) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == PropValue) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olGetDeviceInfo_impl(Device, PropName, PropSize,
|
|
PropValue);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olGetDeviceInfo(ol_device_handle_t Device,
|
|
ol_device_info_t PropName,
|
|
size_t PropSize,
|
|
void *PropValue) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olGetDeviceInfo";
|
|
}
|
|
|
|
ol_result_t Result =
|
|
olGetDeviceInfo_val(Device, PropName, PropSize, PropValue);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_get_device_info_params_t Params = {&Device, &PropName, &PropSize,
|
|
&PropValue};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olGetDeviceInfoWithCodeLoc(ol_device_handle_t Device,
|
|
ol_device_info_t PropName,
|
|
size_t PropSize, void *PropValue,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olGetDeviceInfo(Device, PropName, PropSize, PropValue);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olGetDeviceInfoSize_val(ol_device_handle_t Device,
|
|
ol_device_info_t PropName,
|
|
size_t *PropSizeRet) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Device) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == PropSizeRet) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olGetDeviceInfoSize_impl(Device, PropName, PropSizeRet);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olGetDeviceInfoSize(
|
|
ol_device_handle_t Device, ol_device_info_t PropName, size_t *PropSizeRet) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olGetDeviceInfoSize";
|
|
}
|
|
|
|
ol_result_t Result = olGetDeviceInfoSize_val(Device, PropName, PropSizeRet);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_get_device_info_size_params_t Params = {&Device, &PropName,
|
|
&PropSizeRet};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olGetDeviceInfoSizeWithCodeLoc(ol_device_handle_t Device,
|
|
ol_device_info_t PropName,
|
|
size_t *PropSizeRet,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olGetDeviceInfoSize(Device, PropName, PropSizeRet);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olMemAlloc_val(ol_device_handle_t Device, ol_alloc_type_t Type,
|
|
size_t Size, void **AllocationOut) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (Size == 0) {
|
|
return OL_ERRC_INVALID_SIZE;
|
|
}
|
|
|
|
if (NULL == Device) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == AllocationOut) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olMemAlloc_impl(Device, Type, Size, AllocationOut);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olMemAlloc(ol_device_handle_t Device,
|
|
ol_alloc_type_t Type,
|
|
size_t Size,
|
|
void **AllocationOut) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olMemAlloc";
|
|
}
|
|
|
|
ol_result_t Result = olMemAlloc_val(Device, Type, Size, AllocationOut);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_mem_alloc_params_t Params = {&Device, &Type, &Size, &AllocationOut};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olMemAllocWithCodeLoc(ol_device_handle_t Device,
|
|
ol_alloc_type_t Type, size_t Size,
|
|
void **AllocationOut,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olMemAlloc(Device, Type, Size, AllocationOut);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olMemFree_val(void *Address) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Address) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olMemFree_impl(Address);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olMemFree(void *Address) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olMemFree";
|
|
}
|
|
|
|
ol_result_t Result = olMemFree_val(Address);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_mem_free_params_t Params = {&Address};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olMemFreeWithCodeLoc(void *Address,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olMemFree(Address);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olMemcpy_val(ol_queue_handle_t Queue, void *DstPtr,
|
|
ol_device_handle_t DstDevice, void *SrcPtr,
|
|
ol_device_handle_t SrcDevice, size_t Size,
|
|
ol_event_handle_t *EventOut) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (Queue == NULL && EventOut != NULL) {
|
|
return OL_ERRC_INVALID_ARGUMENT;
|
|
}
|
|
|
|
if (NULL == DstDevice) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == SrcDevice) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == DstPtr) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
|
|
if (NULL == SrcPtr) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olMemcpy_impl(Queue, DstPtr, DstDevice, SrcPtr,
|
|
SrcDevice, Size, EventOut);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL
|
|
olMemcpy(ol_queue_handle_t Queue, void *DstPtr, ol_device_handle_t DstDevice,
|
|
void *SrcPtr, ol_device_handle_t SrcDevice, size_t Size,
|
|
ol_event_handle_t *EventOut) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olMemcpy";
|
|
}
|
|
|
|
ol_result_t Result =
|
|
olMemcpy_val(Queue, DstPtr, DstDevice, SrcPtr, SrcDevice, Size, EventOut);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_memcpy_params_t Params = {&Queue, &DstPtr, &DstDevice, &SrcPtr,
|
|
&SrcDevice, &Size, &EventOut};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olMemcpyWithCodeLoc(ol_queue_handle_t Queue, void *DstPtr,
|
|
ol_device_handle_t DstDevice, void *SrcPtr,
|
|
ol_device_handle_t SrcDevice, size_t Size,
|
|
ol_event_handle_t *EventOut,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result =
|
|
::olMemcpy(Queue, DstPtr, DstDevice, SrcPtr, SrcDevice, Size, EventOut);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olCreateQueue_val(ol_device_handle_t Device,
|
|
ol_queue_handle_t *Queue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Device) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == Queue) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olCreateQueue_impl(Device, Queue);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olCreateQueue(ol_device_handle_t Device,
|
|
ol_queue_handle_t *Queue) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olCreateQueue";
|
|
}
|
|
|
|
ol_result_t Result = olCreateQueue_val(Device, Queue);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_create_queue_params_t Params = {&Device, &Queue};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olCreateQueueWithCodeLoc(ol_device_handle_t Device,
|
|
ol_queue_handle_t *Queue,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olCreateQueue(Device, Queue);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olDestroyQueue_val(ol_queue_handle_t Queue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Queue) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olDestroyQueue_impl(Queue);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olDestroyQueue(ol_queue_handle_t Queue) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olDestroyQueue";
|
|
}
|
|
|
|
ol_result_t Result = olDestroyQueue_val(Queue);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_destroy_queue_params_t Params = {&Queue};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olDestroyQueueWithCodeLoc(ol_queue_handle_t Queue,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olDestroyQueue(Queue);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olWaitQueue_val(ol_queue_handle_t Queue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Queue) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olWaitQueue_impl(Queue);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olWaitQueue(ol_queue_handle_t Queue) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olWaitQueue";
|
|
}
|
|
|
|
ol_result_t Result = olWaitQueue_val(Queue);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_wait_queue_params_t Params = {&Queue};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olWaitQueueWithCodeLoc(ol_queue_handle_t Queue,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olWaitQueue(Queue);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olDestroyEvent_val(ol_event_handle_t Event) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Event) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olDestroyEvent_impl(Event);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olDestroyEvent(ol_event_handle_t Event) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olDestroyEvent";
|
|
}
|
|
|
|
ol_result_t Result = olDestroyEvent_val(Event);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_destroy_event_params_t Params = {&Event};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olDestroyEventWithCodeLoc(ol_event_handle_t Event,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olDestroyEvent(Event);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olWaitEvent_val(ol_event_handle_t Event) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Event) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olWaitEvent_impl(Event);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olWaitEvent(ol_event_handle_t Event) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olWaitEvent";
|
|
}
|
|
|
|
ol_result_t Result = olWaitEvent_val(Event);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_wait_event_params_t Params = {&Event};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olWaitEventWithCodeLoc(ol_event_handle_t Event,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olWaitEvent(Event);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olCreateProgram_val(ol_device_handle_t Device,
|
|
const void *ProgData, size_t ProgDataSize,
|
|
ol_program_handle_t *Program) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Device) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == ProgData) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
|
|
if (NULL == Program) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olCreateProgram_impl(Device, ProgData, ProgDataSize,
|
|
Program);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL
|
|
olCreateProgram(ol_device_handle_t Device, const void *ProgData,
|
|
size_t ProgDataSize, ol_program_handle_t *Program) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olCreateProgram";
|
|
}
|
|
|
|
ol_result_t Result =
|
|
olCreateProgram_val(Device, ProgData, ProgDataSize, Program);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_create_program_params_t Params = {&Device, &ProgData, &ProgDataSize,
|
|
&Program};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olCreateProgramWithCodeLoc(ol_device_handle_t Device,
|
|
const void *ProgData,
|
|
size_t ProgDataSize,
|
|
ol_program_handle_t *Program,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result =
|
|
::olCreateProgram(Device, ProgData, ProgDataSize, Program);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olDestroyProgram_val(ol_program_handle_t Program) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Program) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olDestroyProgram_impl(Program);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL
|
|
olDestroyProgram(ol_program_handle_t Program) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olDestroyProgram";
|
|
}
|
|
|
|
ol_result_t Result = olDestroyProgram_val(Program);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_destroy_program_params_t Params = {&Program};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olDestroyProgramWithCodeLoc(ol_program_handle_t Program,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olDestroyProgram(Program);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t olGetKernel_val(ol_program_handle_t Program,
|
|
const char *KernelName,
|
|
ol_kernel_handle_t *Kernel) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Program) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == KernelName) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
|
|
if (NULL == Kernel) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olGetKernel_impl(Program, KernelName, Kernel);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olGetKernel(ol_program_handle_t Program,
|
|
const char *KernelName,
|
|
ol_kernel_handle_t *Kernel) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olGetKernel";
|
|
}
|
|
|
|
ol_result_t Result = olGetKernel_val(Program, KernelName, Kernel);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_get_kernel_params_t Params = {&Program, &KernelName, &Kernel};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olGetKernelWithCodeLoc(ol_program_handle_t Program,
|
|
const char *KernelName,
|
|
ol_kernel_handle_t *Kernel,
|
|
ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result = ::olGetKernel(Program, KernelName, Kernel);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
ol_impl_result_t
|
|
olLaunchKernel_val(ol_queue_handle_t Queue, ol_device_handle_t Device,
|
|
ol_kernel_handle_t Kernel, const void *ArgumentsData,
|
|
size_t ArgumentsSize,
|
|
const ol_kernel_launch_size_args_t *LaunchSizeArgs,
|
|
ol_event_handle_t *EventOut) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (Queue == NULL && EventOut != NULL) {
|
|
return OL_ERRC_INVALID_ARGUMENT;
|
|
}
|
|
|
|
if (NULL == Device) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == Kernel) {
|
|
return OL_ERRC_INVALID_NULL_HANDLE;
|
|
}
|
|
|
|
if (NULL == ArgumentsData) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
|
|
if (NULL == LaunchSizeArgs) {
|
|
return OL_ERRC_INVALID_NULL_POINTER;
|
|
}
|
|
}
|
|
|
|
return llvm::offload::olLaunchKernel_impl(Queue, Device, Kernel,
|
|
ArgumentsData, ArgumentsSize,
|
|
LaunchSizeArgs, EventOut);
|
|
}
|
|
OL_APIEXPORT ol_result_t OL_APICALL olLaunchKernel(
|
|
ol_queue_handle_t Queue, ol_device_handle_t Device,
|
|
ol_kernel_handle_t Kernel, const void *ArgumentsData, size_t ArgumentsSize,
|
|
const ol_kernel_launch_size_args_t *LaunchSizeArgs,
|
|
ol_event_handle_t *EventOut) {
|
|
if (offloadConfig().TracingEnabled) {
|
|
llvm::errs() << "---> olLaunchKernel";
|
|
}
|
|
|
|
ol_result_t Result =
|
|
olLaunchKernel_val(Queue, Device, Kernel, ArgumentsData, ArgumentsSize,
|
|
LaunchSizeArgs, EventOut);
|
|
|
|
if (offloadConfig().TracingEnabled) {
|
|
ol_launch_kernel_params_t Params = {
|
|
&Queue, &Device, &Kernel, &ArgumentsData,
|
|
&ArgumentsSize, &LaunchSizeArgs, &EventOut};
|
|
llvm::errs() << "(" << &Params << ")";
|
|
llvm::errs() << "-> " << Result << "\n";
|
|
if (Result && Result->Details) {
|
|
llvm::errs() << " *Error Details* " << Result->Details << " \n";
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
ol_result_t olLaunchKernelWithCodeLoc(
|
|
ol_queue_handle_t Queue, ol_device_handle_t Device,
|
|
ol_kernel_handle_t Kernel, const void *ArgumentsData, size_t ArgumentsSize,
|
|
const ol_kernel_launch_size_args_t *LaunchSizeArgs,
|
|
ol_event_handle_t *EventOut, ol_code_location_t *CodeLocation) {
|
|
currentCodeLocation() = CodeLocation;
|
|
ol_result_t Result =
|
|
::olLaunchKernel(Queue, Device, Kernel, ArgumentsData, ArgumentsSize,
|
|
LaunchSizeArgs, EventOut);
|
|
|
|
currentCodeLocation() = nullptr;
|
|
return Result;
|
|
}
|