let's pretend it all has been done in one commit

Author: EuphoricThinking

devops/scripts/benchmarks/utils/compute_runtime.py

@@ -203,16 +203,20 @@ def build_compute_runtime(self):
             # Remove -Werror...
             replace_in_file(cmakelists_path, r"\s-Werror(?:=[a-zA-Z]*)?", "")
 
-            log.info("Building Compute Runtime...")
-            extra_config_args = [
-                "-DNEO_ENABLE_i915_PRELIM_DETECTION=1",
-                "-DNEO_ENABLE_I915_PRELIM_DETECTION=1",
-                "-DNEO_SKIP_UNIT_TESTS=1",
-                f"-DGMM_DIR={self.gmmlib}",
-                f"-DLEVEL_ZERO_ROOT={self.level_zero}",
-            ]
-            if options.build_igc:
-                extra_config_args.append(f"-DIGC_DIR={self.igc}")
+        log.info("Building Compute Runtime...")
+        configure_command = [
+            "cmake",
+            f"-B {self.compute_runtime_build}",
+            f"-S {self.compute_runtime_repo}",
+            "-DCMAKE_BUILD_TYPE=Debug",
+            "-DNEO_ENABLE_i915_PRELIM_DETECTION=1",
+            "-DNEO_ENABLE_I915_PRELIM_DETECTION=1",
+            "-DNEO_SKIP_UNIT_TESTS=1",
+            f"-DGMM_DIR={self.gmmlib}",
+            f"-DLEVEL_ZERO_ROOT={self.level_zero}",
+        ]
+        if options.build_igc:
+            configure_command.append(f"-DIGC_DIR={self.igc}")
 
             project.configure(extra_args=extra_config_args)
             project.build()

unified-runtime/source/adapters/level_zero/CMakeLists.txt

@@ -165,6 +165,7 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/memory.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/lockable.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_api.hpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_batched.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_immediate_in_order.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_immediate_out_of_order.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/usm.hpp
@@ -181,6 +182,7 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/kernel.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/memory.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_api.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_batched.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_create.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_immediate_in_order.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_immediate_out_of_order.cpp

unified-runtime/source/adapters/level_zero/adapter.cpp

@@ -506,72 +506,71 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
   bool forceLoadedAdapter = ur_getenv("UR_ADAPTERS_FORCE_LOAD").has_value();
   if (!forceLoadedAdapter) {
 #ifdef UR_ADAPTER_LEVEL_ZERO_V2
-        auto [useV2, reason] = shouldUseV2Adapter();
-        if (!useV2) {
-          UR_LOG(INFO, "Skipping L0 V2 adapter: {}", reason);
-          return;
-        }
+    auto [useV2, reason] = shouldUseV2Adapter();
+    if (!useV2) {
+      UR_LOG(INFO, "Skipping L0 V2 adapter: {}", reason);
+      return;
+    }
 #else
-        auto [useV1, reason] = shouldUseV1Adapter();
-        if (!useV1) {
-          UR_LOG(INFO, "Skipping L0 V1 adapter: {}", reason);
-          return;
-        }
+    auto [useV1, reason] = shouldUseV1Adapter();
+    if (!useV1) {
+      UR_LOG(INFO, "Skipping L0 V1 adapter: {}", reason);
+      return;
+    }
 #endif
   }
 
-      // Check if the user has enabled the default L0 SysMan initialization.
-      const int UrSysmanZesinitEnable = [&UserForcedSysManInit] {
-        const char *UrRet = std::getenv("UR_L0_ENABLE_ZESINIT_DEFAULT");
-        if (!UrRet)
-          return 0;
-        UserForcedSysManInit &= 2;
-        return std::atoi(UrRet);
-      }();
-
-      bool ZesInitNeeded = UrSysmanZesinitEnable && !UrSysManEnvInitEnabled;
-      // Unless the user has forced the SysMan init, we will check the device
-      // version to see if the zesInit is needed.
-      if (UserForcedSysManInit == 0 && checkDeviceIntelGPUIpVersionOrNewer(
-                                           0x05004000) == UR_RESULT_SUCCESS) {
-        if (UrSysManEnvInitEnabled) {
-          setEnvVar("ZES_ENABLE_SYSMAN", "0");
-        }
-        ZesInitNeeded = true;
-      }
-      if (ZesInitNeeded) {
+  // Check if the user has enabled the default L0 SysMan initialization.
+  const int UrSysmanZesinitEnable = [&UserForcedSysManInit] {
+    const char *UrRet = std::getenv("UR_L0_ENABLE_ZESINIT_DEFAULT");
+    if (!UrRet)
+      return 0;
+    UserForcedSysManInit &= 2;
+    return std::atoi(UrRet);
+  }();
+
+  bool ZesInitNeeded = UrSysmanZesinitEnable && !UrSysManEnvInitEnabled;
+  // Unless the user has forced the SysMan init, we will check the device
+  // version to see if the zesInit is needed.
+  if (UserForcedSysManInit == 0 &&
+      checkDeviceIntelGPUIpVersionOrNewer(0x05004000) == UR_RESULT_SUCCESS) {
+    if (UrSysManEnvInitEnabled) {
+      setEnvVar("ZES_ENABLE_SYSMAN", "0");
+    }
+    ZesInitNeeded = true;
+  }
+  if (ZesInitNeeded) {
 #ifdef UR_STATIC_LEVEL_ZERO
-        getDeviceByUUIdFunctionPtr = zesDriverGetDeviceByUuidExp;
-        getSysManDriversFunctionPtr = zesDriverGet;
-        sysManInitFunctionPtr = zesInit;
+    getDeviceByUUIdFunctionPtr = zesDriverGetDeviceByUuidExp;
+    getSysManDriversFunctionPtr = zesDriverGet;
+    sysManInitFunctionPtr = zesInit;
 #else
-        getDeviceByUUIdFunctionPtr = (zes_pfnDriverGetDeviceByUuidExp_t)
-            ur_loader::LibLoader::getFunctionPtr(processHandle,
-                                                 "zesDriverGetDeviceByUuidExp");
-        getSysManDriversFunctionPtr =
-            (zes_pfnDriverGet_t)ur_loader::LibLoader::getFunctionPtr(
-                processHandle, "zesDriverGet");
-        sysManInitFunctionPtr =
-            (zes_pfnInit_t)ur_loader::LibLoader::getFunctionPtr(processHandle,
-                                                                "zesInit");
+    getDeviceByUUIdFunctionPtr =
+        (zes_pfnDriverGetDeviceByUuidExp_t)ur_loader::LibLoader::getFunctionPtr(
+            processHandle, "zesDriverGetDeviceByUuidExp");
+    getSysManDriversFunctionPtr =
+        (zes_pfnDriverGet_t)ur_loader::LibLoader::getFunctionPtr(
+            processHandle, "zesDriverGet");
+    sysManInitFunctionPtr = (zes_pfnInit_t)ur_loader::LibLoader::getFunctionPtr(
+        processHandle, "zesInit");
 #endif
-      }
-      if (getDeviceByUUIdFunctionPtr && getSysManDriversFunctionPtr &&
-          sysManInitFunctionPtr) {
-        ze_init_flags_t L0ZesInitFlags = 0;
-        UR_LOG(DEBUG, "\nzesInit with flags value of {}\n",
-               static_cast<int>(L0ZesInitFlags));
-        ZesResult = ZE_CALL_NOCHECK(sysManInitFunctionPtr, (L0ZesInitFlags));
-      } else {
-        ZesResult = ZE_RESULT_ERROR_UNINITIALIZED;
-      }
+  }
+  if (getDeviceByUUIdFunctionPtr && getSysManDriversFunctionPtr &&
+      sysManInitFunctionPtr) {
+    ze_init_flags_t L0ZesInitFlags = 0;
+    UR_LOG(DEBUG, "\nzesInit with flags value of {}\n",
+           static_cast<int>(L0ZesInitFlags));
+    ZesResult = ZE_CALL_NOCHECK(sysManInitFunctionPtr, (L0ZesInitFlags));
+  } else {
+    ZesResult = ZE_RESULT_ERROR_UNINITIALIZED;
+  }
 
-      ur_result_t err = initPlatforms(this, platforms, ZesResult);
-      if (err == UR_RESULT_SUCCESS) {
-        Platforms = std::move(platforms);
-      } else {
-        throw err;
-      }
+  ur_result_t err = initPlatforms(this, platforms, ZesResult);
+  if (err == UR_RESULT_SUCCESS) {
+    Platforms = std::move(platforms);
+  } else {
+    throw err;
+  }
 }
 
 void globalAdapterOnDemandCleanup() {

unified-runtime/source/adapters/level_zero/v2/command_buffer.cpp

@@ -14,6 +14,7 @@
 #include "../ur_interface_loader.hpp"
 #include "logger/ur_logger.hpp"
 #include "queue_handle.hpp"
+#include "ur_api.h"
 
 namespace {
 
@@ -129,6 +130,12 @@ ur_result_t ur_exp_command_buffer_handle_t_::createCommandHandle(
 ur_result_t ur_exp_command_buffer_handle_t_::finalizeCommandBuffer() {
   // It is not allowed to append to command list from multiple threads.
   auto commandListLocked = commandListManager.lock();
+
+  // TODO check for queue
+  // if (isFinalized) {
+  //   return UR_RESULT_SUCCESS;
+  // }
+
   UR_ASSERT(!isFinalized, UR_RESULT_ERROR_INVALID_OPERATION);
 
   if (!isInOrder) {
@@ -214,6 +221,13 @@ ur_result_t ur_exp_command_buffer_handle_t_::applyUpdateCommands(
   return UR_RESULT_SUCCESS;
 }
 
+ur_event_handle_t ur_exp_command_buffer_handle_t_::poolMe() {
+  auto event = eventPool->allocate();
+  event->setQueue(nullptr);
+
+  return event;
+}
+
 ur_event_handle_t ur_exp_command_buffer_handle_t_::createEventIfRequested(
     ur_exp_command_buffer_sync_point_t *retSyncPoint) {
   if (retSyncPoint == nullptr) {

unified-runtime/source/adapters/level_zero/v2/command_buffer.hpp

@@ -19,6 +19,7 @@
 #include "kernel.hpp"
 #include "lockable.hpp"
 #include "queue_api.hpp"
+#include "ur_api.h"
 #include <ze_api.h>
 
 struct kernel_command_handle;
@@ -67,6 +68,9 @@ struct ur_exp_command_buffer_handle_t_ : public ur_object {
 
   ur::RefCount RefCount;
 
+  // TODO remove
+  ur_event_handle_t poolMe();
+
 private:
   // Stores all sync points that are created by the command buffer.
   std::vector<ur_event_handle_t> syncPoints;

unified-runtime/source/adapters/level_zero/v2/command_list_manager.cpp

@@ -129,6 +129,9 @@ wait_list_view ur_command_list_manager::getWaitListView(
       numWaitEvents + (additionalWaitEvent != nullptr ? 1 : 0);
   waitList.resize(totalNumWaitEvents);
   for (uint32_t i = 0; i < numWaitEvents; i++) {
+    // TODO is it a good place for it? mixing function purposes, but might miss
+    // preprocessing elsewhere
+    phWaitEvents[i]->runBatch();
     waitList[i] = phWaitEvents[i]->getZeEvent();
   }
   if (additionalWaitEvent != nullptr) {
@@ -499,6 +502,14 @@ ur_result_t ur_command_list_manager::appendTimestampRecordingExp(
   return UR_RESULT_SUCCESS;
 }
 
+ur_result_t ur_command_list_manager::appendRegular(
+    ze_command_list_handle_t *phCommandLists) {
+  ZE2UR_CALL(zeCommandListImmediateAppendCommandListsExp,
+             (getZeCommandList(), 1, phCommandLists, nullptr, 0, nullptr));
+
+  return UR_RESULT_SUCCESS;
+}
+
 ur_result_t ur_command_list_manager::appendGenericCommandListsExp(
     uint32_t numCommandLists, ze_command_list_handle_t *phCommandLists,
     ur_event_handle_t phEvent, uint32_t numEventsInWaitList,

unified-runtime/source/adapters/level_zero/v2/command_list_manager.hpp

@@ -231,6 +231,8 @@ struct ur_command_list_manager {
                                const ur_event_handle_t *phEventWaitList,
                                ur_event_handle_t phEvent);
 
+  ur_result_t appendRegular(ze_command_list_handle_t *phCommandLists);
+
 private:
   ur_result_t appendGenericCommandListsExp(
       uint32_t numCommandLists, ze_command_list_handle_t *phCommandLists,

unified-runtime/source/adapters/level_zero/v2/event.cpp

@@ -10,6 +10,7 @@
 
 #include <ze_api.h>
 
+#include "adapters/level_zero/v2/usm.hpp"
 #include "context.hpp"
 #include "event.hpp"
 #include "event_pool.hpp"
@@ -123,10 +124,21 @@ void ur_event_handle_t_::setQueue(ur_queue_t_ *hQueue) {
   profilingData.reset();
 }
 
+void ur_event_handle_t_::setBatch(int64_t batch_generation) {
+  this->batch_generation = batch_generation;
+}
+
 void ur_event_handle_t_::setCommandType(ur_command_t commandType) {
   this->commandType = commandType;
 }
 
+void ur_event_handle_t_::runBatch() {
+  if (batch_generation != -1) {
+    // TODO check generation number
+    hQueue->runBatchIfCurrentBatch(batch_generation);
+  }
+}
+
 void ur_event_handle_t_::recordStartTimestamp() {
   // queue and device must be set before calling this
   assert(hQueue);
@@ -192,6 +204,8 @@ ur_event_handle_t_::getEventEndTimestampAndHandle() {
 
 ur_queue_t_ *ur_event_handle_t_::getQueue() const { return hQueue; }
 
+int64_t ur_event_handle_t_::getBatch() const { return batch_generation; }
+
 ur_context_handle_t ur_event_handle_t_::getContext() const { return hContext; }
 
 ur_command_t ur_event_handle_t_::getCommandType() const { return commandType; }

unified-runtime/source/adapters/level_zero/v2/event.hpp

@@ -68,7 +68,9 @@ struct ur_event_handle_t_ : ur_object {
 
   // Set the queue and command that this event is associated with
   void setQueue(ur_queue_t_ *hQueue);
+  void setBatch(int64_t batch_generation);
   void setCommandType(ur_command_t commandType);
+  void runBatch();
 
   void reset();
   ze_event_handle_t getZeEvent() const;
@@ -98,6 +100,8 @@ struct ur_event_handle_t_ : ur_object {
   // Get the type of the command that this event is associated with
   ur_command_t getCommandType() const;
 
+  int64_t getBatch() const;
+
   // Get the device associated with this event
   ur_device_handle_t getDevice() const;
 
@@ -129,6 +133,8 @@ struct ur_event_handle_t_ : ur_object {
   // queue and commandType that this event is associated with, set by enqueue
   // commands
   ur_queue_t_ *hQueue = nullptr;
+  // default for non-batched queues
+  int64_t batch_generation = -1;
   ur_command_t commandType = UR_COMMAND_FORCE_UINT32;
   ur_device_handle_t hDevice = nullptr;
 

unified-runtime/source/adapters/level_zero/v2/event_pool.cpp

@@ -49,7 +49,9 @@ void event_pool::free(ur_event_handle_t event) {
   std::unique_lock<ur_mutex> lock(mutex);
 
   event->reset();
+  // TODO is it a good place for it? Am I missing something?
   freelist.push_back(event);
+  event->setBatch(-1);
 
   // The event is still in the pool, so we need to increment the refcount
   assert(event->RefCount.getCount() == 0);