Do not set global offset unless required (#18242)

Previously, zeKernelSetGlobalOffsetExp was called for every kernel
launch. The vast majority of kernels are expected to never have an
offset, because the offset feature was deprecated in SYCL 2020, and we
should optimize for this case.

The SYCL RT currently passes {0, 0, 0} in the case where there is no
offset. To optimize this case:
- A zero offset is treated equivalently to a NULL offset, and
zeKernelSetGlobalOffsetExp is not called.
- A non-zero offset triggers a call to zeKernelSetGlobalOffsetExp before
launching the kernel.
- A non-zero offset triggers a call to zeKernelSetGlobalOffsetExp after
launching the kernel, to reset the offset to zero.

This will introduce additional overhead to the uncommon case where
offsets are specified, but we plan to remove this anyway.

In the long-term, the check for a {0, 0, 0} offset should probably be
moved into the SYCL headers and NULL should be passed directly to UR.
However, this will require wide-reaching changes to other UR adapters
and the UR specification.

---------

Signed-off-by: John Pennycook <john.pennycook@intel.com>

Author: Pennycook

source/adapters/level_zero/helpers/kernel_helpers.hpp

@@ -56,3 +56,18 @@ ur_result_t getSuggestedLocalWorkSize(ur_device_handle_t hDevice,
                                       ze_kernel_handle_t hZeKernel,
                                       size_t GlobalWorkSize3D[3],
                                       uint32_t SuggestedLocalWorkSize3D[3]);
+
+/**
+ * Handle uncommon conditions after kernel submission.
+ * Resets the offset to {0, 0, 0} if one was supplied.
+ * @param[in] hZeKernel The kernel handle.
+ * @param[in] pGlobalWorkOffset Pointer to offset array.
+ */
+inline void postSubmit(ze_kernel_handle_t hZeKernel,
+                       const size_t *pGlobalWorkOffset) {
+  // If this kernel was launched with an offset, clear it for the next launch.
+  // This slows down kernels with offsets but keeps the common case fast.
+  if (pGlobalWorkOffset != NULL) {
+    zeKernelSetGlobalOffsetExp(hZeKernel, 0, 0, 0);
+  }
+}

source/adapters/level_zero/v2/command_list_manager.cpp

@@ -219,6 +219,16 @@ ur_result_t ur_command_list_manager::appendKernelLaunch(
     waitListView.clear();
   };
 
+  // If the offset is {0, 0, 0}, pass NULL instead.
+  // This allows us to skip setting the offset.
+  bool hasOffset = false;
+  for (uint32_t i = 0; i < workDim; ++i) {
+    hasOffset |= pGlobalWorkOffset[i];
+  }
+  if (!hasOffset) {
+    pGlobalWorkOffset = NULL;
+  }
+
   UR_CALL(hKernel->prepareForSubmission(context, device, pGlobalWorkOffset,
                                         workDim, WG[0], WG[1], WG[2],
                                         memoryMigrate));
@@ -229,6 +239,8 @@ ur_result_t ur_command_list_manager::appendKernelLaunch(
              (zeCommandList.get(), hZeKernel, &zeThreadGroupDimensions,
               zeSignalEvent, waitListView.num, waitListView.handles));
 
+  postSubmit(hZeKernel, pGlobalWorkOffset);
+
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/level_zero/v2/queue_immediate_in_order.cpp

@@ -809,6 +809,16 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueCooperativeKernelLaunchExp(
     waitListView.clear();
   };
 
+  // If the offset is {0, 0, 0}, pass NULL instead.
+  // This allows us to skip setting the offset.
+  bool hasOffset = false;
+  for (uint32_t i = 0; i < workDim; ++i) {
+    hasOffset |= pGlobalWorkOffset[i];
+  }
+  if (!hasOffset) {
+    pGlobalWorkOffset = NULL;
+  }
+
   UR_CALL(hKernel->prepareForSubmission(hContext, hDevice, pGlobalWorkOffset,
                                         workDim, WG[0], WG[1], WG[2],
                                         memoryMigrate));
@@ -822,6 +832,8 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueCooperativeKernelLaunchExp(
 
   recordSubmittedKernel(hKernel);
 
+  postSubmit(hZeKernel, pGlobalWorkOffset);
+
   return UR_RESULT_SUCCESS;
 }