[L0 v2] Implement urKernelSetExecInfo

Author: igchor

source/adapters/level_zero/v2/api.cpp

@@ -250,15 +250,6 @@ ur_result_t urKernelGetSubGroupInfo(ur_kernel_handle_t hKernel,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t
-urKernelSetExecInfo(ur_kernel_handle_t hKernel, ur_kernel_exec_info_t propName,
-                    size_t propSize,
-                    const ur_kernel_exec_info_properties_t *pProperties,
-                    const void *pPropValue) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t
 urKernelSetArgSampler(ur_kernel_handle_t hKernel, uint32_t argIndex,
                       const ur_kernel_arg_sampler_properties_t *pProperties,

source/adapters/level_zero/v2/kernel.cpp

@@ -197,6 +197,48 @@ ur_program_handle_t ur_kernel_handle_t_::getProgramHandle() const {
   return hProgram;
 }
 
+ur_result_t ur_kernel_handle_t_::setExecInfo(ur_kernel_exec_info_t propName,
+                                             const void *pPropValue) {
+  std::scoped_lock<ur_shared_mutex> Guard(Mutex);
+
+  for (auto &kernel : deviceKernels) {
+    if (!kernel.has_value())
+      continue;
+    if (propName == UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS &&
+        *(static_cast<const ur_bool_t *>(pPropValue)) == true) {
+      // The whole point for users really was to not need to know anything
+      // about the types of allocations kernel uses. So in DPC++ we always
+      // just set all 3 modes for each kernel.
+      ze_kernel_indirect_access_flags_t indirectFlags =
+          ZE_KERNEL_INDIRECT_ACCESS_FLAG_HOST |
+          ZE_KERNEL_INDIRECT_ACCESS_FLAG_DEVICE |
+          ZE_KERNEL_INDIRECT_ACCESS_FLAG_SHARED;
+      ZE2UR_CALL(zeKernelSetIndirectAccess,
+                 (kernel->hKernel.get(), indirectFlags));
+    } else if (propName == UR_KERNEL_EXEC_INFO_CACHE_CONFIG) {
+      ze_cache_config_flag_t zeCacheConfig{};
+      auto cacheConfig =
+          *(static_cast<const ur_kernel_cache_config_t *>(pPropValue));
+      if (cacheConfig == UR_KERNEL_CACHE_CONFIG_LARGE_SLM)
+        zeCacheConfig = ZE_CACHE_CONFIG_FLAG_LARGE_SLM;
+      else if (cacheConfig == UR_KERNEL_CACHE_CONFIG_LARGE_DATA)
+        zeCacheConfig = ZE_CACHE_CONFIG_FLAG_LARGE_DATA;
+      else if (cacheConfig == UR_KERNEL_CACHE_CONFIG_DEFAULT)
+        zeCacheConfig = static_cast<ze_cache_config_flag_t>(0);
+      else
+        // Unexpected cache configuration value.
+        return UR_RESULT_ERROR_INVALID_VALUE;
+      ZE2UR_CALL(zeKernelSetCacheConfig,
+                 (kernel->hKernel.get(), zeCacheConfig););
+    } else {
+      logger::error("urKernelSetExecInfo: unsupported ParamName");
+      return UR_RESULT_ERROR_INVALID_VALUE;
+    }
+  }
+
+  return UR_RESULT_SUCCESS;
+}
+
 namespace ur::level_zero {
 ur_result_t urKernelCreate(ur_program_handle_t hProgram,
                            const char *pKernelName,
@@ -248,4 +290,19 @@ ur_result_t urKernelSetArgPointer(
   TRACK_SCOPE_LATENCY("ur_kernel_handle_t_::setArgPointer");
   return hKernel->setArgPointer(argIndex, pProperties, pArgValue);
 }
+
+ur_result_t urKernelSetExecInfo(
+    ur_kernel_handle_t hKernel,     ///< [in] handle of the kernel object
+    ur_kernel_exec_info_t propName, ///< [in] name of the execution attribute
+    size_t propSize,                ///< [in] size in byte the attribute value
+    const ur_kernel_exec_info_properties_t
+        *pProperties, ///< [in][optional] pointer to execution info properties
+    const void *pPropValue ///< [in][range(0, propSize)] pointer to memory
+                           ///< location holding the property value.
+) {
+  std::ignore = propSize;
+  std::ignore = pProperties;
+
+  return hKernel->setExecInfo(propName, pPropValue);
+}
 } // namespace ur::level_zero

source/adapters/level_zero/v2/kernel.hpp

@@ -57,6 +57,10 @@ struct ur_kernel_handle_t_ : _ur_object {
                 const ur_kernel_arg_pointer_properties_t *pProperties,
                 const void *pArgValue);
 
+  // Implementation of urKernelSetExecInfo.
+  ur_result_t setExecInfo(ur_kernel_exec_info_t propName,
+                          const void *pPropValue);
+
   // Perform cleanup.
   ur_result_t release();