7e9d708be0
This removes the `ol_impl_result_t` helper class, replacing it with `llvm::Error`. In addition, some internal functions that returned `ol_errc_t` now return `llvm::Error` (with a fancy message).
904 lines
33 KiB
C++
904 lines
33 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error 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 = llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error 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 = llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olGetPlatformInfo_val(ol_platform_handle_t Platform,
|
|
ol_platform_info_t PropName, size_t PropSize,
|
|
void *PropValue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (PropSize == 0) {
|
|
return createOffloadError(error::ErrorCode::INVALID_SIZE,
|
|
"validation failure: PropSize == 0");
|
|
}
|
|
|
|
if (NULL == Platform) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Platform");
|
|
}
|
|
|
|
if (NULL == PropValue) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == PropValue");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(
|
|
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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olGetPlatformInfoSize_val(ol_platform_handle_t Platform,
|
|
ol_platform_info_t PropName,
|
|
size_t *PropSizeRet) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Platform) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Platform");
|
|
}
|
|
|
|
if (NULL == PropSizeRet) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == PropSizeRet");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(
|
|
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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error 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 =
|
|
llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olGetDeviceInfo_val(ol_device_handle_t Device,
|
|
ol_device_info_t PropName, size_t PropSize,
|
|
void *PropValue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (PropSize == 0) {
|
|
return createOffloadError(error::ErrorCode::INVALID_SIZE,
|
|
"validation failure: PropSize == 0");
|
|
}
|
|
|
|
if (NULL == Device) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Device");
|
|
}
|
|
|
|
if (NULL == PropValue) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == PropValue");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(
|
|
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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olGetDeviceInfoSize_val(ol_device_handle_t Device,
|
|
ol_device_info_t PropName,
|
|
size_t *PropSizeRet) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Device) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Device");
|
|
}
|
|
|
|
if (NULL == PropSizeRet) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == PropSizeRet");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(
|
|
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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olMemAlloc_val(ol_device_handle_t Device, ol_alloc_type_t Type,
|
|
size_t Size, void **AllocationOut) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (Size == 0) {
|
|
return createOffloadError(error::ErrorCode::INVALID_SIZE,
|
|
"validation failure: Size == 0");
|
|
}
|
|
|
|
if (NULL == Device) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Device");
|
|
}
|
|
|
|
if (NULL == AllocationOut) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == AllocationOut");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(
|
|
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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olMemFree_val(void *Address) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Address) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == Address");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error 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 createOffloadError(
|
|
error::ErrorCode::INVALID_ARGUMENT,
|
|
"validation failure: Queue == NULL && EventOut != NULL");
|
|
}
|
|
|
|
if (NULL == DstDevice) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == DstDevice");
|
|
}
|
|
|
|
if (NULL == SrcDevice) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == SrcDevice");
|
|
}
|
|
|
|
if (NULL == DstPtr) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == DstPtr");
|
|
}
|
|
|
|
if (NULL == SrcPtr) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == SrcPtr");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olCreateQueue_val(ol_device_handle_t Device,
|
|
ol_queue_handle_t *Queue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Device) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Device");
|
|
}
|
|
|
|
if (NULL == Queue) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == Queue");
|
|
}
|
|
}
|
|
|
|
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 =
|
|
llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olDestroyQueue_val(ol_queue_handle_t Queue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Queue) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Queue");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olWaitQueue_val(ol_queue_handle_t Queue) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Queue) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Queue");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olDestroyEvent_val(ol_event_handle_t Event) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Event) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Event");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olWaitEvent_val(ol_event_handle_t Event) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Event) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Event");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error 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 createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Device");
|
|
}
|
|
|
|
if (NULL == ProgData) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == ProgData");
|
|
}
|
|
|
|
if (NULL == Program) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == Program");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(
|
|
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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olDestroyProgram_val(ol_program_handle_t Program) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Program) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Program");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error olGetKernel_val(ol_program_handle_t Program, const char *KernelName,
|
|
ol_kernel_handle_t *Kernel) {
|
|
if (offloadConfig().ValidationEnabled) {
|
|
if (NULL == Program) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Program");
|
|
}
|
|
|
|
if (NULL == KernelName) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == KernelName");
|
|
}
|
|
|
|
if (NULL == Kernel) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == Kernel");
|
|
}
|
|
}
|
|
|
|
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 =
|
|
llvmErrorToOffloadError(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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
llvm::Error
|
|
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 createOffloadError(
|
|
error::ErrorCode::INVALID_ARGUMENT,
|
|
"validation failure: Queue == NULL && EventOut != NULL");
|
|
}
|
|
|
|
if (NULL == Device) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Device");
|
|
}
|
|
|
|
if (NULL == Kernel) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_HANDLE,
|
|
"validation failure: NULL == Kernel");
|
|
}
|
|
|
|
if (NULL == ArgumentsData) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == ArgumentsData");
|
|
}
|
|
|
|
if (NULL == LaunchSizeArgs) {
|
|
return createOffloadError(error::ErrorCode::INVALID_NULL_POINTER,
|
|
"validation failure: NULL == LaunchSizeArgs");
|
|
}
|
|
}
|
|
|
|
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 = llvmErrorToOffloadError(
|
|
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;
|
|
}
|