intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-30 01:35:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

Enhance SBA tracking

Browse Source 
Related-To: NEO-4637

Change-Id: I0cd0cf17bac332f1a00c10a324f94e91fe031c0a
Signed-off-by: Mateusz Hoppe <mateusz.hoppe@intel.com>
This commit is contained in:
Mateusz Hoppe
2020-08-24 09:27:30 +02:00
committed by sys_ocldev
parent 473e74b617
commit 75710fead9
10 changed files with 136 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@@ -1606,7 +1606,15 @@ void CommandListCoreFamily<gfxCoreFamily>::programStateBaseAddress(NEO::CommandC
STATE_BASE_ADDRESS sba;
NEO::EncodeStateBaseAddress<GfxFamily>::encode(commandContainer, sba);
if (device->getL0Debugger()) {
device->getL0Debugger()->captureStateBaseAddress(commandContainer);
NEO::Debugger::SbaAddresses sbaAddresses = {};
sbaAddresses.BindlessSurfaceStateBaseAddress = sba.getBindlessSurfaceStateBaseAddress();
sbaAddresses.DynamicStateBaseAddress = sba.getDynamicStateBaseAddress();
sbaAddresses.GeneralStateBaseAddress = sba.getGeneralStateBaseAddress();
sbaAddresses.IndirectObjectBaseAddress = sba.getIndirectObjectBaseAddress();
sbaAddresses.InstructionBaseAddress = sba.getInstructionBaseAddress();
sbaAddresses.SurfaceStateBaseAddress = sba.getSurfaceStateBaseAddress();
device->getL0Debugger()->captureStateBaseAddress(commandContainer, sbaAddresses);
}
commandContainer.setDirtyStateForAllHeaps(false);
}

11
level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl
View File

@@ -63,7 +63,16 @@ void CommandQueueHw<gfxCoreFamily>::programGeneralStateBaseAddress(uint64_t gsba
gsbaInit = true;
if (device->getL0Debugger()) {
device->getL0Debugger()->programSbaTrackingCommands(commandStream, gsba, 0);
NEO::Debugger::SbaAddresses sbaAddresses = {};
sbaAddresses.BindlessSurfaceStateBaseAddress = sbaCmd.getBindlessSurfaceStateBaseAddress();
sbaAddresses.DynamicStateBaseAddress = sbaCmd.getDynamicStateBaseAddress();
sbaAddresses.GeneralStateBaseAddress = sbaCmd.getGeneralStateBaseAddress();
sbaAddresses.IndirectObjectBaseAddress = sbaCmd.getIndirectObjectBaseAddress();
sbaAddresses.InstructionBaseAddress = sbaCmd.getInstructionBaseAddress();
sbaAddresses.SurfaceStateBaseAddress = sbaCmd.getSurfaceStateBaseAddress();
device->getL0Debugger()->programSbaTrackingCommands(commandStream, sbaAddresses);
}
NEO::EncodeWA<GfxFamily>::encodeAdditionalPipelineSelect(*device->getNEODevice(), commandStream, false);

14
level_zero/core/source/debugger/debugger_l0.cpp
View File

@@ -53,7 +53,11 @@ void DebuggerL0::printTrackedAddresses(uint32_t contextId) {
auto sba = reinterpret_cast<SbaTrackedAddresses *>(memory);
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stdout,
"Debugger: SBA ssh = %" SCNx64 " gsba = %" SCNx64 " \n", sba->SurfaceStateBaseAddress, sba->GeneralStateBaseAddress);
"Debugger: SBA ssh = %" SCNx64
" gsba = %" SCNx64
" bsurfsba = %" SCNx64 "\n",
sba->SurfaceStateBaseAddress, sba->GeneralStateBaseAddress,
sba->BindlessSurfaceStateBaseAddress);
}
DebuggerL0 ::~DebuggerL0() {
@@ -67,12 +71,10 @@ bool DebuggerL0::isDebuggerActive() {
return true;
}
void DebuggerL0::captureStateBaseAddress(NEO::CommandContainer &container) {
uint64_t ssh = 0;
if (container.isHeapDirty(NEO::HeapType::SURFACE_STATE)) {
ssh = container.getIndirectHeap(NEO::HeapType::SURFACE_STATE)->getHeapGpuBase();
void DebuggerL0::captureStateBaseAddress(NEO::CommandContainer &container, SbaAddresses sba) {
if (DebuggerL0::isAnyTrackedAddressChanged(sba)) {
programSbaTrackingCommands(*container.getCommandStream(), sba);
}
programSbaTrackingCommands(*container.getCommandStream(), 0, ssh);
}
} // namespace L0

12
level_zero/core/source/debugger/debugger_l0.h
View File

@@ -52,13 +52,19 @@ class DebuggerL0 : public NEO::Debugger, NEO::NonCopyableOrMovableClass {
return sbaTrackingGpuVa.address;
}
void captureStateBaseAddress(NEO::CommandContainer &container) override;
void captureStateBaseAddress(NEO::CommandContainer &container, SbaAddresses sba) override;
void printTrackedAddresses(uint32_t contextId);
virtual size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) const = 0;
virtual void programSbaTrackingCommands(NEO::LinearStream &cmdStream, uint64_t generalStateGpuVa, uint64_t surfaceStateGpuVa) const = 0;
virtual void programSbaTrackingCommands(NEO::LinearStream &cmdStream, const SbaAddresses &sba) const = 0;
protected:
static bool isAnyTrackedAddressChanged(SbaAddresses sba) {
return sba.GeneralStateBaseAddress != 0 ||
sba.SurfaceStateBaseAddress != 0 ||
sba.BindlessSurfaceStateBaseAddress != 0;
}
NEO::Device *device = nullptr;
NEO::GraphicsAllocation *sbaAllocation = nullptr;
std::unordered_map<uint32_t, NEO::GraphicsAllocation *> perContextSbaAllocations;
@@ -74,7 +80,7 @@ class DebuggerL0Hw : public DebuggerL0 {
static DebuggerL0 *allocate(NEO::Device *device);
size_t getSbaTrackingCommandsSize(size_t trackedAddressCount) const override;
void programSbaTrackingCommands(NEO::LinearStream &cmdStream, uint64_t generalStateGpuVa, uint64_t surfaceStateGpuVa) const override;
void programSbaTrackingCommands(NEO::LinearStream &cmdStream, const SbaAddresses &sba) const override;
protected:
DebuggerL0Hw(NEO::Device *device) : DebuggerL0(device){};

32
level_zero/core/source/debugger/debugger_l0.inl
View File

@@ -21,32 +21,46 @@ size_t DebuggerL0Hw<GfxFamily>::getSbaTrackingCommandsSize(size_t trackedAddress
}
template <typename GfxFamily>
void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommands(NEO::LinearStream &cmdStream, uint64_t generalStateGpuVa, uint64_t surfaceStateGpuVa) const {
void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommands(NEO::LinearStream &cmdStream, const SbaAddresses &sba) const {
using MI_STORE_DATA_IMM = typename GfxFamily::MI_STORE_DATA_IMM;
auto gpuAddress = NEO::GmmHelper::decanonize(sbaTrackingGpuVa.address);
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stdout,
"Debugger: SBA stored ssh = %" SCNx64 " gsba = %" SCNx64 " \n", surfaceStateGpuVa, generalStateGpuVa);
"Debugger: SBA stored ssh = %" SCNx64
" gsba = %" SCNx64
" bsurfsba = %" SCNx64 "\n",
sba.SurfaceStateBaseAddress, sba.GeneralStateBaseAddress,
sba.BindlessSurfaceStateBaseAddress);
if (generalStateGpuVa) {
if (sba.GeneralStateBaseAddress) {
MI_STORE_DATA_IMM storeDataImmediate = GfxFamily::cmdInitStoreDataImm;
storeDataImmediate.setAddress(gpuAddress + offsetof(SbaTrackedAddresses, GeneralStateBaseAddress));
storeDataImmediate.setStoreQword(true);
storeDataImmediate.setDwordLength(MI_STORE_DATA_IMM::DWORD_LENGTH::DWORD_LENGTH_STORE_QWORD);
storeDataImmediate.setDataDword0(static_cast<uint32_t>(generalStateGpuVa & 0x0000FFFFFFFFULL));
storeDataImmediate.setDataDword1(static_cast<uint32_t>(generalStateGpuVa >> 32));
storeDataImmediate.setDataDword0(static_cast<uint32_t>(sba.GeneralStateBaseAddress & 0x0000FFFFFFFFULL));
storeDataImmediate.setDataDword1(static_cast<uint32_t>(sba.GeneralStateBaseAddress >> 32));
auto storeDataImmediateSpace = cmdStream.getSpaceForCmd<MI_STORE_DATA_IMM>();
*storeDataImmediateSpace = storeDataImmediate;
}
if (surfaceStateGpuVa) {
if (sba.SurfaceStateBaseAddress) {
MI_STORE_DATA_IMM storeDataImmediate = GfxFamily::cmdInitStoreDataImm;
storeDataImmediate.setAddress(gpuAddress + offsetof(SbaTrackedAddresses, SurfaceStateBaseAddress));
storeDataImmediate.setStoreQword(true);
storeDataImmediate.setDwordLength(MI_STORE_DATA_IMM::DWORD_LENGTH::DWORD_LENGTH_STORE_QWORD);
storeDataImmediate.setDataDword0(static_cast<uint32_t>(surfaceStateGpuVa & 0x0000FFFFFFFFULL));
storeDataImmediate.setDataDword1(static_cast<uint32_t>(surfaceStateGpuVa >> 32));
storeDataImmediate.setDataDword0(static_cast<uint32_t>(sba.SurfaceStateBaseAddress & 0x0000FFFFFFFFULL));
storeDataImmediate.setDataDword1(static_cast<uint32_t>(sba.SurfaceStateBaseAddress >> 32));
auto storeDataImmediateSpace = cmdStream.getSpaceForCmd<MI_STORE_DATA_IMM>();
*storeDataImmediateSpace = storeDataImmediate;
}
if (sba.BindlessSurfaceStateBaseAddress) {
MI_STORE_DATA_IMM storeDataImmediate = GfxFamily::cmdInitStoreDataImm;
storeDataImmediate.setAddress(gpuAddress + offsetof(SbaTrackedAddresses, BindlessSurfaceStateBaseAddress));
storeDataImmediate.setStoreQword(true);
storeDataImmediate.setDwordLength(MI_STORE_DATA_IMM::DWORD_LENGTH::DWORD_LENGTH_STORE_QWORD);
storeDataImmediate.setDataDword0(static_cast<uint32_t>(sba.BindlessSurfaceStateBaseAddress & 0x0000FFFFFFFFULL));
storeDataImmediate.setDataDword1(static_cast<uint32_t>(sba.BindlessSurfaceStateBaseAddress >> 32));
auto storeDataImmediateSpace = cmdStream.getSpaceForCmd<MI_STORE_DATA_IMM>();
*storeDataImmediateSpace = storeDataImmediate;

4
level_zero/core/test/unit_tests/mocks/mock_l0_debugger.h
View File

@@ -25,9 +25,9 @@ class MockDebuggerL0Hw : public L0::DebuggerL0Hw<GfxFamily> {
return new MockDebuggerL0Hw<GfxFamily>(device);
}
void captureStateBaseAddress(NEO::CommandContainer &container) override {
void captureStateBaseAddress(NEO::CommandContainer &container, NEO::Debugger::SbaAddresses sba) override {
captureStateBaseAddressCount++;
L0::DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(container);
L0::DebuggerL0Hw<GfxFamily>::captureStateBaseAddress(container, sba);
}
uint32_t captureStateBaseAddressCount = 0;
};

67
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger.cpp
View File

@@ -485,7 +485,11 @@ HWTEST_F(L0DebuggerSimpleTest, givenNonZeroGpuVasWhenProgrammingSbaTrackingThenC
uint64_t gsba = 0x60000;
uint64_t ssba = 0x1234567000;
debugger->programSbaTrackingCommands(cmdStream, gsba, ssba);
NEO::Debugger::SbaAddresses sbaAddresses = {};
sbaAddresses.GeneralStateBaseAddress = gsba;
sbaAddresses.SurfaceStateBaseAddress = ssba;
debugger->programSbaTrackingCommands(cmdStream, sbaAddresses);
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
@@ -522,7 +526,11 @@ HWTEST_F(L0DebuggerSimpleTest, givenZeroGpuVasWhenProgrammingSbaTrackingThenStre
uint64_t gsba = 0;
uint64_t ssba = 0;
debugger->programSbaTrackingCommands(cmdStream, gsba, ssba);
NEO::Debugger::SbaAddresses sbaAddresses = {};
sbaAddresses.GeneralStateBaseAddress = gsba;
sbaAddresses.SurfaceStateBaseAddress = ssba;
debugger->programSbaTrackingCommands(cmdStream, sbaAddresses);
EXPECT_EQ(0u, cmdStream.getUsed());
}
@@ -533,7 +541,7 @@ HWTEST_F(L0DebuggerSimpleTest, whenAllocateCalledThenDebuggerIsCreated) {
delete debugger;
}
HWTEST_F(L0DebuggerSimpleTest, givenNotDirtySSHWhenCapturingSBAThenNoTrackingCmdsAreAdded) {
HWTEST_F(L0DebuggerSimpleTest, givenNotChangedSurfaceStateWhenCapturingSBAThenNoTrackingCmdsAreAdded) {
auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
debugger->sbaTrackingGpuVa.address = 0x45670000;
@@ -541,16 +549,63 @@ HWTEST_F(L0DebuggerSimpleTest, givenNotDirtySSHWhenCapturingSBAThenNoTrackingCmd
NEO::CommandContainer container;
container.initialize(neoDevice);
debugger->captureStateBaseAddress(container);
NEO::Debugger::SbaAddresses sba = {};
sba.SurfaceStateBaseAddress = 0x123456000;
debugger->captureStateBaseAddress(container, sba);
auto sizeUsed = container.getCommandStream()->getUsed();
EXPECT_NE(0u, sizeUsed);
container.setDirtyStateForAllHeaps(false);
sba.SurfaceStateBaseAddress = 0;
debugger->captureStateBaseAddress(container);
debugger->captureStateBaseAddress(container, sba);
auto sizeUsed2 = container.getCommandStream()->getUsed();
EXPECT_EQ(sizeUsed, sizeUsed2);
}
HWTEST_F(L0DebuggerSimpleTest, givenChangedBaseAddressesWhenCapturingSBAThenNoTrackingCmdsAreAdded) {
auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
debugger->sbaTrackingGpuVa.address = 0x45670000;
{
NEO::CommandContainer container;
container.initialize(neoDevice);
NEO::Debugger::SbaAddresses sba = {};
sba.SurfaceStateBaseAddress = 0x123456000;
debugger->captureStateBaseAddress(container, sba);
auto sizeUsed = container.getCommandStream()->getUsed();
EXPECT_NE(0u, sizeUsed);
}
{
NEO::CommandContainer container;
container.initialize(neoDevice);
NEO::Debugger::SbaAddresses sba = {};
sba.GeneralStateBaseAddress = 0x123456000;
debugger->captureStateBaseAddress(container, sba);
auto sizeUsed = container.getCommandStream()->getUsed();
EXPECT_NE(0u, sizeUsed);
}
{
NEO::CommandContainer container;
container.initialize(neoDevice);
NEO::Debugger::SbaAddresses sba = {};
sba.BindlessSurfaceStateBaseAddress = 0x123456000;
debugger->captureStateBaseAddress(container, sba);
auto sizeUsed = container.getCommandStream()->getUsed();
EXPECT_NE(0u, sizeUsed);
}
}
} // namespace ult
} // namespace L0

3
opencl/test/unit_test/source_level_debugger/source_level_debugger_tests.cpp
View File

@@ -611,6 +611,7 @@ TEST(SourceLevelDebugger, whenCaptureSBACalledThenNoCommandsAreAddedToStream) {
CommandContainer container;
container.initialize(device.get());
debugger.captureStateBaseAddress(container);
NEO::Debugger::SbaAddresses sbaAddresses = {};
debugger.captureStateBaseAddress(container, sbaAddresses);
EXPECT_EQ(0u, container.getCommandStream()->getUsed());
}

12
shared/source/debugger/debugger.h
View File

@@ -14,11 +14,21 @@ class IndirectHeap;
class Debugger {
public:
struct SbaAddresses {
uint64_t GeneralStateBaseAddress = 0;
uint64_t SurfaceStateBaseAddress = 0;
uint64_t DynamicStateBaseAddress = 0;
uint64_t IndirectObjectBaseAddress = 0;
uint64_t InstructionBaseAddress = 0;
uint64_t BindlessSurfaceStateBaseAddress = 0;
uint64_t BindlessSamplerStateBaseAddress = 0;
};
static std::unique_ptr<Debugger> create(HardwareInfo *hwInfo);
virtual ~Debugger() = default;
virtual bool isDebuggerActive() = 0;
bool isLegacy() const { return isLegacyMode; }
virtual void captureStateBaseAddress(CommandContainer &container) = 0;
virtual void captureStateBaseAddress(CommandContainer &container, SbaAddresses sba) = 0;
void *getDebugSurfaceReservedSurfaceState(IndirectHeap &ssh);

2
shared/source/source_level_debugger/source_level_debugger.h
View File

@@ -31,7 +31,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(CommandContainer &container) override{};
void captureStateBaseAddress(CommandContainer &container, SbaAddresses sba) override{};
protected:
class SourceLevelDebuggerInterface;