Add feature to estimate number of event packets

Related-To: NEO-7469

Signed-off-by: Zbigniew Zdanowicz <[email protected]>

Author: zzdanowicz

level_zero/core/source/CMakeLists.txt

@@ -99,6 +99,7 @@ if(SUPPORT_XEHP_AND_LATER)
   list(APPEND L0_RUNTIME_SOURCES
        ${CMAKE_CURRENT_SOURCE_DIR}/cmdlist/cmdlist_hw_xehp_and_later.inl
        ${CMAKE_CURRENT_SOURCE_DIR}/cmdqueue/cmdqueue_xe_hp_core_and_later.inl
+       ${CMAKE_CURRENT_SOURCE_DIR}/hw_helpers/l0_hw_helper_xehp_and_later.inl
   )
 endif()
 

level_zero/core/source/cmdlist/cmdlist_hw.inl

@@ -390,7 +390,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendEventReset(ze_event_hand
     }
 
     if (event->isEventTimestampFlagSet()) {
-        packetsToReset = EventPacketsCount::eventPackets;
+        packetsToReset = event->getMaxPacketsCount();
     }
     event->resetPackets();
     event->resetCompletion();

level_zero/core/source/context/context_imp.cpp

@@ -577,12 +577,11 @@ ze_result_t ContextImp::openEventPoolIpcHandle(const ze_ipc_event_pool_handle_t
     auto device = Device::fromHandle(this->devices.begin()->second);
     auto neoDevice = device->getNEODevice();
     NEO::osHandle osHandle = static_cast<NEO::osHandle>(handle);
-    auto &hwHelper = device->getHwHelper();
-    const uint32_t eventAlignment = static_cast<uint32_t>(hwHelper.getTimestampPacketAllocatorAlignment());
-    uint32_t eventSize = static_cast<uint32_t>(alignUp(EventPacketsCount::eventPackets * hwHelper.getSingleTimestampPacketSize(), eventAlignment));
-    size_t alignedSize = alignUp<size_t>(numEvents * eventSize, MemoryConstants::pageSize64k);
+
+    eventPool->initializeSizeParameters(this->numDevices, this->deviceHandles.data(), *this->driverHandle, device->getHwInfo());
+
     NEO::AllocationProperties unifiedMemoryProperties{rootDeviceIndex,
-                                                      alignedSize,
+                                                      eventPool->getEventPoolSize(),
                                                       NEO::AllocationType::BUFFER_HOST_MEMORY,
                                                       systemMemoryBitfield};
 
@@ -605,8 +604,6 @@ ze_result_t ContextImp::openEventPoolIpcHandle(const ze_ipc_event_pool_handle_t
     eventPool->eventPoolPtr = reinterpret_cast<void *>(alloc->getUnderlyingBuffer());
     eventPool->devices.push_back(device);
     eventPool->isImportedIpcPool = true;
-    eventPool->setEventSize(eventSize);
-    eventPool->setEventAlignment(eventAlignment);
 
     for (auto currDeviceIndex : this->rootDeviceIndices) {
         if (currDeviceIndex == rootDeviceIndex) {

level_zero/core/source/context/context_imp.h

@@ -149,11 +149,20 @@ struct ContextImp : Context {
     bool isShareableMemory(const void *exportDesc, bool exportableMemory, NEO::Device *neoDevice) override;
     void *getMemHandlePtr(ze_device_handle_t hDevice, uint64_t handle, ze_ipc_memory_flags_t flags) override;
 
+    void initDeviceHandles(uint32_t numDevices, ze_device_handle_t *deviceHandles) {
+        this->numDevices = numDevices;
+        if (numDevices > 0) {
+            this->deviceHandles.assign(deviceHandles, deviceHandles + numDevices);
+        }
+    }
+
   protected:
     bool isAllocationSuitableForCompression(const StructuresLookupTable &structuresLookupTable, Device &device, size_t allocSize);
 
     std::map<uint32_t, ze_device_handle_t> devices;
+    std::vector<ze_device_handle_t> deviceHandles;
     DriverHandleImp *driverHandle = nullptr;
+    uint32_t numDevices = 0;
 };
 
 } // namespace L0

level_zero/core/source/device/device.h

@@ -136,6 +136,7 @@ struct Device : _ze_device_handle_t {
     virtual NEO::GraphicsAllocation *obtainReusableAllocation(size_t requiredSize, NEO::AllocationType type) = 0;
     virtual void storeReusableAllocation(NEO::GraphicsAllocation &alloc) = 0;
     virtual ze_result_t getFabricVertex(ze_fabric_vertex_handle_t *phVertex) = 0;
+    virtual uint32_t getEventMaxPacketCount() const = 0;
 
   protected:
     NEO::Device *neoDevice = nullptr;

level_zero/core/source/device/device_imp.cpp

@@ -1515,4 +1515,14 @@ ze_result_t DeviceImp::getFabricVertex(ze_fabric_vertex_handle_t *phVertex) {
     return ZE_RESULT_SUCCESS;
 }
 
+uint32_t DeviceImp::getEventMaxPacketCount() const {
+    const auto &hardwareInfo = this->getHwInfo();
+    auto &l0HwHelper = L0HwHelper::get(hardwareInfo.platform.eRenderCoreFamily);
+
+    uint32_t basePackets = l0HwHelper.getEventBaseMaxPacketCount(hardwareInfo);
+    if (this->isImplicitScalingCapable()) {
+        basePackets *= static_cast<uint32_t>(neoDevice->getDeviceBitfield().count());
+    }
+    return basePackets;
+}
 } // namespace L0

level_zero/core/source/device/device_imp.h

@@ -141,6 +141,7 @@ struct DeviceImp : public Device {
 
     ze_result_t queryDeviceLuid(ze_device_luid_ext_properties_t *deviceLuidProperties);
     ze_result_t setDeviceLuid(ze_device_luid_ext_properties_t *deviceLuidProperties);
+    uint32_t getEventMaxPacketCount() const override;
 
   protected:
     void adjustCommandQueueDesc(uint32_t &ordinal, uint32_t &index);

level_zero/core/source/driver/driver_handle.h

@@ -66,6 +66,7 @@ struct DriverHandle : _ze_driver_handle_t {
                                                                      uint32_t rootDeviceIndex,
                                                                      uintptr_t *gpuAddress) = 0;
     virtual ze_result_t fabricVertexGetExp(uint32_t *pCount, ze_fabric_vertex_handle_t *phDevices) = 0;
+    virtual uint32_t getEventMaxPacketCount(uint32_t numDevices, ze_device_handle_t *deviceHandles) const = 0;
 
     static DriverHandle *fromHandle(ze_driver_handle_t handle) { return static_cast<DriverHandle *>(handle); }
     inline ze_driver_handle_t toHandle() { return this; }

level_zero/core/source/driver/driver_handle_imp.cpp

@@ -58,7 +58,7 @@ ze_result_t DriverHandleImp::createContext(const ze_context_desc_t *desc,
     }
 
     *phContext = context->toHandle();
-
+    context->initDeviceHandles(numDevices, phDevices);
     if (numDevices == 0) {
         for (auto device : this->devices) {
             auto neoDevice = device->getNEODevice();
@@ -704,4 +704,22 @@ ze_result_t DriverHandleImp::fabricEdgeGetExp(ze_fabric_vertex_handle_t hVertexA
     return ZE_RESULT_SUCCESS;
 }
 
+uint32_t DriverHandleImp::getEventMaxPacketCount(uint32_t numDevices, ze_device_handle_t *deviceHandles) const {
+    uint32_t maxCount = 0;
+
+    if (numDevices == 0) {
+        for (auto device : this->devices) {
+            auto deviceMaxCount = device->getEventMaxPacketCount();
+            maxCount = std::max(maxCount, deviceMaxCount);
+        }
+    } else {
+        for (uint32_t i = 0; i < numDevices; i++) {
+            auto deviceMaxCount = Device::fromHandle(deviceHandles[i])->getEventMaxPacketCount();
+            maxCount = std::max(maxCount, deviceMaxCount);
+        }
+    }
+
+    return maxCount;
+}
+
 } // namespace L0

level_zero/core/source/driver/driver_handle_imp.h

@@ -82,6 +82,7 @@ struct DriverHandleImp : public DriverHandle {
                                 Device *device);
     ze_result_t fabricEdgeGetExp(ze_fabric_vertex_handle_t hVertexA, ze_fabric_vertex_handle_t hVertexB,
                                  uint32_t *pCount, ze_fabric_edge_handle_t *phEdges);
+    uint32_t getEventMaxPacketCount(uint32_t numDevices, ze_device_handle_t *deviceHandles) const override;
 
     std::unique_ptr<HostPointerManager> hostPointerManager;
     // Experimental functions