Skip to content

[SYCL][UR][CUDA] Remove unnecessary UR entry point validation #9969

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Jul 7, 2023
Merged

[SYCL][UR][CUDA] Remove unnecessary UR entry point validation #9969

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
0e22d6f
[SYCL][UR][CUDA] Remove unnecessary input validation from UR entry po…
callumfare Jun 15, 2023
0e75cd7
Merge branch 'sycl' into cuda_ur_remove_extra_validation
callumfare Jul 5, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 0 additions & 14 deletions sycl/plugins/unified_runtime/ur/adapters/cuda/context.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,8 +24,6 @@ urContextCreate(uint32_t DeviceCount, const ur_device_handle_t *phDevices,
ur_context_handle_t *phContext) {
std::ignore = DeviceCount;
std::ignore = pProperties;
UR_ASSERT(phDevices, UR_RESULT_ERROR_INVALID_NULL_POINTER);
UR_ASSERT(phContext, UR_RESULT_ERROR_INVALID_NULL_POINTER);

assert(DeviceCount == 1);
ur_result_t RetErr = UR_RESULT_SUCCESS;
Expand All @@ -46,8 +44,6 @@ urContextCreate(uint32_t DeviceCount, const ur_device_handle_t *phDevices,
UR_APIEXPORT ur_result_t UR_APICALL urContextGetInfo(
ur_context_handle_t hContext, ur_context_info_t ContextInfoType,
size_t propSize, void *pContextInfo, size_t *pPropSizeRet) {
UR_ASSERT(hContext, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

UrReturnHelper ReturnValue(propSize, pContextInfo, pPropSizeRet);

switch (uint32_t{ContextInfoType}) {
Expand Down Expand Up @@ -98,8 +94,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urContextGetInfo(

UR_APIEXPORT ur_result_t UR_APICALL
urContextRelease(ur_context_handle_t hContext) {
UR_ASSERT(hContext, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

if (hContext->decrementReferenceCount() > 0) {
return UR_RESULT_SUCCESS;
}
Expand All @@ -112,8 +106,6 @@ urContextRelease(ur_context_handle_t hContext) {

UR_APIEXPORT ur_result_t UR_APICALL
urContextRetain(ur_context_handle_t hContext) {
UR_ASSERT(hContext, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

assert(hContext->getReferenceCount() > 0);

hContext->incrementReferenceCount();
Expand All @@ -122,9 +114,6 @@ urContextRetain(ur_context_handle_t hContext) {

UR_APIEXPORT ur_result_t UR_APICALL urContextGetNativeHandle(
ur_context_handle_t hContext, ur_native_handle_t *phNativeContext) {
UR_ASSERT(hContext, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(phNativeContext, UR_RESULT_ERROR_INVALID_NULL_POINTER);

*phNativeContext = reinterpret_cast<ur_native_handle_t>(hContext->get());
return UR_RESULT_SUCCESS;
}
Expand All @@ -146,9 +135,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urContextCreateWithNativeHandle(
UR_APIEXPORT ur_result_t UR_APICALL urContextSetExtendedDeleter(
ur_context_handle_t hContext, ur_context_extended_deleter_t pfnDeleter,
void *pUserData) {
UR_ASSERT(hContext, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(pfnDeleter, UR_RESULT_ERROR_INVALID_NULL_POINTER);

hContext->setExtendedDeleter(pfnDeleter, pUserData);
return UR_RESULT_SUCCESS;
}
23 changes: 3 additions & 20 deletions sycl/plugins/unified_runtime/ur/adapters/cuda/device.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,7 +37,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
size_t propSize,
void *pPropValue,
size_t *pPropSizeRet) {
UR_ASSERT(hDevice, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UrReturnHelper ReturnValue(propSize, pPropValue, pPropSizeRet);

static constexpr uint32_t MaxWorkItemDimensions = 3u;
Expand Down Expand Up @@ -1017,8 +1016,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
/// \return PI_SUCCESS if the function is executed successfully
/// CUDA devices are always root devices so retain always returns success.
UR_APIEXPORT ur_result_t UR_APICALL urDeviceRetain(ur_device_handle_t hDevice) {
UR_ASSERT(hDevice, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

std::ignore = hDevice;
return UR_RESULT_SUCCESS;
}

Expand All @@ -1032,8 +1030,7 @@ urDevicePartition(ur_device_handle_t, const ur_device_partition_properties_t *,
/// devices.
UR_APIEXPORT ur_result_t UR_APICALL
urDeviceRelease(ur_device_handle_t hDevice) {
UR_ASSERT(hDevice, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

std::ignore = hDevice;
return UR_RESULT_SUCCESS;
}

Expand All @@ -1048,13 +1045,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGet(ur_platform_handle_t hPlatform,
const bool AskingForGPU = DeviceType == UR_DEVICE_TYPE_GPU;
const bool ReturnDevices = AskingForDefault || AskingForAll || AskingForGPU;

UR_ASSERT(hPlatform, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

size_t NumDevices = ReturnDevices ? hPlatform->Devices.size() : 0;

try {
UR_ASSERT(pNumDevices || phDevices, UR_RESULT_ERROR_INVALID_VALUE);

if (pNumDevices) {
*pNumDevices = NumDevices;
}
Expand Down Expand Up @@ -1082,9 +1075,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGet(ur_platform_handle_t hPlatform,

UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetNativeHandle(
ur_device_handle_t hDevice, ur_native_handle_t *phNativeHandle) {
UR_ASSERT(hDevice, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(phNativeHandle, UR_RESULT_ERROR_INVALID_NULL_POINTER);

*phNativeHandle = reinterpret_cast<ur_native_handle_t>(hDevice->get());
return UR_RESULT_SUCCESS;
}
Expand All @@ -1103,7 +1093,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
const ur_device_native_properties_t *pProperties,
ur_device_handle_t *phDevice) {
std::ignore = pProperties;
UR_ASSERT(phDevice, UR_RESULT_ERROR_INVALID_NULL_POINTER);

// We can't cast between ur_native_handle_t and CUdevice, so memcpy the bits
// instead
Expand Down Expand Up @@ -1154,8 +1143,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
ur_result_t UR_APICALL urDeviceGetGlobalTimestamps(ur_device_handle_t hDevice,
uint64_t *pDeviceTimestamp,
uint64_t *pHostTimestamp) {
UR_ASSERT(hDevice, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

CUevent Event;
ScopedContext Active(hDevice->getContext());

Expand Down Expand Up @@ -1184,11 +1171,7 @@ ur_result_t UR_APICALL urDeviceGetGlobalTimestamps(ur_device_handle_t hDevice,
UR_APIEXPORT ur_result_t UR_APICALL urDeviceSelectBinary(
ur_device_handle_t hDevice, const ur_device_binary_t *pBinaries,
uint32_t NumBinaries, uint32_t *pSelectedBinary) {
// Ignore unused parameter
(void)hDevice;

UR_ASSERT(pBinaries, UR_RESULT_ERROR_INVALID_NULL_POINTER);
UR_ASSERT(NumBinaries > 0, UR_RESULT_ERROR_INVALID_ARGUMENT);
std::ignore = hDevice;

// Look for an image for the NVPTX64 target, and return the first one that is
// found
Expand Down
73 changes: 1 addition & 72 deletions sycl/plugins/unified_runtime/ur/adapters/cuda/enqueue.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -204,8 +204,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier(
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
// This function makes one stream work on the previous work (or work
// represented by input events) and then all future work waits on that stream.
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_QUEUE);

ur_result_t Result;

try {
Expand Down Expand Up @@ -292,11 +290,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueKernelLaunch(
const size_t *pLocalWorkSize, uint32_t numEventsInWaitList,
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
// Preconditions
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hQueue->getContext() == hKernel->getContext(),
UR_RESULT_ERROR_INVALID_KERNEL);
UR_ASSERT(hKernel, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(pGlobalWorkOffset, UR_RESULT_ERROR_INVALID_NULL_POINTER);
UR_ASSERT(workDim > 0, UR_RESULT_ERROR_INVALID_WORK_DIMENSION);
UR_ASSERT(workDim < 4, UR_RESULT_ERROR_INVALID_WORK_DIMENSION);

Expand Down Expand Up @@ -513,9 +508,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemBufferReadRect(
size_t hostRowPitch, size_t hostSlicePitch, void *pDst,
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent) {
UR_ASSERT(hBuffer, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

ur_result_t Result = UR_RESULT_SUCCESS;
CUdeviceptr DevPtr = hBuffer->Mem.BufferMem.get();
std::unique_ptr<ur_event_handle_t_> RetImplEvent{nullptr};
Expand Down Expand Up @@ -564,9 +556,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemBufferWriteRect(
size_t hostRowPitch, size_t hostSlicePitch, void *pSrc,
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent) {
UR_ASSERT(hBuffer, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

ur_result_t Result = UR_RESULT_SUCCESS;
CUdeviceptr DevPtr = hBuffer->Mem.BufferMem.get();
std::unique_ptr<ur_event_handle_t_> RetImplEvent{nullptr};
Expand Down Expand Up @@ -612,8 +601,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemBufferCopy(
ur_mem_handle_t hBufferDst, size_t srcOffset, size_t dstOffset, size_t size,
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent) {
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

std::unique_ptr<ur_event_handle_t_> RetImplEvent{nullptr};

try {
Expand Down Expand Up @@ -656,10 +643,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemBufferCopyRect(
size_t srcSlicePitch, size_t dstRowPitch, size_t dstSlicePitch,
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent) {
UR_ASSERT(hBufferSrc, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hBufferDst, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

ur_result_t Result = UR_RESULT_SUCCESS;
CUdeviceptr SrcPtr = hBufferSrc->Mem.BufferMem.get();
CUdeviceptr DstPtr = hBufferDst->Mem.BufferMem.get();
Expand Down Expand Up @@ -699,8 +682,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemBufferFill(
size_t patternSize, size_t offset, size_t size,
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent) {
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);

auto ArgsAreMultiplesOfPatternSize =
(offset % patternSize == 0) || (size % patternSize == 0);

Expand Down Expand Up @@ -886,8 +867,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemImageRead(
std::ignore = rowPitch;
std::ignore = slicePitch;

UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hImage, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hImage->MemType == ur_mem_handle_t_::Type::Surface,
UR_RESULT_ERROR_INVALID_MEM_OBJECT);

Expand Down Expand Up @@ -955,8 +934,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemImageWrite(
std::ignore = rowPitch;
std::ignore = slicePitch;

UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hImage, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hImage->MemType == ur_mem_handle_t_::Type::Surface,
UR_RESULT_ERROR_INVALID_MEM_OBJECT);

Expand Down Expand Up @@ -1099,9 +1076,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemBufferMap(
ur_map_flags_t mapFlags, size_t offset, size_t size,
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent, void **ppRetMap) {
UR_ASSERT(ppRetMap != nullptr, UR_RESULT_ERROR_INVALID_NULL_POINTER);
UR_ASSERT(hQueue != nullptr, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hBuffer != nullptr, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hBuffer->MemType == ur_mem_handle_t_::Type::Buffer,
UR_RESULT_ERROR_INVALID_MEM_OBJECT);

Expand Down Expand Up @@ -1160,10 +1134,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemUnmap(
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent) {
ur_result_t Result = UR_RESULT_SUCCESS;
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hMem, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(pMappedPtr, UR_RESULT_ERROR_INVALID_NULL_POINTER);

UR_ASSERT(hMem->MemType == ur_mem_handle_t_::Type::Buffer,
UR_RESULT_ERROR_INVALID_MEM_OBJECT);
UR_ASSERT(hMem->Mem.BufferMem.getMapPtr() != nullptr,
Expand Down Expand Up @@ -1209,10 +1179,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMFill(
ur_queue_handle_t hQueue, void *ptr, size_t patternSize,
const void *pPattern, size_t size, uint32_t numEventsInWaitList,
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_QUEUE);
UR_ASSERT(ptr, UR_RESULT_ERROR_INVALID_NULL_POINTER);
UR_ASSERT(size % patternSize == 0, UR_RESULT_ERROR_INVALID_SIZE);

ur_result_t Result = UR_RESULT_SUCCESS;
std::unique_ptr<ur_event_handle_t_> EventPtr{nullptr};

Expand Down Expand Up @@ -1263,9 +1229,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMMemcpy(
ur_queue_handle_t hQueue, bool blocking, void *pDst, const void *pSrc,
size_t size, uint32_t numEventsInWaitList,
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_QUEUE);
UR_ASSERT(pDst, UR_RESULT_ERROR_INVALID_NULL_POINTER);
UR_ASSERT(pSrc, UR_RESULT_ERROR_INVALID_NULL_POINTER);
ur_result_t Result = UR_RESULT_SUCCESS;

std::unique_ptr<ur_event_handle_t_> EventPtr{nullptr};
Expand Down Expand Up @@ -1302,7 +1265,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
ur_queue_handle_t hQueue, const void *pMem, size_t size,
ur_usm_migration_flags_t flags, uint32_t numEventsInWaitList,
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_QUEUE);
ur_device_handle_t Device = hQueue->getContext()->getDevice();

// Certain cuda devices and Windows do not have support for some Unified
Expand All @@ -1328,8 +1290,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
// flags is currently unused so fail if set
if (flags != 0)
return UR_RESULT_ERROR_INVALID_VALUE;
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(pMem, UR_RESULT_ERROR_INVALID_NULL_POINTER);

ur_result_t Result = UR_RESULT_SUCCESS;
std::unique_ptr<ur_event_handle_t_> EventPtr{nullptr};

Expand Down Expand Up @@ -1360,9 +1321,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
UR_APIEXPORT ur_result_t UR_APICALL
urEnqueueUSMAdvise(ur_queue_handle_t hQueue, const void *pMem, size_t size,
ur_usm_advice_flags_t advice, ur_event_handle_t *phEvent) {
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_QUEUE);
UR_ASSERT(pMem, UR_RESULT_ERROR_INVALID_MEM_OBJECT);

// Certain cuda devices and Windows do not have support for some Unified
// Memory features. Passing CU_MEM_ADVISE_SET/CLEAR_PREFERRED_LOCATION and
// to cuMemAdvise on a GPU device requires the GPU device to report a non-zero
Expand Down Expand Up @@ -1449,7 +1407,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMMemcpy2D(
const void *pSrc, size_t srcPitch, size_t width, size_t height,
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent) {
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_QUEUE);
ur_result_t result = UR_RESULT_SUCCESS;

try {
Expand Down Expand Up @@ -1496,17 +1453,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemBufferRead(
ur_queue_handle_t hQueue, ur_mem_handle_t hBuffer, bool blockingRead,
size_t offset, size_t size, void *pDst, uint32_t numEventsInWaitList,
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {

UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hBuffer, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(!hBuffer->isImage(), UR_RESULT_ERROR_INVALID_MEM_OBJECT);
UR_ASSERT(pDst, UR_RESULT_ERROR_INVALID_NULL_POINTER);
if (phEventWaitList) {
UR_ASSERT(numEventsInWaitList > 0, UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
} else {
UR_ASSERT(numEventsInWaitList == 0,
UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
}
UR_ASSERT(offset + size <= hBuffer->Mem.BufferMem.Size,
UR_RESULT_ERROR_INVALID_SIZE);

Expand Down Expand Up @@ -1553,17 +1500,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueMemBufferWrite(
ur_queue_handle_t hQueue, ur_mem_handle_t hBuffer, bool blockingWrite,
size_t offset, size_t size, const void *pSrc, uint32_t numEventsInWaitList,
const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {

UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hBuffer, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(!hBuffer->isImage(), UR_RESULT_ERROR_INVALID_MEM_OBJECT);
UR_ASSERT(pSrc, UR_RESULT_ERROR_INVALID_NULL_POINTER);
if (phEventWaitList) {
UR_ASSERT(numEventsInWaitList > 0, UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
} else {
UR_ASSERT(numEventsInWaitList == 0,
UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
}
UR_ASSERT(offset + size <= hBuffer->Mem.BufferMem.Size,
UR_RESULT_ERROR_INVALID_SIZE);

Expand Down Expand Up @@ -1609,10 +1546,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableWrite(
bool blockingWrite, size_t count, size_t offset, const void *pSrc,
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent) {
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hProgram, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(name && pSrc, UR_RESULT_ERROR_INVALID_VALUE);

// Since CUDA requires a the global variable to be referenced by name, we use
// metadata to find the correct name to access it by.
auto DeviceGlobalNameIt = hProgram->GlobalIDMD.find(name);
Expand Down Expand Up @@ -1645,10 +1578,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableRead(
bool blockingRead, size_t count, size_t offset, void *pDst,
uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
ur_event_handle_t *phEvent) {
UR_ASSERT(hQueue, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(hProgram, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
UR_ASSERT(name && pDst, UR_RESULT_ERROR_INVALID_VALUE);

// Since CUDA requires a the global variable to be referenced by name, we use
// metadata to find the correct name to access it by.
auto DeviceGlobalNameIt = hProgram->GlobalIDMD.find(name);
Expand Down
Loading