Merge branch 'sycl' into use-device-usm-for-rtl-data

Author: zhaomaosu

scripts/benchmarks/benches/compute.py

@@ -20,7 +20,7 @@ def setup(self):
         if self.built:
             return
 
-        repo_path = git_clone(self.directory, "compute-benchmarks-repo", "https://github.com/intel/compute-benchmarks.git", "08c41bb8bc1762ad53c6194df6d36bfcceff4aa2")
+        repo_path = git_clone(self.directory, "compute-benchmarks-repo", "https://github.com/intel/compute-benchmarks.git", "aa6a3b2108bb86202b654ad28129156fa746d41d")
         build_path = create_build_path(self.directory, 'compute-benchmarks-build')
 
         configure_command = [
@@ -231,3 +231,26 @@ def bin_args(self) -> list[str]:
             "--numberOfElementsY=256",
             "--numberOfElementsZ=256",
         ]
+
+class MemcpyExecute(ComputeBenchmark):
+    def __init__(self, bench, numOpsPerThread, numThreads, allocSize, iterations):
+        self.numOpsPerThread = numOpsPerThread
+        self.numThreads = numThreads
+        self.allocSize = allocSize
+        self.iterations = iterations
+        super().__init__(bench, "multithread_benchmark_ur", "MemcpyExecute")
+
+    def name(self):
+        return f"multithread_benchmark_ur MemcpyExecute opsPerThread:{self.numOpsPerThread}, numThreads:{self.numThreads}, allocSize:{self.allocSize}"
+
+    def bin_args(self) -> list[str]:
+        return [
+            "--Ioq=1",
+            "--UseEvents=1",
+            "--MeasureCompletion=1",
+            "--UseQueuePerThread=1",
+            f"--AllocSize={self.allocSize}",
+            f"--NumThreads={self.numThreads}",
+            f"--NumOpsPerThread={self.numOpsPerThread}",
+            f"--iterations={self.iterations}"
+        ]

scripts/benchmarks/main.py

@@ -44,6 +44,12 @@ def main(directory, additional_env_vars, save_name, compare_names, filter):
         ExecImmediateCopyQueue(cb, 0, 1, 'Device', 'Device', 1024),
         ExecImmediateCopyQueue(cb, 1, 1, 'Device', 'Host', 1024),
         VectorSum(cb),
+        MemcpyExecute(cb, 400, 8, 1024, 100),
+        MemcpyExecute(cb, 400, 8, 102400, 10),
+        MemcpyExecute(cb, 500, 8, 102400, 10),
+        MemcpyExecute(cb, 400, 1, 1024, 1000),
+        MemcpyExecute(cb, 10, 16, 1024, 1000),
+        MemcpyExecute(cb, 10, 16, 102400, 100),
 
         # *** Velocity benchmarks
         Hashtable(vb),

source/adapters/level_zero/adapter.cpp

@@ -144,6 +144,43 @@ ur_result_t adapterStateInit() {
   return UR_RESULT_SUCCESS;
 }
 
+/*
+This constructor initializes the `ur_adapter_handle_t_` object and
+sets up the environment for Level Zero (L0) initialization.
+The behavior of the initialization process is influenced by two
+environment variables:
+`UR_L0_ENABLE_SYSMAN_ENV_DEFAULT` and `UR_L0_ENABLE_ZESINIT_DEFAULT`.
+
+| Environment Variable           | Value | Behavior                   |
+|--------------------------------|-------|----------------------------|
+| UR_L0_ENABLE_SYSMAN_ENV_DEFAULT| 1     | Enables the default SysMan |
+|                                |       | environment initialization |
+|                                |       | by setting                 |
+|                                |       | `ZES_ENABLE_SYSMAN` to "1".|
+|                                | 0     | Disables the default SysMan|
+|                                |       | environment initialization.|
+|                                | unset | Defaults to 1, enabling the|
+|                                |       | SysMan environment         |
+|                                |       | initialization.            |
+| UR_L0_ENABLE_ZESINIT_DEFAULT   | 1     | Enables the default SysMan |
+|                                |       | initialization by loading  |
+|                                |       | SysMan-related functions   |
+|                                |       | and calling `zesInit`.     |
+|                                | 0     | Disables the default SysMan|
+|                                |       | initialization with zesInit|
+|                                | unset | Defaults to 0, disabling   |
+|                                |       | the SysMan initialization  |
+|                                |       | thru zesInit.              |
+
+Behavior Summary:
+- If `UR_L0_ENABLE_SYSMAN_ENV_DEFAULT` is set to 1 or is unset,
+  `ZES_ENABLE_SYSMAN` is set to "1".
+- If `UR_L0_ENABLE_ZESINIT_DEFAULT` is set to 1 and
+  `UR_L0_ENABLE_SYSMAN_ENV_DEFAULT` is not set to 1,
+  SysMan-related functions are loaded and `zesInit` is called.
+- If `UR_L0_ENABLE_ZESINIT_DEFAULT` is set to 0 or is unset,
+  SysMan initialization is skipped.
+*/
 ur_adapter_handle_t_::ur_adapter_handle_t_()
     : logger(logger::get_logger("level_zero")) {
 
@@ -169,6 +206,14 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
       return;
     }
 
+    // Check if the user has disabled the default L0 Env initialization.
+    const int UrSysManEnvInitEnabled = [] {
+      const char *UrRet = std::getenv("UR_L0_ENABLE_SYSMAN_ENV_DEFAULT");
+      if (!UrRet)
+        return 1;
+      return std::atoi(UrRet);
+    }();
+
     // initialize level zero only once.
     if (GlobalAdapter->ZeResult == std::nullopt) {
       // Setting these environment variables before running zeInit will enable
@@ -196,6 +241,11 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
       if (UrL0InitAllDrivers) {
         L0InitFlags |= ZE_INIT_FLAG_VPU_ONLY;
       }
+
+      // Set ZES_ENABLE_SYSMAN by default if the user has not set it.
+      if (UrSysManEnvInitEnabled) {
+        setEnvVar("ZES_ENABLE_SYSMAN", "1");
+      }
       logger::debug("\nzeInit with flags value of {}\n",
                     static_cast<int>(L0InitFlags));
       GlobalAdapter->ZeResult = ZE_CALL_NOCHECK(zeInit, (L0InitFlags));
@@ -223,15 +273,29 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
 #else
     HMODULE processHandle = nullptr;
 #endif
-    GlobalAdapter->getDeviceByUUIdFunctionPtr =
-        (zes_pfnDriverGetDeviceByUuidExp_t)ur_loader::LibLoader::getFunctionPtr(
-            processHandle, "zesDriverGetDeviceByUuidExp");
-    GlobalAdapter->getSysManDriversFunctionPtr =
-        (zes_pfnDriverGet_t)ur_loader::LibLoader::getFunctionPtr(
-            processHandle, "zesDriverGet");
-    GlobalAdapter->sysManInitFunctionPtr =
-        (zes_pfnInit_t)ur_loader::LibLoader::getFunctionPtr(processHandle,
-                                                            "zesInit");
+
+    // Check if the user has enabled the default L0 SysMan initialization.
+    const int UrSysmanZesinitEnable = [] {
+      const char *UrRet = std::getenv("UR_L0_ENABLE_ZESINIT_DEFAULT");
+      if (!UrRet)
+        return 0;
+      return std::atoi(UrRet);
+    }();
+
+    // Enable zesInit by default only if ZES_ENABLE_SYSMAN has not been set by
+    // default and UrSysmanZesinitEnable is true.
+    if (UrSysmanZesinitEnable && !UrSysManEnvInitEnabled) {
+      GlobalAdapter->getDeviceByUUIdFunctionPtr =
+          (zes_pfnDriverGetDeviceByUuidExp_t)
+              ur_loader::LibLoader::getFunctionPtr(
+                  processHandle, "zesDriverGetDeviceByUuidExp");
+      GlobalAdapter->getSysManDriversFunctionPtr =
+          (zes_pfnDriverGet_t)ur_loader::LibLoader::getFunctionPtr(
+              processHandle, "zesDriverGet");
+      GlobalAdapter->sysManInitFunctionPtr =
+          (zes_pfnInit_t)ur_loader::LibLoader::getFunctionPtr(processHandle,
+                                                              "zesInit");
+    }
     if (GlobalAdapter->getDeviceByUUIdFunctionPtr &&
         GlobalAdapter->getSysManDriversFunctionPtr &&
         GlobalAdapter->sysManInitFunctionPtr) {

source/adapters/level_zero/kernel.cpp

@@ -746,7 +746,7 @@ ur_result_t urKernelGetInfo(
       char *attributes = new char[Size];
       ZE2UR_CALL(zeKernelGetSourceAttributes,
                  (Kernel->ZeKernel, &Size, &attributes));
-      auto Res = ReturnValue(attributes);
+      auto Res = ReturnValue(static_cast<const char *>(attributes));
       delete[] attributes;
       return Res;
     } catch (const std::bad_alloc &) {

source/adapters/opencl/adapter.cpp

@@ -8,16 +8,49 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "adapter.hpp"
 #include "common.hpp"
-#include "logger/ur_logger.hpp"
+#include "ur/ur.hpp"
+
+#ifdef _MSC_VER
+#include <Windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+ur_adapter_handle_t_::ur_adapter_handle_t_() {
+#ifdef _MSC_VER
+  // Loading OpenCL.dll increments the libraries internal reference count.
+  auto handle = LoadLibraryA("OpenCL.dll");
+
+#define CL_CORE_FUNCTION(FUNC)                                                 \
+  FUNC = reinterpret_cast<decltype(::FUNC) *>(GetProcAddress(handle, "FUNC"));
+#include "core_functions.def"
+#undef CL_CORE_FUNCTION
+
+  // So we can safely decrement it here wihtout actually unloading OpenCL.dll.
+  FreeLibrary(handle);
+#else
+  // Loading libOpenCL.so to get the library handle but don't dlclose it as
+  // this causes a segfault when attempting to call any OpenCL entry point.
+  auto handle = dlopen("libOpenCL.so", RTLD_LOCAL);
+
+#define CL_CORE_FUNCTION(FUNC)                                                 \
+  FUNC = reinterpret_cast<decltype(::FUNC) *>(dlsym(handle, #FUNC));
+#include "core_functions.def"
+#undef CL_CORE_FUNCTION
+
+#endif
+}
 
-struct ur_adapter_handle_t_ {
-  std::atomic<uint32_t> RefCount = 0;
-  std::mutex Mutex;
-  logger::Logger &log = logger::get_logger("opencl");
-};
+static ur_adapter_handle_t adapter = nullptr;
 
-static ur_adapter_handle_t_ *adapter = nullptr;
+ur_adapter_handle_t ur::cl::getAdapter() {
+  if (!adapter) {
+    die("OpenCL adapter used before initalization or after destruction");
+  }
+  return adapter;
+}
 
 static void globalAdapterShutdown() {
   if (cl_ext::ExtFuncPtrCache) {

source/adapters/opencl/adapter.hpp

@@ -8,6 +8,26 @@
 //
 //===----------------------------------------------------------------------===//
 
-struct ur_adapter_handle_t_;
+#include "CL/cl.h"
+#include "logger/ur_logger.hpp"
 
-extern ur_adapter_handle_t_ adapter;
+struct ur_adapter_handle_t_ {
+  ur_adapter_handle_t_();
+
+  std::atomic<uint32_t> RefCount = 0;
+  std::mutex Mutex;
+  logger::Logger &log = logger::get_logger("opencl");
+
+  // Function pointers to core OpenCL entry points which may not exist in older
+  // versions of the OpenCL-ICD-Loader are tracked here and initialized by
+  // dynamically loading the symbol by name.
+#define CL_CORE_FUNCTION(FUNC) decltype(::FUNC) *FUNC = nullptr;
+#include "core_functions.def"
+#undef CL_CORE_FUNCTION
+};
+
+namespace ur {
+namespace cl {
+ur_adapter_handle_t getAdapter();
+} // namespace cl
+} // namespace ur

source/adapters/opencl/common.hpp

@@ -239,10 +239,6 @@ cl_int(CL_API_CALL *)(cl_command_queue, cl_program, const char *, cl_bool,
                       size_t, size_t, void *, cl_uint, const cl_event *,
                       cl_event *);
 
-using clSetProgramSpecializationConstant_fn = CL_API_ENTRY
-cl_int(CL_API_CALL *)(cl_program program, cl_uint spec_id, size_t spec_size,
-                      const void *spec_value);
-
 using clEnqueueReadHostPipeINTEL_fn = CL_API_ENTRY
 cl_int(CL_API_CALL *)(cl_command_queue queue, cl_program program,
                       const char *pipe_symbol, cl_bool blocking, void *ptr,

source/adapters/opencl/context.cpp

@@ -9,6 +9,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "context.hpp"
+#include "adapter.hpp"
 
 #include <mutex>
 #include <set>
@@ -169,6 +170,13 @@ 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) {
+  if (!ur::cl::getAdapter()->clSetContextDestructorCallback) {
+    ur::cl::getAdapter()->log.warning(
+        "clSetContextDestructorCallback not found, consider upgrading the "
+        "OpenCL-ICD-Loader to the latest version.");
+    return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  }
+
   static std::unordered_map<ur_context_handle_t,
                             std::set<ur_context_extended_deleter_t>>
       ContextCallbackMap;
@@ -212,7 +220,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urContextSetExtendedDeleter(
     auto *C = static_cast<ContextCallback *>(pUserData);
     C->execute();
   };
-  CL_RETURN_ON_FAILURE(clSetContextDestructorCallback(
+  CL_RETURN_ON_FAILURE(ur::cl::getAdapter()->clSetContextDestructorCallback(
       cl_adapter::cast<cl_context>(hContext), ClCallback, Callback));
 
   return UR_RESULT_SUCCESS;

source/adapters/opencl/core_functions.def

@@ -0,0 +1,14 @@
+// Introduced in OpenCL 2.0
+// TODO: clCreateCommandQueueWithProperties
+
+// Introduced in OpenCL 2.1
+// TODO: clGetKernelSubGroupInfo
+// TODO: clCreateProgramWithIL
+// TODO: clGetHostTimer
+// TODO: clGetDeviceAndHostTimer
+
+// Introduced in OpenCL 2.2
+CL_CORE_FUNCTION(clSetProgramSpecializationConstant)
+
+// Introduced in OpenCL 3.0
+CL_CORE_FUNCTION(clSetContextDestructorCallback)

source/adapters/opencl/extension_functions.def

@@ -13,7 +13,6 @@ CL_EXTENSION_FUNC(clEnqueueWriteGlobalVariable)
 CL_EXTENSION_FUNC(clEnqueueReadGlobalVariable)
 CL_EXTENSION_FUNC(clEnqueueReadHostPipeINTEL)
 CL_EXTENSION_FUNC(clEnqueueWriteHostPipeINTEL)
-CL_EXTENSION_FUNC(clSetProgramSpecializationConstant)
 CL_EXTENSION_FUNC(clCreateCommandBufferKHR)
 CL_EXTENSION_FUNC(clRetainCommandBufferKHR)
 CL_EXTENSION_FUNC(clReleaseCommandBufferKHR)