Mirror intel/llvm commits

.github/intel-llvm-mirror-base-commit

@@ -1 +1 @@
-7ab256b26005c9b3ff6fa6d2d1e8ad714468d055
+58f4da62522087e9fe6b90e6ee5f78f550d3ebe5

scripts/templates/ldrddi.cpp.mako

@@ -51,24 +51,21 @@ namespace ur_loader
         %if func_basename == "AdapterGet":
         auto context = getContext();
 
-        size_t adapterIndex = 0;
-        if( nullptr != ${obj['params'][1]['name']} && ${obj['params'][0]['name']} !=0)
-        {
-            for( auto& platform : context->platforms )
-            {
-                if(platform.initStatus != ${X}_RESULT_SUCCESS)
-                    continue;
-                platform.dditable.${th.get_table_name(n, tags, obj)}.${th.make_pfn_name(n, tags, obj)}( 1, &${obj['params'][1]['name']}[adapterIndex], nullptr );
-                adapterIndex++;
-                if (adapterIndex == NumEntries) {
-                    break;
-                }
-            }
+        uint32_t numAdapters = 0;
+        for (auto &platform : context->platforms) {
+            if (platform.initStatus != ${X}_RESULT_SUCCESS)
+                continue;
+
+            uint32_t adapter;
+            ur_adapter_handle_t *adapterHandle = numAdapters < NumEntries ? &${obj['params'][1]['name']}[numAdapters] : nullptr;
+            platform.dditable.${th.get_table_name(n, tags, obj)}.${th.make_pfn_name(n, tags, obj)}( 1, adapterHandle, &adapter );
+
+            numAdapters += adapter;
         }
 
         if( ${obj['params'][2]['name']} != nullptr )
         {
-            *${obj['params'][2]['name']} = static_cast<uint32_t>(context->platforms.size());
+            *${obj['params'][2]['name']} = numAdapters;
         }
 
         return ${X}_RESULT_SUCCESS;

source/adapters/level_zero/adapter.hpp

@@ -37,11 +37,7 @@ struct ur_adapter_handle_t_ : ur::handle_base<ur::level_zero::ddi_getter> {
   uint32_t ZeInitDriversCount = 0;
   bool InitDriversSupported = false;
 
-  ze_result_t ZeInitDriversResult;
-  ze_result_t ZeInitResult;
-  ze_result_t ZesResult;
-  std::optional<ze_result_t> ZeResult;
-  ZeCache<Result<PlatformVec>> PlatformCache;
+  PlatformVec Platforms;
   logger::Logger &logger;
   HMODULE processHandle = nullptr;
 

source/adapters/level_zero/device.cpp

@@ -1583,12 +1583,8 @@ ur_result_t urDeviceCreateWithNativeHandle(
   // a valid Level Zero device.
 
   ur_device_handle_t Dev = nullptr;
-  if (const auto *platforms = GlobalAdapter->PlatformCache->get_value()) {
-    for (const auto &p : *platforms) {
-      Dev = p->getDeviceFromNativeHandle(ZeDevice);
-    }
-  } else {
-    return GlobalAdapter->PlatformCache->get_error();
+  for (const auto &p : GlobalAdapter->Platforms) {
+    Dev = p->getDeviceFromNativeHandle(ZeDevice);
   }
 
   if (Dev == nullptr)

source/adapters/level_zero/platform.cpp

@@ -28,20 +28,15 @@ ur_result_t urPlatformGet(
     uint32_t *NumPlatforms) {
   // Platform handles are cached for reuse. This is to ensure consistent
   // handle pointers across invocations and to improve retrieval performance.
-  if (const auto *cached_platforms = GlobalAdapter->PlatformCache->get_value();
-      cached_platforms) {
-    uint32_t nplatforms = (uint32_t)cached_platforms->size();
-    if (NumPlatforms) {
-      *NumPlatforms = nplatforms;
-    }
+  uint32_t nplatforms = (uint32_t)GlobalAdapter->Platforms.size();
+  if (NumPlatforms) {
+    *NumPlatforms = nplatforms;
+  }
     if (Platforms) {
       for (uint32_t i = 0; i < std::min(nplatforms, NumEntries); ++i) {
-        Platforms[i] = cached_platforms->at(i).get();
+        Platforms[i] = GlobalAdapter->Platforms.at(i).get();
       }
     }
-  } else {
-    return GlobalAdapter->PlatformCache->get_error();
-  }
 
   return UR_RESULT_SUCCESS;
 }

source/adapters/level_zero/v2/queue_immediate_in_order.cpp

@@ -90,9 +90,13 @@ ur_queue_immediate_in_order_t::queueGetInfo(ur_queue_info_t propName,
 }
 
 ur_result_t ur_queue_immediate_in_order_t::queueGetNativeHandle(
-    ur_queue_native_desc_t * /*pDesc*/, ur_native_handle_t *phNativeQueue) {
+    ur_queue_native_desc_t *pDesc, ur_native_handle_t *phNativeQueue) {
   *phNativeQueue = reinterpret_cast<ur_native_handle_t>(
       commandListManager.get_no_lock()->getZeCommandList());
+  if (pDesc && pDesc->pNativeData) {
+    // pNativeData == isImmediateQueue
+    *(reinterpret_cast<int32_t *>(pDesc->pNativeData)) = 1;
+  }
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/level_zero/v2/queue_immediate_out_of_order.cpp

@@ -94,10 +94,14 @@ ur_result_t ur_queue_immediate_out_of_order_t::queueGetInfo(
 }
 
 ur_result_t ur_queue_immediate_out_of_order_t::queueGetNativeHandle(
-    ur_queue_native_desc_t * /*pDesc*/, ur_native_handle_t *phNativeQueue) {
+    ur_queue_native_desc_t *pDesc, ur_native_handle_t *phNativeQueue) {
   *phNativeQueue = reinterpret_cast<ur_native_handle_t>(
       (*commandListManagers.get_no_lock())[getNextCommandListId()]
           .getZeCommandList());
+  if (pDesc && pDesc->pNativeData) {
+    // pNativeData == isImmediateQueue
+    *(reinterpret_cast<int32_t *>(pDesc->pNativeData)) = 1;
+  }
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/offload/kernel.cpp

@@ -21,8 +21,8 @@ urKernelCreate(ur_program_handle_t hProgram, const char *pKernelName,
                ur_kernel_handle_t *phKernel) {
   ur_kernel_handle_t Kernel = new ur_kernel_handle_t_;
 
-  auto Res = olGetKernel(hProgram->OffloadProgram, pKernelName,
-                         &Kernel->OffloadKernel);
+  auto Res = olGetSymbol(hProgram->OffloadProgram, pKernelName,
+                         OL_SYMBOL_KIND_KERNEL, &Kernel->OffloadKernel);
 
   if (Res != OL_SUCCESS) {
     delete Kernel;

source/adapters/offload/kernel.hpp

@@ -77,6 +77,6 @@ struct ur_kernel_handle_t_ : RefCounted {
     }
   };
 
-  ol_kernel_handle_t OffloadKernel;
+  ol_symbol_handle_t OffloadKernel;
   OffloadKernelArguments Args{};
 };

source/adapters/offload/program.cpp

@@ -108,7 +108,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramCreateWithBinary(
                                        phProgram);
   }
 
-  ur_program_handle_t Program = new ur_program_handle_t_();
+  ur_program_handle_t Program = new ur_program_handle_t_{};
+  Program->URContext = hContext;
+  Program->Binary = RealBinary;
+  Program->BinarySizeInBytes = RealLength;
   auto Res = olCreateProgram(hContext->Device->OffloadDevice, RealBinary,
                              RealLength, &Program->OffloadProgram);
 
@@ -137,6 +140,19 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramBuildExp(ur_program_handle_t,
   return UR_RESULT_SUCCESS;
 }
 
+UR_APIEXPORT ur_result_t UR_APICALL urProgramCompile(ur_context_handle_t,
+                                                     ur_program_handle_t,
+                                                     const char *) {
+  // Do nothing, program is built upon creation
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL
+urProgramCreateWithIL(ur_context_handle_t, const void *, size_t,
+                      const ur_program_properties_t *, ur_program_handle_t *) {
+  return UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE;
+}
+
 UR_APIEXPORT ur_result_t UR_APICALL
 urProgramGetInfo(ur_program_handle_t hProgram, ur_program_info_t propName,
                  size_t propSize, void *pPropValue, size_t *pPropSizeRet) {
@@ -145,8 +161,42 @@ urProgramGetInfo(ur_program_handle_t hProgram, ur_program_info_t propName,
   switch (propName) {
   case UR_PROGRAM_INFO_REFERENCE_COUNT:
     return ReturnValue(hProgram->RefCount.load());
-  default:
+  case UR_PROGRAM_INFO_CONTEXT:
+    return ReturnValue(hProgram->URContext);
+  case UR_PROGRAM_INFO_NUM_DEVICES:
+    return ReturnValue(1);
+  case UR_PROGRAM_INFO_DEVICES:
+    return ReturnValue(&hProgram->URContext->Device, 1);
+  case UR_PROGRAM_INFO_IL:
+    return ReturnValue(reinterpret_cast<const char *>(0), 0);
+  case UR_PROGRAM_INFO_BINARY_SIZES:
+    return ReturnValue(&hProgram->BinarySizeInBytes, 1);
+  case UR_PROGRAM_INFO_BINARIES: {
+    if (!pPropValue && !pPropSizeRet) {
+      return UR_RESULT_ERROR_INVALID_NULL_POINTER;
+    }
+
+    if (pPropValue != nullptr) {
+      if (propSize < sizeof(void *)) {
+        return UR_RESULT_ERROR_INVALID_SIZE;
+      }
+
+      std::memcpy(*reinterpret_cast<void **>(pPropValue), hProgram->Binary,
+                  hProgram->BinarySizeInBytes);
+    }
+
+    if (pPropSizeRet != nullptr) {
+      *pPropSizeRet = sizeof(void *);
+    }
+    break;
+  }
+  case UR_PROGRAM_INFO_NUM_KERNELS:
+  case UR_PROGRAM_INFO_KERNEL_NAMES:
+    // Program introspection is not available for liboffload (or generally,
+    // amdgpu/cuda)
     return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+  default:
+    return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 
   return UR_RESULT_SUCCESS;

source/adapters/offload/program.hpp

@@ -17,4 +17,7 @@
 
 struct ur_program_handle_t_ : RefCounted {
   ol_program_handle_t OffloadProgram;
+  ur_context_handle_t URContext;
+  const uint8_t *Binary;
+  size_t BinarySizeInBytes;
 };

source/adapters/offload/ur_interface_loader.cpp

@@ -86,9 +86,9 @@ UR_DLLEXPORT ur_result_t UR_APICALL urGetProgramProcAddrTable(
     return result;
   }
   pDdiTable->pfnBuild = urProgramBuild;
-  pDdiTable->pfnCompile = nullptr;
+  pDdiTable->pfnCompile = urProgramCompile;
   pDdiTable->pfnCreateWithBinary = urProgramCreateWithBinary;
-  pDdiTable->pfnCreateWithIL = nullptr;
+  pDdiTable->pfnCreateWithIL = urProgramCreateWithIL;
   pDdiTable->pfnCreateWithNativeHandle = urProgramCreateWithNativeHandle;
   pDdiTable->pfnGetBuildInfo = nullptr;
   pDdiTable->pfnGetFunctionPointer = nullptr;

source/loader/ur_adapter_registry.hpp

@@ -355,22 +355,6 @@ class AdapterRegistry {
     }
 
     for (const auto &adapterName : adapterNames) {
-      // Skip legacy L0 adapter if the v2 adapter is requested, and vice versa.
-      if (std::string(adapterName).find("level_zero") != std::string::npos) {
-        auto v2Requested = getenv_tobool("UR_LOADER_USE_LEVEL_ZERO_V2", false);
-        v2Requested |= getenv_tobool("SYCL_UR_USE_LEVEL_ZERO_V2", false);
-        auto v2Adapter =
-            std::string(adapterName).find("v2") != std::string::npos;
-
-        if (v2Requested != v2Adapter) {
-          UR_LOG(INFO, "The adapter '{}' is skipped because {} {}.",
-                 adapterName,
-                 "UR_LOADER_USE_LEVEL_ZERO_V2 or SYCL_UR_USE_LEVEL_ZERO_V2",
-                 v2Requested ? "is set" : "is not set");
-          continue;
-        }
-      }
-
       std::vector<fs::path> loadPaths;
 
       // Adapter search order:

test/conformance/testing/include/uur/checks.h

@@ -41,7 +41,8 @@ inline std::ostream &operator<<(std::ostream &out, const Result &result) {
   do {                                                                         \
     auto status = ret;                                                         \
     if (status == UR_RESULT_ERROR_UNSUPPORTED_FEATURE ||                       \
-        status == UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION) {                   \
+        status == UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION ||                   \
+        status == UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE) {                    \
       GTEST_SKIP();                                                            \
     } else {                                                                   \
       ASSERT_EQ(status, UR_RESULT_SUCCESS);                                    \