Merge branch 'main' into num_compute_units

Author: dyniols

scripts/core/enqueue.yml

@@ -782,7 +782,9 @@ desc: "Enqueue a command to fill an image object with specified color"
 class: $xEnqueue
 name: MemImageFill
 ordinal: "0"
-version: "9999.0" # see #50
+# Will not be generated
+# https://github.com/oneapi-src/unified-runtime/issues/50
+version: "9999.0"
 details:
     - "Currently not implemented in Level Zero"
     - "TODO: add a driver function in Level Zero?"
@@ -919,7 +921,9 @@ type: function
 desc: "Enqueue a command to map a region of the image object into the host address space and return a pointer to the mapped region"
 class: $xEnqueue
 name: MemImageMap
-version: "9999.0" # See #50
+# Will not be generated
+# https://github.com/oneapi-src/unified-runtime/issues/50
+version: "9999.0"
 ordinal: "0"
 details:
     - "Input parameter blockingMap indicates if the map is blocking or non-blocking."

scripts/core/event.yml

@@ -43,14 +43,18 @@ etors:
       desc: Event created by $xEnqueueMemImageWrite
     - name: MEM_IMAGE_COPY
       desc: Event created by $xEnqueueMemImageCopy
+    # Will not be generated
+    # https://github.com/oneapi-src/unified-runtime/issues/50
     - name: MEM_IMAGE_FILL
       desc: Event created by $xEnqueueMemImageFill
-      version: "9999.0" # See #50
+      version: "9999.0"
     - name: MEM_BUFFER_MAP
       desc: Event created by $xEnqueueMemBufferMap
+    # Will not be generated
+    # https://github.com/oneapi-src/unified-runtime/issues/50
     - name: MEM_IMAGE_MAP
       desc: Event created by $xEnqueueMemImageMap
-      version: "9999.0" # See #50
+      version: "9999.0"
     - name: MEM_UNMAP
       desc: Event created by $xEnqueueMemUnmap
     - name: USM_FILL

scripts/templates/ldrddi.cpp.mako

@@ -273,11 +273,17 @@ namespace ur_loader
 
         %endif
         %endif
-        ## Before we can re-enable the releases we will need ref-counted object_t.
-        ## See unified-runtime github issue #1784
-        ##%if item['release']:
-        ##// release loader handle
-        ##${item['factory']}.release( ${item['name']} );
+        ## Possibly handle release/retain ref counting - there are no ur_exp-image factories
+        %if 'factory' in item and '_exp_image_' not in item['factory']:
+            %if item['release']:
+            // release loader handle
+            context->factories.${item['factory']}.release( ${item['name']} );
+            %endif
+            %if item['retain']:
+            // increment refcount of handle
+            context->factories.${item['factory']}.retain( ${item['name']} );
+            %endif
+        %endif
         %if not item['release'] and not item['retain'] and not '_native_object_' in item['obj'] or th.make_func_name(n, tags, obj) == 'urPlatformCreateWithNativeHandle':
         try
         {

source/adapters/cuda/adapter.cpp

@@ -38,7 +38,8 @@ class ur_legacy_sink : public logger::Sink {
 };
 
 // FIXME: Remove the default log level when querying logging info is supported
-// through UR entry points. See #1330.
+// through UR entry points.
+// https://github.com/oneapi-src/unified-runtime/issues/1330
 ur_adapter_handle_t_::ur_adapter_handle_t_()
     : logger(logger::get_logger("cuda",
                                 /*default_log_level*/ logger::Level::ERR)) {

source/adapters/cuda/memory.cpp

@@ -17,7 +17,8 @@
 
 /// Creates a UR Memory object using a CUDA memory allocation.
 /// Can trigger a manual copy depending on the mode.
-/// \TODO Implement USE_HOST_PTR using cuHostRegister - See #9789
+/// \TODO Implement USE_HOST_PTR using cuHostRegister
+/// https://github.com/intel/llvm/issues/9789
 ///
 UR_APIEXPORT ur_result_t UR_APICALL urMemBufferCreate(
     ur_context_handle_t hContext, ur_mem_flags_t flags, size_t size,

source/adapters/hip/adapter.cpp

@@ -37,7 +37,8 @@ class ur_legacy_sink : public logger::Sink {
 };
 
 // FIXME: Remove the default log level when querying logging info is supported
-// through UR entry points. See #1330.
+// through UR entry points.
+// https://github.com/oneapi-src/unified-runtime/issues/1330
 ur_adapter_handle_t_::ur_adapter_handle_t_()
     : logger(
           logger::get_logger("hip", /*default_log_level*/ logger::Level::ERR)) {

source/adapters/hip/memory.cpp

@@ -90,7 +90,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemRelease(ur_mem_handle_t hMem) {
 
 /// Creates a UR Memory object using a HIP memory allocation.
 /// Can trigger a manual copy depending on the mode.
-/// \TODO Implement USE_HOST_PTR using hipHostRegister - See #9789
+/// \TODO Implement USE_HOST_PTR using hipHostRegister
+/// https://github.com/intel/llvm/issues/9789
 UR_APIEXPORT ur_result_t UR_APICALL urMemBufferCreate(
     ur_context_handle_t hContext, ur_mem_flags_t flags, size_t size,
     const ur_buffer_properties_t *pProperties, ur_mem_handle_t *phBuffer) {

source/adapters/level_zero/v2/api.cpp

@@ -103,16 +103,6 @@ ur_result_t urKernelSetSpecializationConstants(
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t urKernelGetSuggestedLocalWorkSize(ur_kernel_handle_t hKernel,
-                                              ur_queue_handle_t hQueue,
-                                              uint32_t numWorkDim,
-                                              const size_t *pGlobalWorkOffset,
-                                              const size_t *pGlobalWorkSize,
-                                              size_t *pSuggestedLocalWorkSize) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t urEventSetCallback(ur_event_handle_t hEvent,
                                ur_execution_info_t execStatus,
                                ur_event_callback_t pfnNotify, void *pUserData) {
@@ -484,14 +474,6 @@ ur_result_t urCommandBufferCommandGetInfoExp(
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t urKernelSuggestMaxCooperativeGroupCountExp(
-    ur_kernel_handle_t hKernel, ur_device_handle_t hDevice, uint32_t workDim,
-    const size_t *pLocalWorkSize, size_t dynamicSharedMemorySize,
-    uint32_t *pGroupCountRet) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t urUSMImportExp(ur_context_handle_t hContext, void *pMem,
                            size_t size) {
   logger::error("{} function not implemented!", __FUNCTION__);

source/adapters/level_zero/v2/kernel.cpp

@@ -13,6 +13,7 @@
 #include "context.hpp"
 #include "kernel.hpp"
 #include "memory.hpp"
+#include "queue_api.hpp"
 
 #include "../device.hpp"
 #include "../helpers/kernel_helpers.hpp"
@@ -624,4 +625,48 @@ ur_result_t urKernelGetInfo(ur_kernel_handle_t hKernel,
 } catch (...) {
   return exceptionToResult(std::current_exception());
 }
+
+ur_result_t urKernelGetSuggestedLocalWorkSize(
+    ur_kernel_handle_t hKernel, ur_queue_handle_t hQueue, uint32_t workDim,
+    [[maybe_unused]] const size_t *pGlobalWorkOffset,
+    const size_t *pGlobalWorkSize, size_t *pSuggestedLocalWorkSize) {
+  UR_ASSERT(workDim > 0, UR_RESULT_ERROR_INVALID_WORK_DIMENSION);
+  UR_ASSERT(workDim < 4, UR_RESULT_ERROR_INVALID_WORK_DIMENSION);
+  UR_ASSERT(pSuggestedLocalWorkSize != nullptr,
+            UR_RESULT_ERROR_INVALID_NULL_POINTER);
+
+  uint32_t localWorkSize[3];
+  size_t globalWorkSize3D[3]{1, 1, 1};
+  std::copy(pGlobalWorkSize, pGlobalWorkSize + workDim, globalWorkSize3D);
+
+  ur_device_handle_t hDevice;
+  UR_CALL(hQueue->queueGetInfo(UR_QUEUE_INFO_DEVICE, sizeof(hDevice),
+                               reinterpret_cast<void *>(&hDevice), nullptr));
+
+  UR_CALL(getSuggestedLocalWorkSize(hDevice, hKernel->getZeHandle(hDevice),
+                                    globalWorkSize3D, localWorkSize));
+
+  std::copy(localWorkSize, localWorkSize + workDim, pSuggestedLocalWorkSize);
+  return UR_RESULT_SUCCESS;
+}
+
+ur_result_t urKernelSuggestMaxCooperativeGroupCountExp(
+    ur_kernel_handle_t hKernel, ur_device_handle_t hDevice, uint32_t workDim,
+    const size_t *pLocalWorkSize, size_t dynamicSharedMemorySize,
+    uint32_t *pGroupCountRet) {
+  (void)dynamicSharedMemorySize;
+
+  uint32_t wg[3];
+  wg[0] = ur_cast<uint32_t>(pLocalWorkSize[0]);
+  wg[1] = workDim >= 2 ? ur_cast<uint32_t>(pLocalWorkSize[1]) : 1;
+  wg[2] = workDim == 3 ? ur_cast<uint32_t>(pLocalWorkSize[2]) : 1;
+  ZE2UR_CALL(zeKernelSetGroupSize,
+             (hKernel->getZeHandle(hDevice), wg[0], wg[1], wg[2]));
+
+  uint32_t totalGroupCount = 0;
+  ZE2UR_CALL(zeKernelSuggestMaxCooperativeGroupCount,
+             (hKernel->getZeHandle(hDevice), &totalGroupCount));
+  *pGroupCountRet = totalGroupCount;
+  return UR_RESULT_SUCCESS;
+}
 } // namespace ur::level_zero

source/common/ur_singleton.hpp

@@ -11,20 +11,26 @@
 #ifndef UR_SINGLETON_H
 #define UR_SINGLETON_H 1
 
+#include <cassert>
 #include <memory>
 #include <mutex>
 #include <unordered_map>
 
 //////////////////////////////////////////////////////////////////////////
 /// a abstract factory for creation of singleton objects
 template <typename singleton_tn, typename key_tn> class singleton_factory_t {
+    struct entry_t {
+        std::unique_ptr<singleton_tn> ptr;
+        size_t ref_count;
+    };
+
   protected:
     using singleton_t = singleton_tn;
     using key_t = typename std::conditional<std::is_pointer<key_tn>::value,
                                             size_t, key_tn>::type;
 
     using ptr_t = std::unique_ptr<singleton_t>;
-    using map_t = std::unordered_map<key_t, ptr_t>;
+    using map_t = std::unordered_map<key_t, entry_t>;
 
     std::mutex mut; ///< lock for thread-safety
     map_t map;      ///< single instance of singleton for each unique key
@@ -60,16 +66,31 @@ template <typename singleton_tn, typename key_tn> class singleton_factory_t {
         if (map.end() == iter) {
             auto ptr =
                 std::make_unique<singleton_t>(std::forward<Ts>(params)...);
-            iter = map.emplace(key, std::move(ptr)).first;
+            iter = map.emplace(key, entry_t{std::move(ptr), 0}).first;
+        } else {
+            iter->second.ref_count++;
         }
-        return iter->second.get();
+        return iter->second.ptr.get();
+    }
+
+    void retain(key_tn key) {
+        std::lock_guard<std::mutex> lk(mut);
+        auto iter = map.find(getKey(key));
+        assert(iter != map.end());
+        iter->second.ref_count++;
     }
 
     //////////////////////////////////////////////////////////////////////////
     /// once the key is no longer valid, release the singleton
     void release(key_tn key) {
         std::lock_guard<std::mutex> lk(mut);
-        map.erase(getKey(key));
+        auto iter = map.find(getKey(key));
+        assert(iter != map.end());
+        if (iter->second.ref_count == 0) {
+            map.erase(iter);
+        } else {
+            iter->second.ref_count--;
+        }
     }
 
     void clear() {