[SYCL][UR] Update UR loader version (#9053)

smaslov-intel · bmyates · web-flow · commit e12574f51e6d · 2023-04-13T10:33:43.000-07:00
Signed-off-by: Brandon Yates &lt;brandon.yates@intel.com&gt;
Co-authored-by: Brandon Yates &lt;brandon.yates@intel.com&gt;
diff --git a/sycl/plugins/unified_runtime/CMakeLists.txt b/sycl/plugins/unified_runtime/CMakeLists.txt
@@ -4,7 +4,7 @@ if (NOT DEFINED UNIFIED_RUNTIME_LIBRARY OR NOT DEFINED UNIFIED_RUNTIME_INCLUDE_D
   include(FetchContent)
 
   set(UNIFIED_RUNTIME_REPO "https://github.com/oneapi-src/unified-runtime.git")
-  set(UNIFIED_RUNTIME_TAG d6af758779db6eebdc419fd5e249302f566eb5de)
+  set(UNIFIED_RUNTIME_TAG 74843ea0800e6fb7ce0f82e0ef991fc258f4b9bd)
 
   message(STATUS "Will fetch Unified Runtime from ${UNIFIED_RUNTIME_REPO}")
   FetchContent_Declare(unified-runtime
diff --git a/sycl/plugins/unified_runtime/ur/adapters/level_zero/ur_level_zero.cpp b/sycl/plugins/unified_runtime/ur/adapters/level_zero/ur_level_zero.cpp
@@ -662,25 +662,26 @@ ur_result_t urDeviceGetInfo(
     ze_device_fp_flags_t ZeSingleFPCapabilities =
         Device->ZeDeviceModuleProperties->fp32flags;
     if (ZE_DEVICE_FP_FLAG_DENORM & ZeSingleFPCapabilities) {
-      SingleFPValue |= UR_FP_CAPABILITY_FLAG_DENORM;
+      SingleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;
     }
     if (ZE_DEVICE_FP_FLAG_INF_NAN & ZeSingleFPCapabilities) {
-      SingleFPValue |= UR_FP_CAPABILITY_FLAG_INF_NAN;
+      SingleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;
     }
     if (ZE_DEVICE_FP_FLAG_ROUND_TO_NEAREST & ZeSingleFPCapabilities) {
-      SingleFPValue |= UR_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
+      SingleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
     }
     if (ZE_DEVICE_FP_FLAG_ROUND_TO_ZERO & ZeSingleFPCapabilities) {
-      SingleFPValue |= UR_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
+      SingleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
     }
     if (ZE_DEVICE_FP_FLAG_ROUND_TO_INF & ZeSingleFPCapabilities) {
-      SingleFPValue |= UR_FP_CAPABILITY_FLAG_ROUND_TO_INF;
+      SingleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;
     }
     if (ZE_DEVICE_FP_FLAG_FMA & ZeSingleFPCapabilities) {
-      SingleFPValue |= UR_FP_CAPABILITY_FLAG_FMA;
+      SingleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
     }
     if (ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT & ZeSingleFPCapabilities) {
-      SingleFPValue |= UR_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
+      SingleFPValue |=
+          UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
     }
     return ReturnValue(uint64_t{SingleFPValue});
   }
@@ -689,25 +690,25 @@ ur_result_t urDeviceGetInfo(
     ze_device_fp_flags_t ZeHalfFPCapabilities =
         Device->ZeDeviceModuleProperties->fp16flags;
     if (ZE_DEVICE_FP_FLAG_DENORM & ZeHalfFPCapabilities) {
-      HalfFPValue |= UR_FP_CAPABILITY_FLAG_DENORM;
+      HalfFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;
     }
     if (ZE_DEVICE_FP_FLAG_INF_NAN & ZeHalfFPCapabilities) {
-      HalfFPValue |= UR_FP_CAPABILITY_FLAG_INF_NAN;
+      HalfFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;
     }
     if (ZE_DEVICE_FP_FLAG_ROUND_TO_NEAREST & ZeHalfFPCapabilities) {
-      HalfFPValue |= UR_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
+      HalfFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
     }
     if (ZE_DEVICE_FP_FLAG_ROUND_TO_ZERO & ZeHalfFPCapabilities) {
-      HalfFPValue |= UR_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
+      HalfFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
     }
     if (ZE_DEVICE_FP_FLAG_ROUND_TO_INF & ZeHalfFPCapabilities) {
-      HalfFPValue |= UR_FP_CAPABILITY_FLAG_ROUND_TO_INF;
+      HalfFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;
     }
     if (ZE_DEVICE_FP_FLAG_FMA & ZeHalfFPCapabilities) {
-      HalfFPValue |= UR_FP_CAPABILITY_FLAG_FMA;
+      HalfFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
     }
     if (ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT & ZeHalfFPCapabilities) {
-      HalfFPValue |= UR_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
+      HalfFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
     }
     return ReturnValue(uint64_t{HalfFPValue});
   }
@@ -716,25 +717,26 @@ ur_result_t urDeviceGetInfo(
     ze_device_fp_flags_t ZeDoubleFPCapabilities =
         Device->ZeDeviceModuleProperties->fp64flags;
     if (ZE_DEVICE_FP_FLAG_DENORM & ZeDoubleFPCapabilities) {
-      DoubleFPValue |= UR_FP_CAPABILITY_FLAG_DENORM;
+      DoubleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;
     }
     if (ZE_DEVICE_FP_FLAG_INF_NAN & ZeDoubleFPCapabilities) {
-      DoubleFPValue |= UR_FP_CAPABILITY_FLAG_INF_NAN;
+      DoubleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;
     }
     if (ZE_DEVICE_FP_FLAG_ROUND_TO_NEAREST & ZeDoubleFPCapabilities) {
-      DoubleFPValue |= UR_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
+      DoubleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
     }
     if (ZE_DEVICE_FP_FLAG_ROUND_TO_ZERO & ZeDoubleFPCapabilities) {
-      DoubleFPValue |= UR_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
+      DoubleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
     }
     if (ZE_DEVICE_FP_FLAG_ROUND_TO_INF & ZeDoubleFPCapabilities) {
-      DoubleFPValue |= UR_FP_CAPABILITY_FLAG_ROUND_TO_INF;
+      DoubleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;
     }
     if (ZE_DEVICE_FP_FLAG_FMA & ZeDoubleFPCapabilities) {
-      DoubleFPValue |= UR_FP_CAPABILITY_FLAG_FMA;
+      DoubleFPValue |= UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
     }
     if (ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT & ZeDoubleFPCapabilities) {
-      DoubleFPValue |= UR_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
+      DoubleFPValue |=
+          UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
     }
     return ReturnValue(uint64_t{DoubleFPValue});
   }
diff --git a/sycl/plugins/unified_runtime/ur/adapters/level_zero/ur_loader_interface.cpp b/sycl/plugins/unified_runtime/ur/adapters/level_zero/ur_loader_interface.cpp
@@ -86,7 +86,7 @@ UR_DLLEXPORT ur_result_t UR_APICALL urGetEnqueueProcAddrTable(
   pDdiTable->pfnMemUnmap = nullptr;
   pDdiTable->pfnUSMMemcpy = nullptr;
   pDdiTable->pfnUSMPrefetch = nullptr;
-  pDdiTable->pfnUSMMemAdvise = nullptr;
+  pDdiTable->pfnUSMAdvise = nullptr;
   pDdiTable->pfnUSMFill2D = nullptr;
   pDdiTable->pfnUSMMemcpy2D = nullptr;
   pDdiTable->pfnDeviceGlobalVariableWrite = nullptr;
diff --git a/sycl/plugins/unified_runtime/ur/ur.hpp b/sycl/plugins/unified_runtime/ur/ur.hpp
@@ -43,10 +43,6 @@ const int UR_EXT_DEVICE_INFO_FREE_MEMORY = UR_EXT_DEVICE_INFO_END - 13;
 // const int ZER_EXT_DEVICE_INFO_DEVICE_ID = UR_EXT_DEVICE_INFO_END - 14;
 // const int ZER_EXT_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE =
 //     UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE;
-const int UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES =
-    UR_EXT_DEVICE_INFO_END - 16;
-const int UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES =
-    UR_EXT_DEVICE_INFO_END - 17;
 
 const ur_device_info_t UR_EXT_DEVICE_INFO_OPENCL_C_VERSION =
     (ur_device_info_t)0x103D;

Original file line number	Diff line number	Diff line change
`@@ -662,25 +662,26 @@ ur_result_t urDeviceGetInfo(`
`662`	`662`	`ze_device_fp_flags_t ZeSingleFPCapabilities =`
`663`	`663`	`Device->ZeDeviceModuleProperties->fp32flags;`
`664`	`664`	`if (ZE_DEVICE_FP_FLAG_DENORM & ZeSingleFPCapabilities) {`
`665`		`- SingleFPValue \|= UR_FP_CAPABILITY_FLAG_DENORM;`
	`665`	`+ SingleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;`
`666`	`666`	`}`
`667`	`667`	`if (ZE_DEVICE_FP_FLAG_INF_NAN & ZeSingleFPCapabilities) {`
`668`		`- SingleFPValue \|= UR_FP_CAPABILITY_FLAG_INF_NAN;`
	`668`	`+ SingleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;`
`669`	`669`	`}`
`670`	`670`	`if (ZE_DEVICE_FP_FLAG_ROUND_TO_NEAREST & ZeSingleFPCapabilities) {`
`671`		`- SingleFPValue \|= UR_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;`
	`671`	`+ SingleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;`
`672`	`672`	`}`
`673`	`673`	`if (ZE_DEVICE_FP_FLAG_ROUND_TO_ZERO & ZeSingleFPCapabilities) {`
`674`		`- SingleFPValue \|= UR_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;`
	`674`	`+ SingleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;`
`675`	`675`	`}`
`676`	`676`	`if (ZE_DEVICE_FP_FLAG_ROUND_TO_INF & ZeSingleFPCapabilities) {`
`677`		`- SingleFPValue \|= UR_FP_CAPABILITY_FLAG_ROUND_TO_INF;`
	`677`	`+ SingleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;`
`678`	`678`	`}`
`679`	`679`	`if (ZE_DEVICE_FP_FLAG_FMA & ZeSingleFPCapabilities) {`
`680`		`- SingleFPValue \|= UR_FP_CAPABILITY_FLAG_FMA;`
	`680`	`+ SingleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_FMA;`
`681`	`681`	`}`
`682`	`682`	`if (ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT & ZeSingleFPCapabilities) {`
`683`		`- SingleFPValue \|= UR_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;`
	`683`	`+ SingleFPValue \|=`
	`684`	`+ UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;`
`684`	`685`	`}`
`685`	`686`	`return ReturnValue(uint64_t{SingleFPValue});`
`686`	`687`	`}`
`@@ -689,25 +690,25 @@ ur_result_t urDeviceGetInfo(`
`689`	`690`	`ze_device_fp_flags_t ZeHalfFPCapabilities =`
`690`	`691`	`Device->ZeDeviceModuleProperties->fp16flags;`
`691`	`692`	`if (ZE_DEVICE_FP_FLAG_DENORM & ZeHalfFPCapabilities) {`
`692`		`- HalfFPValue \|= UR_FP_CAPABILITY_FLAG_DENORM;`
	`693`	`+ HalfFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;`
`693`	`694`	`}`
`694`	`695`	`if (ZE_DEVICE_FP_FLAG_INF_NAN & ZeHalfFPCapabilities) {`
`695`		`- HalfFPValue \|= UR_FP_CAPABILITY_FLAG_INF_NAN;`
	`696`	`+ HalfFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;`
`696`	`697`	`}`
`697`	`698`	`if (ZE_DEVICE_FP_FLAG_ROUND_TO_NEAREST & ZeHalfFPCapabilities) {`
`698`		`- HalfFPValue \|= UR_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;`
	`699`	`+ HalfFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;`
`699`	`700`	`}`
`700`	`701`	`if (ZE_DEVICE_FP_FLAG_ROUND_TO_ZERO & ZeHalfFPCapabilities) {`
`701`		`- HalfFPValue \|= UR_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;`
	`702`	`+ HalfFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;`
`702`	`703`	`}`
`703`	`704`	`if (ZE_DEVICE_FP_FLAG_ROUND_TO_INF & ZeHalfFPCapabilities) {`
`704`		`- HalfFPValue \|= UR_FP_CAPABILITY_FLAG_ROUND_TO_INF;`
	`705`	`+ HalfFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;`
`705`	`706`	`}`
`706`	`707`	`if (ZE_DEVICE_FP_FLAG_FMA & ZeHalfFPCapabilities) {`
`707`		`- HalfFPValue \|= UR_FP_CAPABILITY_FLAG_FMA;`
	`708`	`+ HalfFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_FMA;`
`708`	`709`	`}`
`709`	`710`	`if (ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT & ZeHalfFPCapabilities) {`
`710`		`- HalfFPValue \|= UR_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;`
	`711`	`+ HalfFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;`
`711`	`712`	`}`
`712`	`713`	`return ReturnValue(uint64_t{HalfFPValue});`
`713`	`714`	`}`
`@@ -716,25 +717,26 @@ ur_result_t urDeviceGetInfo(`
`716`	`717`	`ze_device_fp_flags_t ZeDoubleFPCapabilities =`
`717`	`718`	`Device->ZeDeviceModuleProperties->fp64flags;`
`718`	`719`	`if (ZE_DEVICE_FP_FLAG_DENORM & ZeDoubleFPCapabilities) {`
`719`		`- DoubleFPValue \|= UR_FP_CAPABILITY_FLAG_DENORM;`
	`720`	`+ DoubleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;`
`720`	`721`	`}`
`721`	`722`	`if (ZE_DEVICE_FP_FLAG_INF_NAN & ZeDoubleFPCapabilities) {`
`722`		`- DoubleFPValue \|= UR_FP_CAPABILITY_FLAG_INF_NAN;`
	`723`	`+ DoubleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;`
`723`	`724`	`}`
`724`	`725`	`if (ZE_DEVICE_FP_FLAG_ROUND_TO_NEAREST & ZeDoubleFPCapabilities) {`
`725`		`- DoubleFPValue \|= UR_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;`
	`726`	`+ DoubleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;`
`726`	`727`	`}`
`727`	`728`	`if (ZE_DEVICE_FP_FLAG_ROUND_TO_ZERO & ZeDoubleFPCapabilities) {`
`728`		`- DoubleFPValue \|= UR_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;`
	`729`	`+ DoubleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;`
`729`	`730`	`}`
`730`	`731`	`if (ZE_DEVICE_FP_FLAG_ROUND_TO_INF & ZeDoubleFPCapabilities) {`
`731`		`- DoubleFPValue \|= UR_FP_CAPABILITY_FLAG_ROUND_TO_INF;`
	`732`	`+ DoubleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;`
`732`	`733`	`}`
`733`	`734`	`if (ZE_DEVICE_FP_FLAG_FMA & ZeDoubleFPCapabilities) {`
`734`		`- DoubleFPValue \|= UR_FP_CAPABILITY_FLAG_FMA;`
	`735`	`+ DoubleFPValue \|= UR_DEVICE_FP_CAPABILITY_FLAG_FMA;`
`735`	`736`	`}`
`736`	`737`	`if (ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT & ZeDoubleFPCapabilities) {`
`737`		`- DoubleFPValue \|= UR_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;`
	`738`	`+ DoubleFPValue \|=`
	`739`	`+ UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;`
`738`	`740`	`}`
`739`	`741`	`return ReturnValue(uint64_t{DoubleFPValue});`
`740`	`742`	`}`