Address more review feedback

Author: callumfare

sycl/plugins/unified_runtime/CMakeLists.txt

@@ -162,6 +162,11 @@ if ("cuda" IN_LIST SYCL_ENABLE_PLUGINS)
       Threads::Threads
       cudadrv
   )
+
+  set_target_properties("ur_adapter_cuda" PROPERTIES
+    VERSION "0.0.0"
+    SOVERSION "0"
+  )
 endif()
 
 if (TARGET UnifiedRuntimeLoader)

sycl/plugins/unified_runtime/ur/adapters/cuda/device.cpp

@@ -1026,7 +1026,7 @@ urDevicePartition(ur_device_handle_t, const ur_device_partition_property_t *,
 
 /// \return UR_RESULT_SUCCESS always since CUDA devices are always root
 /// devices.
-UR_DLLEXPORT ur_result_t UR_APICALL
+UR_APIEXPORT ur_result_t UR_APICALL
 urDeviceRelease(ur_device_handle_t hDevice) {
   UR_ASSERT(hDevice, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
 

sycl/plugins/unified_runtime/ur/adapters/cuda/enqueue.cpp

@@ -223,7 +223,7 @@ bool hasExceededMaxRegistersPerBlock(ur_device_handle_t Device,
 /// \ref enqueueEventWaitWithBarrier.) If the events list is empty, the enqueued
 /// wait will wait on all previous events in the queue.
 ///
-UR_DLLEXPORT ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier(
+UR_APIEXPORT ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier(
     ur_queue_handle_t hQueue, uint32_t numEventsInWaitList,
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
   // This function makes one stream work on the previous work (or work
@@ -303,14 +303,14 @@ UR_DLLEXPORT ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier(
 /// TODO: Add support for multiple streams once the Event class is properly
 /// refactored.
 ///
-UR_DLLEXPORT ur_result_t UR_APICALL urEnqueueEventsWait(
+UR_APIEXPORT ur_result_t UR_APICALL urEnqueueEventsWait(
     ur_queue_handle_t hQueue, uint32_t numEventsInWaitList,
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
   return urEnqueueEventsWaitWithBarrier(hQueue, numEventsInWaitList,
                                         phEventWaitList, phEvent);
 }
 
-UR_DLLEXPORT ur_result_t UR_APICALL urEnqueueKernelLaunch(
+UR_APIEXPORT ur_result_t UR_APICALL urEnqueueKernelLaunch(
     ur_queue_handle_t hQueue, ur_kernel_handle_t hKernel, uint32_t workDim,
     const size_t *pGlobalWorkOffset, const size_t *pGlobalWorkSize,
     const size_t *pLocalWorkSize, uint32_t numEventsInWaitList,

sycl/plugins/unified_runtime/ur/adapters/cuda/platform.cpp

@@ -18,7 +18,7 @@
 void enableCUDATracing();
 void disableCUDATracing();
 
-UR_DLLEXPORT ur_result_t UR_APICALL urPlatformGetInfo(
+UR_APIEXPORT ur_result_t UR_APICALL urPlatformGetInfo(
     ur_platform_handle_t hPlatform, ur_platform_info_t PlatformInfoType,
     size_t Size, void *pPlatformInfo, size_t *pSizeRet) {
 
@@ -56,7 +56,7 @@ UR_DLLEXPORT ur_result_t UR_APICALL urPlatformGetInfo(
 ///
 /// However because multiple devices in a context is not currently supported,
 /// place each device in a separate platform.
-UR_DLLEXPORT ur_result_t UR_APICALL
+UR_APIEXPORT ur_result_t UR_APICALL
 urPlatformGet(uint32_t NumEntries, ur_platform_handle_t *phPlatforms,
               uint32_t *pNumPlatforms) {
 
@@ -163,7 +163,7 @@ urPlatformGet(uint32_t NumEntries, ur_platform_handle_t *phPlatforms,
   }
 }
 
-UR_DLLEXPORT ur_result_t UR_APICALL urPlatformGetApiVersion(
+UR_APIEXPORT ur_result_t UR_APICALL urPlatformGetApiVersion(
     ur_platform_handle_t hDriver, ur_api_version_t *pVersion) {
   UR_ASSERT(hDriver, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
   UR_ASSERT(pVersion, UR_RESULT_ERROR_INVALID_NULL_POINTER);
@@ -172,12 +172,12 @@ UR_DLLEXPORT ur_result_t UR_APICALL urPlatformGetApiVersion(
   return UR_RESULT_SUCCESS;
 }
 
-UR_DLLEXPORT ur_result_t UR_APICALL urInit(ur_device_init_flags_t) {
+UR_APIEXPORT ur_result_t UR_APICALL urInit(ur_device_init_flags_t) {
   enableCUDATracing();
   return UR_RESULT_SUCCESS;
 }
 
-UR_DLLEXPORT ur_result_t UR_APICALL urTearDown(void *) {
+UR_APIEXPORT ur_result_t UR_APICALL urTearDown(void *) {
   disableCUDATracing();
   return UR_RESULT_SUCCESS;
 }

sycl/plugins/unified_runtime/ur/adapters/cuda/sampler.cpp

@@ -9,9 +9,9 @@
 #include "sampler.hpp"
 #include "common.hpp"
 
-ur_result_t urSamplerCreate(ur_context_handle_t hContext,
-                            const ur_sampler_desc_t *pDesc,
-                            ur_sampler_handle_t *phSampler) {
+UR_APIEXPORT ur_result_t UR_APICALL
+urSamplerCreate(ur_context_handle_t hContext, const ur_sampler_desc_t *pDesc,
+                ur_sampler_handle_t *phSampler) {
   std::unique_ptr<ur_sampler_handle_t_> Sampler{
       new ur_sampler_handle_t_(hContext)};
 
@@ -29,9 +29,9 @@ ur_result_t urSamplerCreate(ur_context_handle_t hContext,
   return UR_RESULT_SUCCESS;
 }
 
-ur_result_t urSamplerGetInfo(ur_sampler_handle_t hSampler,
-                             ur_sampler_info_t propName, size_t propValueSize,
-                             void *pPropValue, size_t *pPropSizeRet) {
+UR_APIEXPORT ur_result_t UR_APICALL
+urSamplerGetInfo(ur_sampler_handle_t hSampler, ur_sampler_info_t propName,
+                 size_t propValueSize, void *pPropValue, size_t *pPropSizeRet) {
   UR_ASSERT(hSampler, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
   UrReturnHelper ReturnValue(propValueSize, pPropValue, pPropSizeRet);
 
@@ -60,13 +60,15 @@ ur_result_t urSamplerGetInfo(ur_sampler_handle_t hSampler,
   return {};
 }
 
-ur_result_t urSamplerRetain(ur_sampler_handle_t hSampler) {
+UR_APIEXPORT ur_result_t UR_APICALL
+urSamplerRetain(ur_sampler_handle_t hSampler) {
   UR_ASSERT(hSampler, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
   hSampler->incrementReferenceCount();
   return UR_RESULT_SUCCESS;
 }
 
-ur_result_t urSamplerRelease(ur_sampler_handle_t hSampler) {
+UR_APIEXPORT ur_result_t UR_APICALL
+urSamplerRelease(ur_sampler_handle_t hSampler) {
   UR_ASSERT(hSampler, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
 
   // double delete or someone is messing with the ref count.