diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.inl b/level_zero/core/source/cmdlist/cmdlist_hw.inl
index d1c581bb9e..17b2762a03 100644
--- a/level_zero/core/source/cmdlist/cmdlist_hw.inl
+++ b/level_zero/core/source/cmdlist/cmdlist_hw.inl
@@ -2569,7 +2569,7 @@ void CommandListCoreFamily<gfxCoreFamily>::programStateBaseAddress(NEO::CommandC
     NEO::EncodeStateBaseAddress<GfxFamily>::setSbaTrackingForL0DebuggerIfEnabled(sbaTrackingEnabled,
                                                                                  *this->device->getNEODevice(),
                                                                                  *container.getCommandStream(),
-                                                                                 sba);
+                                                                                 sba, this->isFlushTaskSubmissionEnabled);
 }
 
 template <GFXCORE_FAMILY gfxCoreFamily>
diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl b/level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl
index a068bbcf0b..608b536897 100644
--- a/level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl
+++ b/level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl
@@ -81,7 +81,7 @@ void CommandQueueHw<gfxCoreFamily>::programStateBaseAddress(uint64_t gsba, bool
     NEO::StateBaseAddressHelper<GfxFamily>::programStateBaseAddressIntoCommandStream(stateBaseAddressHelperArgs, commandStream);
 
     bool sbaTrackingEnabled = (NEO::Debugger::isDebugEnabled(this->internalUsage) && device->getL0Debugger());
-    NEO::EncodeStateBaseAddress<GfxFamily>::setSbaTrackingForL0DebuggerIfEnabled(sbaTrackingEnabled, *neoDevice, commandStream, sbaCmd);
+    NEO::EncodeStateBaseAddress<GfxFamily>::setSbaTrackingForL0DebuggerIfEnabled(sbaTrackingEnabled, *neoDevice, commandStream, sbaCmd, true);
 
     NEO::EncodeWA<GfxFamily>::encodeAdditionalPipelineSelect(commandStream, {}, false, hwInfo, isRcs);
 
diff --git a/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl b/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl
index e4690e1a56..575836af25 100644
--- a/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl
+++ b/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl
@@ -73,7 +73,7 @@ void CommandQueueHw<gfxCoreFamily>::programStateBaseAddress(uint64_t gsba, bool
         NEO::EncodeStateBaseAddress<GfxFamily>::setSbaTrackingForL0DebuggerIfEnabled(sbaTrackingEnabled,
                                                                                      *neoDevice,
                                                                                      commandStream,
-                                                                                     sbaCmd);
+                                                                                     sbaCmd, true);
 
         auto heap = neoDevice->getBindlessHeapsHelper()->getHeap(NEO::BindlessHeapsHelper::GLOBAL_SSH);
         NEO::StateBaseAddressHelper<GfxFamily>::programBindingTableBaseAddress(
diff --git a/level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h b/level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h
index 7b69afb7ba..ede8206e33 100644
--- a/level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h
+++ b/level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h
@@ -96,6 +96,17 @@ struct L0DebuggerPerContextAddressSpaceFixture : public L0DebuggerHwFixture {
     DebugManagerStateRestore restorer;
 };
 
+struct L0DebuggerSingleAddressSpaceFixture : public L0DebuggerHwFixture {
+    void setUp() {
+        NEO::DebugManager.flags.DebuggerForceSbaTrackingMode.set(1);
+        L0DebuggerHwFixture::setUp();
+    }
+    void tearDown() {
+        L0DebuggerHwFixture::tearDown();
+    }
+    DebugManagerStateRestore restorer;
+};
+
 struct L0DebuggerHwParameterizedFixture : ::testing::TestWithParam<int>, public L0DebuggerHwFixture {
     void SetUp() override {
         NEO::DebugManager.flags.DebuggerForceSbaTrackingMode.set(GetParam());
diff --git a/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp b/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp
index 4e5d108230..2d912afc2e 100644
--- a/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp
+++ b/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp
@@ -106,6 +106,51 @@ HWTEST_P(L0DebuggerWithBlitterTest, givenDebuggerLogsDisabledWhenCommandListIsSy
 }
 
 using Gen12Plus = IsAtLeastGfxCore<IGFX_GEN12_CORE>;
+using singleAddressSpaceModeTest = Test<L0DebuggerSingleAddressSpaceFixture>;
+
+HWTEST2_F(singleAddressSpaceModeTest, givenImmediateCommandListWhenExecutingWithFlushTaskThenGPR15isProgrammed, Gen12Plus) {
+    using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
+    Mock<::L0::Kernel> kernel;
+    DebugManagerStateRestore restorer;
+    NEO::DebugManager.flags.EnableFlushTaskSubmission.set(true);
+
+    ze_command_queue_desc_t queueDesc = {};
+    ze_result_t returnValue = ZE_RESULT_SUCCESS;
+    ze_group_count_t groupCount{1, 1, 1};
+
+    auto &csr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
+    csr.storeMakeResidentAllocations = true;
+
+    auto commandList = CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::RenderCompute, returnValue);
+
+    EXPECT_TRUE(commandList->isFlushTaskSubmissionEnabled);
+    EXPECT_EQ(&csr, commandList->csr);
+
+    csr.lastFlushedCommandStream = nullptr;
+    CmdListKernelLaunchParams launchParams = {};
+    auto result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, nullptr, 0, nullptr, launchParams);
+    ASSERT_EQ(ZE_RESULT_SUCCESS, result);
+
+    EXPECT_NE(nullptr, csr.lastFlushedCommandStream);
+
+    GenCmdList cmdList;
+    ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
+        cmdList, commandList->csr->getCS().getCpuBase(), commandList->csr->getCS().getUsed()));
+    bool gpr15Found = false;
+    auto miLoadImm = findAll<MI_LOAD_REGISTER_IMM *>(cmdList.begin(), cmdList.end());
+    for (size_t i = 0; i < miLoadImm.size(); i++) {
+        MI_LOAD_REGISTER_IMM *miLoad = genCmdCast<MI_LOAD_REGISTER_IMM *>(*miLoadImm[i]);
+        ASSERT_NE(nullptr, miLoad);
+
+        if (miLoad->getRegisterOffset() == CS_GPR_R15) {
+            gpr15Found = true;
+            break;
+        }
+    }
+    EXPECT_TRUE(gpr15Found);
+    commandList->destroy();
+}
+
 HWTEST2_P(L0DebuggerWithBlitterTest, givenImmediateCommandListWhenExecutingWithFlushTaskThenSipIsInstalledAndDebuggerAllocationsAreResident, Gen12Plus) {
     using STATE_SIP = typename FamilyType::STATE_SIP;
     using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
diff --git a/opencl/test/unit_test/source_level_debugger/source_level_debugger_tests.cpp b/opencl/test/unit_test/source_level_debugger/source_level_debugger_tests.cpp
index cf960d6644..fb0481aba0 100644
--- a/opencl/test/unit_test/source_level_debugger/source_level_debugger_tests.cpp
+++ b/opencl/test/unit_test/source_level_debugger/source_level_debugger_tests.cpp
@@ -707,7 +707,7 @@ TEST(SourceLevelDebugger, whenCaptureSBACalledThenNoCommandsAreAddedToStream) {
     container.initialize(device.get(), nullptr, true);
 
     NEO::Debugger::SbaAddresses sbaAddresses = {};
-    debugger.captureStateBaseAddress(*container.getCommandStream(), sbaAddresses);
+    debugger.captureStateBaseAddress(*container.getCommandStream(), sbaAddresses, false);
     EXPECT_EQ(0u, container.getCommandStream()->getUsed());
 }
 
diff --git a/shared/source/command_container/command_encoder.h b/shared/source/command_container/command_encoder.h
index 6d4ecac8fa..0ea2d8f510 100644
--- a/shared/source/command_container/command_encoder.h
+++ b/shared/source/command_container/command_encoder.h
@@ -312,7 +312,7 @@ struct EncodeStateBaseAddress {
     static void setSbaTrackingForL0DebuggerIfEnabled(bool trackingEnabled,
                                                      Device &device,
                                                      LinearStream &commandStream,
-                                                     STATE_BASE_ADDRESS &sbaCmd);
+                                                     STATE_BASE_ADDRESS &sbaCmd, bool useFirstLevelBB);
 
   protected:
     static void setSbaAddressesForDebugger(NEO::Debugger::SbaAddresses &sbaAddress, const STATE_BASE_ADDRESS &sbaCmd);
diff --git a/shared/source/command_container/command_encoder.inl b/shared/source/command_container/command_encoder.inl
index 0b22f35781..065cbfc5b9 100644
--- a/shared/source/command_container/command_encoder.inl
+++ b/shared/source/command_container/command_encoder.inl
@@ -353,14 +353,13 @@ template <typename Family>
 inline void EncodeStateBaseAddress<Family>::setSbaTrackingForL0DebuggerIfEnabled(bool trackingEnabled,
                                                                                  Device &device,
                                                                                  LinearStream &commandStream,
-                                                                                 STATE_BASE_ADDRESS &sbaCmd) {
+                                                                                 STATE_BASE_ADDRESS &sbaCmd, bool useFirstLevelBB) {
     if (!trackingEnabled) {
         return;
     }
-
     NEO::Debugger::SbaAddresses sbaAddresses = {};
     NEO::EncodeStateBaseAddress<Family>::setSbaAddressesForDebugger(sbaAddresses, sbaCmd);
-    device.getL0Debugger()->captureStateBaseAddress(commandStream, sbaAddresses);
+    device.getL0Debugger()->captureStateBaseAddress(commandStream, sbaAddresses, useFirstLevelBB);
 }
 
 template <typename Family>
diff --git a/shared/source/command_stream/command_stream_receiver_hw_base.inl b/shared/source/command_stream/command_stream_receiver_hw_base.inl
index e4e7429d3a..8a0540c2eb 100644
--- a/shared/source/command_stream/command_stream_receiver_hw_base.inl
+++ b/shared/source/command_stream/command_stream_receiver_hw_base.inl
@@ -15,6 +15,7 @@
 #include "shared/source/command_stream/stream_properties.h"
 #include "shared/source/command_stream/wait_status.h"
 #include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/debugger/debugger_l0.h"
 #include "shared/source/device/device.h"
 #include "shared/source/direct_submission/direct_submission_controller.h"
 #include "shared/source/direct_submission/direct_submission_hw.h"
@@ -436,10 +437,14 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
         StateBaseAddressHelper<GfxFamily>::programStateBaseAddressIntoCommandStream(args, commandStreamCSR);
 
         bool sbaTrackingEnabled = (debuggingEnabled && !device.getDebugger()->isLegacy());
+        if (sbaTrackingEnabled) {
+            device.getL0Debugger()->programSbaAddressLoad(commandStreamCSR,
+                                                          device.getL0Debugger()->getSbaTrackingBuffer(this->getOsContext().getContextId())->getGpuAddress());
+        }
         NEO::EncodeStateBaseAddress<GfxFamily>::setSbaTrackingForL0DebuggerIfEnabled(sbaTrackingEnabled,
                                                                                      device,
                                                                                      commandStreamCSR,
-                                                                                     stateBaseAddressCmd);
+                                                                                     stateBaseAddressCmd, true);
 
         if (sshDirty) {
             bindingTableBaseAddressRequired = true;
diff --git a/shared/source/debugger/debugger.h b/shared/source/debugger/debugger.h
index 9caed2f043..da10819ddc 100644
--- a/shared/source/debugger/debugger.h
+++ b/shared/source/debugger/debugger.h
@@ -31,7 +31,7 @@ class Debugger {
     static std::unique_ptr<Debugger> create(const NEO::RootDeviceEnvironment &rootDeviceEnvironment);
     virtual ~Debugger() = default;
     bool isLegacy() const { return isLegacyMode; }
-    virtual void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba) = 0;
+    virtual void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba, bool useFirstLevelBB) = 0;
     virtual size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) = 0;
 
     void *getDebugSurfaceReservedSurfaceState(IndirectHeap &ssh);
diff --git a/shared/source/debugger/debugger_l0.h b/shared/source/debugger/debugger_l0.h
index d75ba46333..5e4b9cb639 100644
--- a/shared/source/debugger/debugger_l0.h
+++ b/shared/source/debugger/debugger_l0.h
@@ -141,12 +141,12 @@ class DebuggerL0Hw : public DebuggerL0 {
   public:
     static DebuggerL0 *allocate(NEO::Device *device);
 
-    void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba) override;
+    void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba, bool useFirstLevelBB) override;
     size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) override;
     size_t getSbaAddressLoadCommandsSize() override;
     void programSbaAddressLoad(NEO::LinearStream &cmdStream, uint64_t sbaGpuVa) override;
 
-    void programSbaTrackingCommandsSingleAddressSpace(NEO::LinearStream &cmdStream, const SbaAddresses &sba);
+    void programSbaTrackingCommandsSingleAddressSpace(NEO::LinearStream &cmdStream, const SbaAddresses &sba, bool useFirstLevelBB);
 
   protected:
     DebuggerL0Hw(NEO::Device *device) : DebuggerL0(device){};
diff --git a/shared/source/debugger/debugger_l0.inl b/shared/source/debugger/debugger_l0.inl
index 42d24be2f9..fbf7ba2628 100644
--- a/shared/source/debugger/debugger_l0.inl
+++ b/shared/source/debugger/debugger_l0.inl
@@ -14,7 +14,7 @@
 namespace NEO {
 
 template <typename GfxFamily>
-void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba) {
+void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba, bool useFirstLevelBB) {
     using MI_STORE_DATA_IMM = typename GfxFamily::MI_STORE_DATA_IMM;
     using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
     using MI_BATCH_BUFFER_START = typename GfxFamily::MI_BATCH_BUFFER_START;
@@ -41,7 +41,7 @@ void DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(NEO::LinearStream &cmdStre
                             sbaCanonized.IndirectObjectBaseAddress, sbaCanonized.InstructionBaseAddress, sbaCanonized.BindlessSurfaceStateBaseAddress);
 
     if (singleAddressSpaceSbaTracking) {
-        programSbaTrackingCommandsSingleAddressSpace(cmdStream, sbaCanonized);
+        programSbaTrackingCommandsSingleAddressSpace(cmdStream, sbaCanonized, useFirstLevelBB);
     } else {
         if (sbaCanonized.GeneralStateBaseAddress) {
             auto generalStateBaseAddress = sbaCanonized.GeneralStateBaseAddress;
diff --git a/shared/source/debugger/debugger_l0_base.inl b/shared/source/debugger/debugger_l0_base.inl
index e6426e3bf4..66671b9139 100644
--- a/shared/source/debugger/debugger_l0_base.inl
+++ b/shared/source/debugger/debugger_l0_base.inl
@@ -16,7 +16,7 @@ size_t DebuggerL0Hw<GfxFamily>::getSbaTrackingCommandsSize(size_t trackedAddress
 }
 
 template <typename GfxFamily>
-void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::LinearStream &cmdStream, const SbaAddresses &sba) {
+void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::LinearStream &cmdStream, const SbaAddresses &sba, bool useFirstLevelBB) {
     UNRECOVERABLE_IF(true);
 }
 } // namespace NEO
\ No newline at end of file
diff --git a/shared/source/debugger/debugger_l0_tgllp_and_later.inl b/shared/source/debugger/debugger_l0_tgllp_and_later.inl
index 3770649e22..ec8f3fa3f2 100644
--- a/shared/source/debugger/debugger_l0_tgllp_and_later.inl
+++ b/shared/source/debugger/debugger_l0_tgllp_and_later.inl
@@ -21,7 +21,7 @@ size_t DebuggerL0Hw<GfxFamily>::getSbaTrackingCommandsSize(size_t trackedAddress
 }
 
 template <typename GfxFamily>
-void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::LinearStream &cmdStream, const SbaAddresses &sba) {
+void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::LinearStream &cmdStream, const SbaAddresses &sba, bool useFirstLevelBB) {
     using MI_STORE_DATA_IMM = typename GfxFamily::MI_STORE_DATA_IMM;
     using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
     using MI_BATCH_BUFFER_START = typename GfxFamily::MI_BATCH_BUFFER_START;
@@ -57,6 +57,8 @@ void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::
     const auto cmdStreamGpuBase = cmdStream.getGpuBase();
     const auto cmdStreamCpuBase = reinterpret_cast<uint64_t>(cmdStream.getCpuBase());
 
+    auto bbLevel = useFirstLevelBB ? MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH : MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH;
+
     if (fieldOffsetAndValue.size()) {
         auto arb = cmdStream.getSpaceForCmd<MI_ARB_CHECK>();
         auto arbCmd = GfxFamily::cmdInitArbCheck;
@@ -70,7 +72,7 @@ void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::
         MI_BATCH_BUFFER_START bbCmd = GfxFamily::cmdInitBatchBufferStart;
         bbCmd.setAddressSpaceIndicator(MI_BATCH_BUFFER_START::ADDRESS_SPACE_INDICATOR_PPGTT);
         bbCmd.setBatchBufferStartAddress(nextCommand);
-        bbCmd.setSecondLevelBatchBuffer(MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH);
+        bbCmd.setSecondLevelBatchBuffer(bbLevel);
         *newBuffer = bbCmd;
     }
 
@@ -129,7 +131,7 @@ void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::
         MI_BATCH_BUFFER_START bbCmd = GfxFamily::cmdInitBatchBufferStart;
         bbCmd.setAddressSpaceIndicator(MI_BATCH_BUFFER_START::ADDRESS_SPACE_INDICATOR_PPGTT);
         bbCmd.setBatchBufferStartAddress(addressOfSDI);
-        bbCmd.setSecondLevelBatchBuffer(MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH);
+        bbCmd.setSecondLevelBatchBuffer(bbLevel);
         *newBuffer = bbCmd;
 
         auto storeSbaField = GfxFamily::cmdInitStoreDataImm;
@@ -150,7 +152,7 @@ void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::
         MI_BATCH_BUFFER_START bbCmd = GfxFamily::cmdInitBatchBufferStart;
         bbCmd.setAddressSpaceIndicator(MI_BATCH_BUFFER_START::ADDRESS_SPACE_INDICATOR_PPGTT);
         bbCmd.setBatchBufferStartAddress(addressOfPreviousBuffer);
-        bbCmd.setSecondLevelBatchBuffer(MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH);
+        bbCmd.setSecondLevelBatchBuffer(bbLevel);
         *previousBuffer = bbCmd;
 
         auto arbCmd = GfxFamily::cmdInitArbCheck;
diff --git a/shared/source/source_level_debugger/source_level_debugger.h b/shared/source/source_level_debugger/source_level_debugger.h
index 4944529d83..23479a67e2 100644
--- a/shared/source/source_level_debugger/source_level_debugger.h
+++ b/shared/source/source_level_debugger/source_level_debugger.h
@@ -41,7 +41,7 @@ class SourceLevelDebugger : public Debugger {
     MOCKABLE_VIRTUAL bool notifyKernelDebugData(const DebugData *debugData, const std::string &name, const void *isa, size_t isaSize) const;
     MOCKABLE_VIRTUAL bool initialize(bool useLocalMemory);
 
-    void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba) override{};
+    void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba, bool useFirstLevelBB) override{};
     size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) override {
         return 0;
     }
diff --git a/shared/test/common/mocks/mock_debugger.h b/shared/test/common/mocks/mock_debugger.h
index 33943b3a30..03b7cbbafc 100644
--- a/shared/test/common/mocks/mock_debugger.h
+++ b/shared/test/common/mocks/mock_debugger.h
@@ -15,7 +15,7 @@ class MockDebugger : public Debugger {
   public:
     MockDebugger() = default;
     ~MockDebugger() override = default;
-    void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba) override{};
+    void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba, bool useFirstLevelBB) override{};
     size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) override {
         return 0;
     }
diff --git a/shared/test/common/mocks/mock_l0_debugger.h b/shared/test/common/mocks/mock_l0_debugger.h
index 222e59e072..4a8cf39f52 100644
--- a/shared/test/common/mocks/mock_l0_debugger.h
+++ b/shared/test/common/mocks/mock_l0_debugger.h
@@ -21,7 +21,7 @@ class MockDebuggerL0 : public NEO::DebuggerL0 {
         isLegacyMode = false;
     }
 
-    void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba) override{};
+    void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba, bool useFirstLevelBB) override{};
     size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) override {
         return 0;
     }
@@ -45,9 +45,9 @@ class MockDebuggerL0Hw : public NEO::DebuggerL0Hw<GfxFamily> {
         return new MockDebuggerL0Hw<GfxFamily>(device);
     }
 
-    void captureStateBaseAddress(NEO::LinearStream &cmdStream, NEO::Debugger::SbaAddresses sba) override {
+    void captureStateBaseAddress(NEO::LinearStream &cmdStream, NEO::Debugger::SbaAddresses sba, bool useFirstLevelBB) override {
         captureStateBaseAddressCount++;
-        NEO::DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(cmdStream, sba);
+        NEO::DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(cmdStream, sba, useFirstLevelBB);
     }
 
     size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) override {
diff --git a/shared/test/unit_test/debugger/test_l0_debugger.cpp b/shared/test/unit_test/debugger/test_l0_debugger.cpp
index fc68aeea01..0b13e0b287 100644
--- a/shared/test/unit_test/debugger/test_l0_debugger.cpp
+++ b/shared/test/unit_test/debugger/test_l0_debugger.cpp
@@ -314,7 +314,7 @@ TEST(Debugger, givenNonLegacyDebuggerWhenInitializingDeviceCapsThenUnrecoverable
             isLegacyMode = false;
         }
 
-        void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba) override{};
+        void captureStateBaseAddress(NEO::LinearStream &cmdStream, SbaAddresses sba, bool useFirstLevelBB) override{};
         size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) override {
             return 0;
         }
@@ -361,7 +361,7 @@ HWTEST_F(PerContextAddressSpaceL0DebuggerTest, givenCanonizedGpuVasWhenProgrammi
     sbaAddresses.DynamicStateBaseAddress = dsba;
     sbaAddresses.BindlessSurfaceStateBaseAddress = ssba;
 
-    debugger->captureStateBaseAddress(cmdStream, sbaAddresses);
+    debugger->captureStateBaseAddress(cmdStream, sbaAddresses, false);
 
     GenCmdList cmdList;
     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
@@ -450,7 +450,7 @@ HWTEST_F(PerContextAddressSpaceL0DebuggerTest, givenNonZeroGpuVasWhenProgramming
     sbaAddresses.DynamicStateBaseAddress = dsba;
     sbaAddresses.BindlessSurfaceStateBaseAddress = ssba;
 
-    debugger->captureStateBaseAddress(cmdStream, sbaAddresses);
+    debugger->captureStateBaseAddress(cmdStream, sbaAddresses, false);
 
     GenCmdList cmdList;
     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
@@ -623,7 +623,7 @@ HWTEST2_P(L0DebuggerSimpleParameterizedTest, givenZeroGpuVasWhenProgrammingSbaTr
     sbaAddresses.GeneralStateBaseAddress = gsba;
     sbaAddresses.SurfaceStateBaseAddress = ssba;
 
-    debugger->captureStateBaseAddress(cmdStream, sbaAddresses);
+    debugger->captureStateBaseAddress(cmdStream, sbaAddresses, false);
 
     EXPECT_EQ(0u, cmdStream.getUsed());
 }
@@ -639,13 +639,13 @@ HWTEST2_P(L0DebuggerSimpleParameterizedTest, givenNotChangedSurfaceStateWhenCapt
     NEO::Debugger::SbaAddresses sba = {};
     sba.SurfaceStateBaseAddress = 0x123456000;
 
-    debugger->captureStateBaseAddress(*container.getCommandStream(), sba);
+    debugger->captureStateBaseAddress(*container.getCommandStream(), sba, false);
     auto sizeUsed = container.getCommandStream()->getUsed();
 
     EXPECT_NE(0u, sizeUsed);
     sba.SurfaceStateBaseAddress = 0;
 
-    debugger->captureStateBaseAddress(*container.getCommandStream(), sba);
+    debugger->captureStateBaseAddress(*container.getCommandStream(), sba, false);
     auto sizeUsed2 = container.getCommandStream()->getUsed();
 
     EXPECT_EQ(sizeUsed, sizeUsed2);
@@ -662,7 +662,7 @@ HWTEST2_P(L0DebuggerSimpleParameterizedTest, givenChangedBaseAddressesWhenCaptur
         NEO::Debugger::SbaAddresses sba = {};
         sba.SurfaceStateBaseAddress = 0x123456000;
 
-        debugger->captureStateBaseAddress(*container.getCommandStream(), sba);
+        debugger->captureStateBaseAddress(*container.getCommandStream(), sba, false);
         auto sizeUsed = container.getCommandStream()->getUsed();
 
         EXPECT_NE(0u, sizeUsed);
@@ -675,7 +675,7 @@ HWTEST2_P(L0DebuggerSimpleParameterizedTest, givenChangedBaseAddressesWhenCaptur
         NEO::Debugger::SbaAddresses sba = {};
         sba.GeneralStateBaseAddress = 0x123456000;
 
-        debugger->captureStateBaseAddress(*container.getCommandStream(), sba);
+        debugger->captureStateBaseAddress(*container.getCommandStream(), sba, false);
         auto sizeUsed = container.getCommandStream()->getUsed();
 
         EXPECT_NE(0u, sizeUsed);
@@ -688,7 +688,7 @@ HWTEST2_P(L0DebuggerSimpleParameterizedTest, givenChangedBaseAddressesWhenCaptur
         NEO::Debugger::SbaAddresses sba = {};
         sba.BindlessSurfaceStateBaseAddress = 0x123456000;
 
-        debugger->captureStateBaseAddress(*container.getCommandStream(), sba);
+        debugger->captureStateBaseAddress(*container.getCommandStream(), sba, false);
         auto sizeUsed = container.getCommandStream()->getUsed();
 
         EXPECT_NE(0u, sizeUsed);
diff --git a/shared/test/unit_test/debugger/test_l0_debugger_single_address_space.cpp b/shared/test/unit_test/debugger/test_l0_debugger_single_address_space.cpp
index 018ae5539e..f980c6c246 100644
--- a/shared/test/unit_test/debugger/test_l0_debugger_single_address_space.cpp
+++ b/shared/test/unit_test/debugger/test_l0_debugger_single_address_space.cpp
@@ -28,6 +28,17 @@ struct SingleAddressSpaceFixture : public Test<NEO::DeviceFixture> {
     DebugManagerStateRestore restorer;
 };
 
+struct L0DebuggerBBlevelParameterizedTest : ::testing::TestWithParam<bool>, public NEO::DeviceFixture {
+    void SetUp() override {
+        NEO::DebugManager.flags.DebuggerForceSbaTrackingMode.set(1);
+        DeviceFixture::setUp();
+    }
+    void TearDown() override {
+        DeviceFixture::tearDown();
+    }
+    DebugManagerStateRestore restorer;
+};
+
 HWTEST_F(SingleAddressSpaceFixture, givenDebugFlagForceSbaTrackingModeSetWhenDebuggerIsCreatedThenItHasCorrectSingleAddressSpaceValue) {
     DebugManagerStateRestore restorer;
     NEO::DebugManager.flags.DebuggerForceSbaTrackingMode.set(1);
@@ -86,13 +97,13 @@ HWTEST2_F(SingleAddressSpaceFixture, WhenProgrammingSbaTrackingCommandsForSingle
     sbaAddresses.DynamicStateBaseAddress = dsba;
     sbaAddresses.BindlessSurfaceStateBaseAddress = ssba;
 
-    EXPECT_THROW(debugger->programSbaTrackingCommandsSingleAddressSpace(cmdStream, sbaAddresses), std::exception);
+    EXPECT_THROW(debugger->programSbaTrackingCommandsSingleAddressSpace(cmdStream, sbaAddresses, false), std::exception);
 
     EXPECT_EQ(0u, cmdStream.getUsed());
     EXPECT_THROW(debugger->getSbaTrackingCommandsSize(6), std::exception);
 }
 
-HWTEST2_F(SingleAddressSpaceFixture, GivenNonZeroSbaAddressesWhenProgrammingSbaTrackingCommandsForSingleAddressSpaceThenCorrectSequenceOfCommandsAreAddedToStream, IsAtLeastGen12lp) {
+HWTEST2_P(L0DebuggerBBlevelParameterizedTest, GivenNonZeroSbaAddressesWhenProgrammingSbaTrackingCommandsForSingleAddressSpaceThenCorrectSequenceOfCommandsAreAddedToStream, IsAtLeastGen12lp) {
     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(pDevice);
     using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
     using MI_ARB_CHECK = typename FamilyType::MI_ARB_CHECK;
@@ -109,7 +120,7 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenNonZeroSbaAddressesWhenProgrammingSbaT
                                                     pDevice->getDeviceBitfield()};
     auto streamAllocation = pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(commandBufferProperties);
     ASSERT_NE(nullptr, streamAllocation);
-
+    auto expectedBbLevel = GetParam() ? MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH : MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH;
     NEO::LinearStream cmdStream;
     cmdStream.replaceGraphicsAllocation(streamAllocation);
     cmdStream.replaceBuffer(streamAllocation->getUnderlyingBuffer(), streamAllocation->getUnderlyingBufferSize());
@@ -128,7 +139,7 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenNonZeroSbaAddressesWhenProgrammingSbaT
     sbaAddresses.DynamicStateBaseAddress = dsba;
     sbaAddresses.BindlessSurfaceStateBaseAddress = ssba;
 
-    debugger->programSbaTrackingCommandsSingleAddressSpace(cmdStream, sbaAddresses);
+    debugger->programSbaTrackingCommandsSingleAddressSpace(cmdStream, sbaAddresses, GetParam());
 
     GenCmdList cmdList;
     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
@@ -156,6 +167,8 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenNonZeroSbaAddressesWhenProgrammingSbaT
 
     itor = find<MI_BATCH_BUFFER_START *>(itor, cmdList.end());
     ASSERT_NE(cmdList.end(), itor);
+    auto bbLevel = genCmdCast<MI_BATCH_BUFFER_START *>(*itor)->getSecondLevelBatchBuffer();
+    ASSERT_EQ(bbLevel, expectedBbLevel);
 
     for (int i = 0; i < 6; i++) {
         itor = find<MI_LOAD_REGISTER_IMM *>(itor, cmdList.end());
@@ -188,6 +201,8 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenNonZeroSbaAddressesWhenProgrammingSbaT
 
         itor = find<MI_BATCH_BUFFER_START *>(itor, cmdList.end());
         ASSERT_NE(cmdList.end(), itor);
+        bbLevel = genCmdCast<MI_BATCH_BUFFER_START *>(*itor)->getSecondLevelBatchBuffer();
+        ASSERT_EQ(bbLevel, expectedBbLevel);
 
         itor = find<MI_STORE_DATA_IMM *>(itor, cmdList.end());
         ASSERT_NE(cmdList.end(), itor);
@@ -195,6 +210,8 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenNonZeroSbaAddressesWhenProgrammingSbaT
 
     itor = find<MI_BATCH_BUFFER_START *>(itor, cmdList.end());
     ASSERT_NE(cmdList.end(), itor);
+    bbLevel = genCmdCast<MI_BATCH_BUFFER_START *>(*itor)->getSecondLevelBatchBuffer();
+    ASSERT_EQ(bbLevel, expectedBbLevel);
 
     itor = find<MI_ARB_CHECK *>(itor, cmdList.end());
     ASSERT_NE(cmdList.end(), itor);
@@ -206,7 +223,7 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenNonZeroSbaAddressesWhenProgrammingSbaT
     pDevice->getMemoryManager()->freeGraphicsMemory(streamAllocation);
 }
 
-HWTEST2_F(SingleAddressSpaceFixture, GivenOneNonZeroSbaAddressesWhenProgrammingSbaTrackingCommandsForSingleAddressSpaceThenONlyPartOfCommandsAreAddedToStream, IsAtLeastGen12lp) {
+HWTEST2_P(L0DebuggerBBlevelParameterizedTest, GivenOneNonZeroSbaAddressesWhenProgrammingSbaTrackingCommandsForSingleAddressSpaceThenONlyPartOfCommandsAreAddedToStream, IsAtLeastGen12lp) {
     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(pDevice);
     using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
     using MI_ARB_CHECK = typename FamilyType::MI_ARB_CHECK;
@@ -232,9 +249,9 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenOneNonZeroSbaAddressesWhenProgrammingS
 
     NEO::Debugger::SbaAddresses sbaAddresses = {0};
     sbaAddresses.SurfaceStateBaseAddress = ssba;
-
+    auto expectedBbLevel = GetParam() ? MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH : MI_BATCH_BUFFER_START::SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH;
     debugger->singleAddressSpaceSbaTracking = true;
-    debugger->captureStateBaseAddress(cmdStream, sbaAddresses);
+    debugger->captureStateBaseAddress(cmdStream, sbaAddresses, GetParam());
 
     GenCmdList cmdList;
     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
@@ -259,6 +276,8 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenOneNonZeroSbaAddressesWhenProgrammingS
 
     itor = find<MI_BATCH_BUFFER_START *>(itor, cmdList.end());
     ASSERT_NE(cmdList.end(), itor);
+    auto bbLevel = genCmdCast<MI_BATCH_BUFFER_START *>(*itor)->getSecondLevelBatchBuffer();
+    ASSERT_EQ(bbLevel, expectedBbLevel);
 
     itor = find<MI_LOAD_REGISTER_IMM *>(itor, cmdList.end());
     ASSERT_NE(cmdList.end(), itor);
@@ -294,12 +313,16 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenOneNonZeroSbaAddressesWhenProgrammingS
 
     itor = find<MI_BATCH_BUFFER_START *>(itor, cmdList.end());
     ASSERT_NE(cmdList.end(), itor);
+    bbLevel = genCmdCast<MI_BATCH_BUFFER_START *>(*itor)->getSecondLevelBatchBuffer();
+    ASSERT_EQ(bbLevel, expectedBbLevel);
 
     itor = find<MI_STORE_DATA_IMM *>(itor, cmdList.end());
     ASSERT_NE(cmdList.end(), itor);
 
     itor = find<MI_BATCH_BUFFER_START *>(itor, cmdList.end());
     ASSERT_NE(cmdList.end(), itor);
+    bbLevel = genCmdCast<MI_BATCH_BUFFER_START *>(*itor)->getSecondLevelBatchBuffer();
+    ASSERT_EQ(bbLevel, expectedBbLevel);
 
     itor = find<MI_ARB_CHECK *>(itor, cmdList.end());
     ASSERT_NE(cmdList.end(), itor);
@@ -311,6 +334,8 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenOneNonZeroSbaAddressesWhenProgrammingS
     pDevice->getMemoryManager()->freeGraphicsMemory(streamAllocation);
 }
 
+INSTANTIATE_TEST_CASE_P(BBLevelForSbaTracking, L0DebuggerBBlevelParameterizedTest, ::testing::Values(false, true));
+
 HWTEST2_F(SingleAddressSpaceFixture, GivenAllZeroSbaAddressesWhenProgrammingSbaTrackingCommandsForSingleAddressSpaceThenNoCommandsAreAddedToStream, IsAtLeastGen12lp) {
     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(pDevice);
     AllocationProperties commandBufferProperties = {pDevice->getRootDeviceIndex(),
@@ -327,7 +352,7 @@ HWTEST2_F(SingleAddressSpaceFixture, GivenAllZeroSbaAddressesWhenProgrammingSbaT
     cmdStream.replaceBuffer(streamAllocation->getUnderlyingBuffer(), streamAllocation->getUnderlyingBufferSize());
     NEO::Debugger::SbaAddresses sbaAddresses = {0};
 
-    debugger->programSbaTrackingCommandsSingleAddressSpace(cmdStream, sbaAddresses);
+    debugger->programSbaTrackingCommandsSingleAddressSpace(cmdStream, sbaAddresses, false);
     size_t sizeExpected = 0;
     EXPECT_EQ(sizeExpected, cmdStream.getUsed());