Per-thread scratch offset calculation

Related-To: NEO-6404

Signed-off-by: Mateusz Hoppe <[email protected]>

Author: HoppeMateusz

level_zero/tools/source/debug/debug_session.cpp

@@ -203,4 +203,14 @@ bool DebugSession::isBindlessSystemRoutine() {
     return false;
 }
 
+size_t DebugSession::getPerThreadScratchOffset(size_t ptss, EuThread::ThreadId threadId) {
+    auto hwInfo = connectedDevice->getHwInfo();
+    const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.MaxSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported;
+    const uint32_t numEuPerSubslice = hwInfo.gtSystemInfo.MaxEuPerSubSlice;
+    const uint32_t numThreadsPerEu = (hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount);
+
+    auto threadOffset = (((threadId.slice * numSubslicesPerSlice + threadId.subslice) * numEuPerSubslice + threadId.eu) * numThreadsPerEu + threadId.thread) * ptss;
+    return threadOffset;
+}
+
 } // namespace L0

level_zero/tools/source/debug/debug_session.h

@@ -87,6 +87,8 @@ struct DebugSession : _zet_debug_session_handle_t {
 
     std::vector<EuThread::ThreadId> getSingleThreadsForDevice(uint32_t deviceIndex, ze_device_thread_t physicalThread, const NEO::HardwareInfo &hwInfo);
 
+    size_t getPerThreadScratchOffset(size_t ptss, EuThread::ThreadId threadId);
+
     DebugAreaHeader debugArea;
 
     Device *connectedDevice = nullptr;

level_zero/tools/test/unit_tests/sources/debug/debug_session_tests.cpp

@@ -430,6 +430,29 @@ TEST(DebugSession, givenDifferentCombinationsOfThreadsAndMemoryTypeCheckExpected
     EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
 }
 
+TEST(DebugSession, givenDifferentThreadsWhenGettingPerThreadScratchOffsetThenCorrectOffsetReturned) {
+    auto hwInfo = *NEO::defaultHwInfo.get();
+    NEO::Device *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
+    Mock<L0::DeviceImp> deviceImp(neoDevice, neoDevice->getExecutionEnvironment());
+    auto debugSession = std::make_unique<DebugSessionMock>(zet_debug_config_t{0x1234}, &deviceImp);
+
+    const uint32_t numThreadsPerEu = (hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount);
+    EuThread::ThreadId thread0Eu0 = {0, 0, 0, 0, 0};
+    EuThread::ThreadId thread0Eu1 = {0, 0, 0, 1, 0};
+    EuThread::ThreadId thread2Subslice1 = {0, 0, 1, 0, 2};
+
+    const uint32_t ptss = 128;
+
+    auto size = debugSession->getPerThreadScratchOffset(ptss, thread0Eu0);
+    EXPECT_EQ(0u, size);
+
+    size = debugSession->getPerThreadScratchOffset(ptss, thread0Eu1);
+    EXPECT_EQ(ptss * numThreadsPerEu, size);
+
+    size = debugSession->getPerThreadScratchOffset(ptss, thread2Subslice1);
+    EXPECT_EQ(2 * ptss + ptss * hwInfo.gtSystemInfo.MaxEuPerSubSlice * numThreadsPerEu, size);
+}
+
 using DebugSessionMultiTile = Test<MultipleDevicesWithCustomHwInfo>;
 
 TEST_F(DebugSessionMultiTile, givenApiThreadAndMultipleTilesWhenConvertingToPhysicalThenCorrectValueReturned) {

level_zero/tools/test/unit_tests/sources/debug/mock_debug_session.h

@@ -27,6 +27,7 @@ struct DebugSessionMock : public L0::DebugSession {
     using L0::DebugSession::allThreads;
     using L0::DebugSession::debugArea;
     using L0::DebugSession::fillDevicesFromThread;
+    using L0::DebugSession::getPerThreadScratchOffset;
     using L0::DebugSession::getSingleThreadsForDevice;
     using L0::DebugSession::isBindlessSystemRoutine;
 

opencl/test/unit_test/helpers/hw_helper_tests.cpp

@@ -1321,6 +1321,16 @@ HWTEST_F(HwHelperTest, givenGetRenderSurfaceStateBaseAddressCalledThenCorrectVal
     EXPECT_EQ(expectedBaseAddress, hwHelper.getRenderSurfaceStateBaseAddress(&renderSurfaceState));
 }
 
+HWTEST_F(HwHelperTest, givenGetRenderSurfaceStatePitchCalledThenCorrectValueIsReturned) {
+    using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
+
+    RENDER_SURFACE_STATE renderSurfaceState;
+    uint32_t expectedPitch = 0x400;
+    renderSurfaceState.setSurfacePitch(expectedPitch);
+    const auto &hwHelper = HwHelper::get(renderCoreFamily);
+    EXPECT_EQ(expectedPitch, hwHelper.getRenderSurfaceStatePitch(&renderSurfaceState));
+}
+
 HWCMDTEST_F(IGFX_GEN8_CORE, HwHelperTest, givenCLImageFormatsWhenCallingIsFormatRedescribableThenCorrectValueReturned) {
     static const cl_image_format redescribeFormats[] = {
         {CL_R, CL_UNSIGNED_INT8},

shared/source/helpers/hw_helper.h

@@ -146,6 +146,7 @@ class HwHelper {
 
     virtual bool isScratchSpaceSurfaceStateAccessible() const = 0;
     virtual uint64_t getRenderSurfaceStateBaseAddress(void *renderSurfaceState) const = 0;
+    virtual uint32_t getRenderSurfaceStatePitch(void *renderSurfaceState) const = 0;
     virtual size_t getMax3dImageWidthOrHeight() const = 0;
     virtual uint64_t getMaxMemAllocSize() const = 0;
     virtual bool isStatelesToStatefullWithOffsetSupported() const = 0;
@@ -202,6 +203,14 @@ class HwHelperHw : public HwHelper {
         return messageExtDescriptor.getBindlessSurfaceOffsetToPatch();
     }
 
+    uint64_t getRenderSurfaceStateBaseAddress(void *renderSurfaceState) const override {
+        return reinterpret_cast<typename GfxFamily::RENDER_SURFACE_STATE *>(renderSurfaceState)->getSurfaceBaseAddress();
+    }
+
+    uint32_t getRenderSurfaceStatePitch(void *renderSurfaceState) const override {
+        return reinterpret_cast<typename GfxFamily::RENDER_SURFACE_STATE *>(renderSurfaceState)->getSurfacePitch();
+    }
+
     const AubMemDump::LrcaHelper &getCsTraits(aub_stream::EngineType engineType) const override;
 
     size_t getMaxBarrierRegisterPerSlice() const override;
@@ -369,7 +378,6 @@ class HwHelperHw : public HwHelper {
     void adjustPreemptionSurfaceSize(size_t &csrSize) const override;
 
     bool isScratchSpaceSurfaceStateAccessible() const override;
-    uint64_t getRenderSurfaceStateBaseAddress(void *renderSurfaceState) const override;
 
     size_t getMax3dImageWidthOrHeight() const override;
     uint64_t getMaxMemAllocSize() const override;

shared/source/helpers/hw_helper_base.inl

@@ -624,11 +624,6 @@ template <typename GfxFamily>
 void HwHelperHw<GfxFamily>::adjustPreemptionSurfaceSize(size_t &csrSize) const {
 }
 
-template <typename GfxFamily>
-uint64_t HwHelperHw<GfxFamily>::getRenderSurfaceStateBaseAddress(void *renderSurfaceState) const {
-    return reinterpret_cast<typename GfxFamily::RENDER_SURFACE_STATE *>(renderSurfaceState)->getSurfaceBaseAddress();
-}
-
 template <typename GfxFamily>
 void HwHelperHw<GfxFamily>::encodeBufferSurfaceState(EncodeSurfaceStateArgs &args) {
     EncodeSurfaceState<GfxFamily>::encodeBuffer(args);