From 278bb83c5697d4678324ae1d51a85247b0750f10 Mon Sep 17 00:00:00 2001 From: "Milczarek, Slawomir" Date: Tue, 19 Feb 2019 22:50:52 +0100 Subject: [PATCH] Enable AUB sub-capture in AubStream captures (1/n) Change-Id: I6bd0605d06cf4dc3937e2dbeba7ed7037ae91476 --- runtime/aub/aub_center.cpp | 17 ++- runtime/aub/aub_center.h | 6 + runtime/aub/aub_stream_interface.cpp | 4 +- runtime/aub_mem_dump/aub_mem_dump.h | 5 +- runtime/aub_mem_dump/aub_stream_stubs.cpp | 2 +- .../aub_command_stream_receiver.cpp | 18 +++ .../aub_command_stream_receiver_hw.h | 4 +- .../aub_command_stream_receiver_hw.inl | 51 ++++----- third_party/aub_stream/headers/aub_manager.h | 9 +- unit_tests/aub/aub_center_tests.cpp | 32 +++++- .../aub_stream_interface_mock.cpp | 4 +- .../aub_command_stream_fixture.h | 16 +-- .../aub_command_stream_receiver_1_tests.cpp | 108 ++++++++---------- .../aub_command_stream_receiver_2_tests.cpp | 4 +- .../command_stream/aub_file_stream_tests.cpp | 94 ++++++++++++--- unit_tests/mocks/mock_aub_csr.h | 2 +- unit_tests/mocks/mock_aub_file_stream.h | 27 +++++ unit_tests/mocks/mock_aub_manager.h | 31 ++++- 18 files changed, 292 insertions(+), 142 deletions(-) diff --git a/runtime/aub/aub_center.cpp b/runtime/aub/aub_center.cpp index 5d318b4127..1a602497af 100644 --- a/runtime/aub/aub_center.cpp +++ b/runtime/aub/aub_center.cpp @@ -16,7 +16,7 @@ #include "third_party/aub_stream/headers/modes.h" namespace OCLRT { -extern aub_stream::AubManager *createAubManager(uint32_t productFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, const std::string &aubFileName, uint32_t streamMode); +extern aub_stream::AubManager *createAubManager(uint32_t productFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, uint32_t streamMode); AubCenter::AubCenter(const HardwareInfo *pHwInfo, bool localMemoryEnabled, const std::string &aubFileName, CommandStreamReceiverType csrType) { if (DebugManager.flags.UseAubStream.get()) { @@ -33,15 +33,28 @@ AubCenter::AubCenter(const HardwareInfo *pHwInfo, bool localMemoryEnabled, const aub_stream::tbxServerIp = DebugManager.flags.TbxServer.get(); aub_stream::tbxServerPort = DebugManager.flags.TbxPort.get(); - aubManager.reset(createAubManager(pHwInfo->pPlatform->eProductFamily, devicesCount, memoryBankSize, localMemoryEnabled, aubFileName, aubStreamMode)); + aubManager.reset(createAubManager(pHwInfo->pPlatform->eProductFamily, devicesCount, memoryBankSize, localMemoryEnabled, aubStreamMode)); } addressMapper = std::make_unique(); streamProvider = std::make_unique(); + + subCaptureManager = std::make_unique(aubFileName); + if (DebugManager.flags.AUBDumpSubCaptureMode.get()) { + this->subCaptureManager->subCaptureMode = static_cast(DebugManager.flags.AUBDumpSubCaptureMode.get()); + this->subCaptureManager->subCaptureFilter.dumpKernelStartIdx = static_cast(DebugManager.flags.AUBDumpFilterKernelStartIdx.get()); + this->subCaptureManager->subCaptureFilter.dumpKernelEndIdx = static_cast(DebugManager.flags.AUBDumpFilterKernelEndIdx.get()); + this->subCaptureManager->subCaptureFilter.dumpNamedKernelStartIdx = static_cast(DebugManager.flags.AUBDumpFilterNamedKernelStartIdx.get()); + this->subCaptureManager->subCaptureFilter.dumpNamedKernelEndIdx = static_cast(DebugManager.flags.AUBDumpFilterNamedKernelEndIdx.get()); + if (DebugManager.flags.AUBDumpFilterKernelName.get() != "unk") { + this->subCaptureManager->subCaptureFilter.dumpKernelName = DebugManager.flags.AUBDumpFilterKernelName.get(); + } + } } AubCenter::AubCenter() { addressMapper = std::make_unique(); streamProvider = std::make_unique(); + subCaptureManager = std::make_unique(""); } uint32_t AubCenter::getAubStreamMode(const std::string &aubFileName, uint32_t csrType) { diff --git a/runtime/aub/aub_center.h b/runtime/aub/aub_center.h index d65f336a03..8fd6a7dddc 100644 --- a/runtime/aub/aub_center.h +++ b/runtime/aub/aub_center.h @@ -8,6 +8,7 @@ #pragma once #include "runtime/command_stream/aub_stream_provider.h" #include "runtime/helpers/options.h" +#include "runtime/command_stream/aub_subcapture.h" #include "runtime/memory_manager/address_mapper.h" #include "runtime/memory_manager/physical_address_allocator.h" #include "third_party/aub_stream/headers/aub_manager.h" @@ -38,6 +39,10 @@ class AubCenter { return streamProvider.get(); } + AubSubCaptureManager *getSubCaptureManager() const { + return subCaptureManager.get(); + } + aub_stream::AubManager *getAubManager() const { return aubManager.get(); } @@ -49,6 +54,7 @@ class AubCenter { std::unique_ptr addressMapper; std::unique_ptr streamProvider; + std::unique_ptr subCaptureManager; std::unique_ptr aubManager; uint32_t aubStreamMode = 0; }; diff --git a/runtime/aub/aub_stream_interface.cpp b/runtime/aub/aub_stream_interface.cpp index 68745bef7b..103fa8bd51 100644 --- a/runtime/aub/aub_stream_interface.cpp +++ b/runtime/aub/aub_stream_interface.cpp @@ -8,7 +8,7 @@ #include "runtime/aub/aub_center.h" using namespace aub_stream; namespace OCLRT { -AubManager *createAubManager(uint32_t gfxFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, const std::string &aubFileName, uint32_t streamMode) { - return AubManager::create(gfxFamily, devicesCount, memoryBankSize, localMemorySupported, aubFileName, streamMode); +AubManager *createAubManager(uint32_t gfxFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, uint32_t streamMode) { + return AubManager::create(gfxFamily, devicesCount, memoryBankSize, localMemorySupported, streamMode); } } // namespace OCLRT diff --git a/runtime/aub_mem_dump/aub_mem_dump.h b/runtime/aub_mem_dump/aub_mem_dump.h index 2e166103e7..d66ea69de2 100644 --- a/runtime/aub_mem_dump/aub_mem_dump.h +++ b/runtime/aub_mem_dump/aub_mem_dump.h @@ -131,10 +131,11 @@ struct AubFileStream : public AubStream { void writeGTT(uint32_t offset, uint64_t entry) override; void writeMMIOImpl(uint32_t offset, uint32_t value) override; void registerPoll(uint32_t registerOffset, uint32_t mask, uint32_t value, bool pollNotEqual, uint32_t timeoutAction) override; - bool isOpen() const { return fileHandle.is_open(); } - const std::string &getFileName() const { return fileName; } + MOCKABLE_VIRTUAL bool isOpen() const { return fileHandle.is_open(); } + MOCKABLE_VIRTUAL const std::string &getFileName() const { return fileName; } MOCKABLE_VIRTUAL void write(const char *data, size_t size); MOCKABLE_VIRTUAL void flush(); + MOCKABLE_VIRTUAL void expectMMIO(uint32_t mmioRegister, uint32_t expectedValue); MOCKABLE_VIRTUAL void expectMemory(uint64_t physAddress, const void *memory, size_t size, uint32_t addressSpace, uint32_t compareOperation); MOCKABLE_VIRTUAL bool addComment(const char *message); diff --git a/runtime/aub_mem_dump/aub_stream_stubs.cpp b/runtime/aub_mem_dump/aub_stream_stubs.cpp index 93c7bbf0c7..61a853e0de 100644 --- a/runtime/aub_mem_dump/aub_stream_stubs.cpp +++ b/runtime/aub_mem_dump/aub_stream_stubs.cpp @@ -14,7 +14,7 @@ MMIOList injectMMIOList; std::string tbxServerIp = "127.0.0.1"; uint16_t tbxServerPort = 4321; -AubManager *AubManager::create(uint32_t gfxFamily, uint32_t devicesCount, uint64_t memoryBankSizeInGB, bool localMemorySupported, const std::string &aubFileName, uint32_t streamMode) { +AubManager *AubManager::create(uint32_t productFamily, uint32_t devicesCount, uint64_t memoryBankSizeInGB, bool localMemorySupported, uint32_t streamMode) { return nullptr; } diff --git a/runtime/command_stream/aub_command_stream_receiver.cpp b/runtime/command_stream/aub_command_stream_receiver.cpp index ee98b7bc57..9d39f01031 100644 --- a/runtime/command_stream/aub_command_stream_receiver.cpp +++ b/runtime/command_stream/aub_command_stream_receiver.cpp @@ -181,6 +181,24 @@ void AubFileStream::registerPoll(uint32_t registerOffset, uint32_t mask, uint32_ write(reinterpret_cast(&header), sizeof(header)); } +void AubFileStream::expectMMIO(uint32_t mmioRegister, uint32_t expectedValue) { + using AubMemDump::CmdServicesMemTraceRegisterCompare; + CmdServicesMemTraceRegisterCompare header; + memset(&header, 0, sizeof(header)); + header.setHeader(); + + header.data[0] = expectedValue; + header.registerOffset = mmioRegister; + header.noReadExpect = CmdServicesMemTraceRegisterCompare::NoReadExpectValues::ReadExpect; + header.registerSize = CmdServicesMemTraceRegisterCompare::RegisterSizeValues::Dword; + header.registerSpace = CmdServicesMemTraceRegisterCompare::RegisterSpaceValues::Mmio; + header.readMaskLow = 0xffffffff; + header.readMaskHigh = 0xffffffff; + header.dwordCount = (sizeof(header) / sizeof(uint32_t)) - 1; + + write(reinterpret_cast(&header), sizeof(header)); +} + void AubFileStream::expectMemory(uint64_t physAddress, const void *memory, size_t sizeRemaining, uint32_t addressSpace, uint32_t compareOperation) { using CmdServicesMemTraceMemoryCompare = AubMemDump::CmdServicesMemTraceMemoryCompare; diff --git a/runtime/command_stream/aub_command_stream_receiver_hw.h b/runtime/command_stream/aub_command_stream_receiver_hw.h index 0068bd78ba..4fcd109cb1 100644 --- a/runtime/command_stream/aub_command_stream_receiver_hw.h +++ b/runtime/command_stream/aub_command_stream_receiver_hw.h @@ -81,7 +81,7 @@ class AUBCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHwexecutionEnvironment); } - std::unique_ptr subCaptureManager; + AubSubCaptureManager *subCaptureManager = nullptr; uint32_t aubDeviceId; bool standalone; diff --git a/runtime/command_stream/aub_command_stream_receiver_hw.inl b/runtime/command_stream/aub_command_stream_receiver_hw.inl index c6bef3ae93..dfd5eae7d2 100644 --- a/runtime/command_stream/aub_command_stream_receiver_hw.inl +++ b/runtime/command_stream/aub_command_stream_receiver_hw.inl @@ -37,13 +37,13 @@ namespace OCLRT { template AUBCommandStreamReceiverHw::AUBCommandStreamReceiverHw(const HardwareInfo &hwInfoIn, const std::string &fileName, bool standalone, ExecutionEnvironment &executionEnvironment) : BaseClass(hwInfoIn, executionEnvironment), - subCaptureManager(std::make_unique(fileName)), standalone(standalone) { executionEnvironment.initAubCenter(&this->peekHwInfo(), this->localMemoryEnabled, fileName, this->getType()); auto aubCenter = executionEnvironment.aubCenter.get(); UNRECOVERABLE_IF(nullptr == aubCenter); + subCaptureManager = aubCenter->getSubCaptureManager(); aubManager = aubCenter->getAubManager(); if (!aubCenter->getPhysicalAddressAllocator()) { @@ -69,16 +69,6 @@ AUBCommandStreamReceiverHw::AUBCommandStreamReceiverHw(const Hardware this->dispatchMode = (DispatchMode)DebugManager.flags.CsrDispatchMode.get(); } - if (DebugManager.flags.AUBDumpSubCaptureMode.get()) { - this->subCaptureManager->subCaptureMode = static_cast(DebugManager.flags.AUBDumpSubCaptureMode.get()); - this->subCaptureManager->subCaptureFilter.dumpKernelStartIdx = static_cast(DebugManager.flags.AUBDumpFilterKernelStartIdx.get()); - this->subCaptureManager->subCaptureFilter.dumpKernelEndIdx = static_cast(DebugManager.flags.AUBDumpFilterKernelEndIdx.get()); - this->subCaptureManager->subCaptureFilter.dumpNamedKernelStartIdx = static_cast(DebugManager.flags.AUBDumpFilterNamedKernelStartIdx.get()); - this->subCaptureManager->subCaptureFilter.dumpNamedKernelEndIdx = static_cast(DebugManager.flags.AUBDumpFilterNamedKernelEndIdx.get()); - if (DebugManager.flags.AUBDumpFilterKernelName.get() != "unk") { - this->subCaptureManager->subCaptureFilter.dumpKernelName = DebugManager.flags.AUBDumpFilterKernelName.get(); - } - } auto debugDeviceId = DebugManager.flags.OverrideAubDeviceId.get(); this->aubDeviceId = debugDeviceId == -1 ? hwInfoIn.capabilityTable.aubDeviceId @@ -103,6 +93,7 @@ void AUBCommandStreamReceiverHw::openFile(const std::string &fileName template bool AUBCommandStreamReceiverHw::reopenFile(const std::string &fileName) { auto streamLocked = getAubStream()->lockStream(); + if (isFileOpen()) { if (fileName != getFileName()) { closeFile(); @@ -118,6 +109,14 @@ bool AUBCommandStreamReceiverHw::reopenFile(const std::string &fileNa template void AUBCommandStreamReceiverHw::initFile(const std::string &fileName) { + if (aubManager) { + if (!aubManager->isOpen()) { + aubManager->open(fileName); + DEBUG_BREAK_IF(!aubManager->isOpen()); + } + return; + } + if (!getAubStream()->isOpen()) { // Open our file stream->open(fileName.c_str()); @@ -134,17 +133,17 @@ void AUBCommandStreamReceiverHw::initFile(const std::string &fileName template void AUBCommandStreamReceiverHw::closeFile() { - stream->close(); + aubManager ? aubManager->close() : stream->close(); } template bool AUBCommandStreamReceiverHw::isFileOpen() const { - return getAubStream()->isOpen(); + return aubManager ? aubManager->isOpen() : getAubStream()->isOpen(); } template -const std::string &AUBCommandStreamReceiverHw::getFileName() { - return getAubStream()->getFileName(); +const std::string AUBCommandStreamReceiverHw::getFileName() { + return aubManager ? aubManager->getFileName() : getAubStream()->getFileName(); } template @@ -290,7 +289,7 @@ template CommandStreamReceiver *AUBCommandStreamReceiverHw::create(const HardwareInfo &hwInfoIn, const std::string &fileName, bool standalone, ExecutionEnvironment &executionEnvironment) { auto csr = new AUBCommandStreamReceiverHw(hwInfoIn, fileName, standalone, executionEnvironment); - if (!csr->aubManager && !csr->subCaptureManager->isSubCaptureMode()) { + if (!csr->subCaptureManager->isSubCaptureMode()) { csr->openFile(fileName); } @@ -664,21 +663,11 @@ bool AUBCommandStreamReceiverHw::writeMemory(AllocationView &allocati template void AUBCommandStreamReceiverHw::expectMMIO(uint32_t mmioRegister, uint32_t expectedValue) { - using AubMemDump::CmdServicesMemTraceRegisterCompare; - CmdServicesMemTraceRegisterCompare header; - memset(&header, 0, sizeof(header)); - header.setHeader(); - - header.data[0] = expectedValue; - header.registerOffset = mmioRegister; - header.noReadExpect = CmdServicesMemTraceRegisterCompare::NoReadExpectValues::ReadExpect; - header.registerSize = CmdServicesMemTraceRegisterCompare::RegisterSizeValues::Dword; - header.registerSpace = CmdServicesMemTraceRegisterCompare::RegisterSpaceValues::Mmio; - header.readMaskLow = 0xffffffff; - header.readMaskHigh = 0xffffffff; - header.dwordCount = (sizeof(header) / sizeof(uint32_t)) - 1; - - this->getAubStream()->fileHandle.write(reinterpret_cast(&header), sizeof(header)); + if (hardwareContextController) { + //Add support for expectMMIO to AubStream + return; + } + this->getAubStream()->expectMMIO(mmioRegister, expectedValue); } template diff --git a/third_party/aub_stream/headers/aub_manager.h b/third_party/aub_stream/headers/aub_manager.h index b1a886611d..17b5158664 100644 --- a/third_party/aub_stream/headers/aub_manager.h +++ b/third_party/aub_stream/headers/aub_manager.h @@ -16,10 +16,17 @@ struct HardwareContext; class AubManager { public: virtual ~AubManager() = default; + virtual HardwareContext *createHardwareContext(uint32_t device, uint32_t engine, uint32_t flags) = 0; + + virtual void open(const std::string &aubFileName) = 0; + virtual void close() = 0; + virtual bool isOpen() = 0; + virtual const std::string getFileName() = 0; + virtual void writeMemory(uint64_t gfxAddress, const void *memory, size_t size, uint32_t memoryBanks, int hint, size_t pageSize) = 0; - static AubManager *create(uint32_t productFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, const std::string &aubFileName, uint32_t streamMode); + static AubManager *create(uint32_t productFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, uint32_t streamMode); }; } // namespace aub_stream diff --git a/unit_tests/aub/aub_center_tests.cpp b/unit_tests/aub/aub_center_tests.cpp index bb1c17f51d..dd15e1b077 100644 --- a/unit_tests/aub/aub_center_tests.cpp +++ b/unit_tests/aub/aub_center_tests.cpp @@ -30,7 +30,7 @@ TEST(AubCenter, GivenUseAubStreamDebugVariableSetWhenAubCenterIsCreatedThenCreat DebugManagerStateRestore restorer; DebugManager.flags.UseAubStream.set(false); - MockAubManager *mockAubManager = new MockAubManager(platformDevices[0]->pPlatform->eProductFamily, 4, 8 * MB, true, "aub_file.aub", aub_stream::mode::aubFile); + MockAubManager *mockAubManager = new MockAubManager(platformDevices[0]->pPlatform->eProductFamily, 4, 8 * MB, true, aub_stream::mode::aubFile); MockAubCenter mockAubCenter(platformDevices[0], false, "", CommandStreamReceiverType::CSR_AUB); mockAubCenter.aubManager = std::unique_ptr(mockAubManager); @@ -38,7 +38,6 @@ TEST(AubCenter, GivenUseAubStreamDebugVariableSetWhenAubCenterIsCreatedThenCreat EXPECT_EQ(4, mockAubManager->mockAubManagerParams.devicesCount); EXPECT_EQ(8 * MB, mockAubManager->mockAubManagerParams.memoryBankSize); EXPECT_EQ(true, mockAubManager->mockAubManagerParams.localMemorySupported); - EXPECT_STREQ("aub_file.aub", mockAubManager->mockAubManagerParams.aubFileName.c_str()); EXPECT_EQ(aub_stream::mode::aubFile, mockAubManager->mockAubManagerParams.streamMode); } @@ -122,3 +121,32 @@ TEST(AubCenter, GivenSetCommandStreamReceiverFlagSetWhenAubManagerIsCreatedThenD MockAubCenter aubCenter2(platformDevices[0], true, "", CommandStreamReceiverType::CSR_AUB); EXPECT_EQ(aub_stream::mode::aubFileAndTbx, aubCenter2.aubStreamMode); } + +TEST(AubCenter, GivenAubCenterInSubCaptureModeWhenItIsCreatedWithoutDebugFilterSettingsThenItInitializesSubCaptureFiltersWithDefaults) { + DebugManagerStateRestore restorer; + DebugManager.flags.AUBDumpSubCaptureMode.set(static_cast(AubSubCaptureManager::SubCaptureMode::Filter)); + + MockAubCenter aubCenter(platformDevices[0], false, "", CommandStreamReceiverType::CSR_AUB); + auto subCaptureManager = aubCenter.getSubCaptureManager(); + EXPECT_NE(nullptr, subCaptureManager); + + EXPECT_EQ(0u, subCaptureManager->subCaptureFilter.dumpKernelStartIdx); + EXPECT_EQ(static_cast(-1), subCaptureManager->subCaptureFilter.dumpKernelEndIdx); + EXPECT_STREQ("", subCaptureManager->subCaptureFilter.dumpKernelName.c_str()); +} + +TEST(AubCenter, GivenAubCenterInSubCaptureModeWhenItIsCreatedWithDebugFilterSettingsThenItInitializesSubCaptureFiltersWithDebugFilterSettings) { + DebugManagerStateRestore restorer; + DebugManager.flags.AUBDumpSubCaptureMode.set(static_cast(AubSubCaptureManager::SubCaptureMode::Filter)); + DebugManager.flags.AUBDumpFilterKernelStartIdx.set(10); + DebugManager.flags.AUBDumpFilterKernelEndIdx.set(100); + DebugManager.flags.AUBDumpFilterKernelName.set("kernel_name"); + + MockAubCenter aubCenter(platformDevices[0], false, "", CommandStreamReceiverType::CSR_AUB); + auto subCaptureManager = aubCenter.getSubCaptureManager(); + EXPECT_NE(nullptr, subCaptureManager); + + EXPECT_EQ(static_cast(DebugManager.flags.AUBDumpFilterKernelStartIdx.get()), subCaptureManager->subCaptureFilter.dumpKernelStartIdx); + EXPECT_EQ(static_cast(DebugManager.flags.AUBDumpFilterKernelEndIdx.get()), subCaptureManager->subCaptureFilter.dumpKernelEndIdx); + EXPECT_STREQ(DebugManager.flags.AUBDumpFilterKernelName.get().c_str(), subCaptureManager->subCaptureFilter.dumpKernelName.c_str()); +} diff --git a/unit_tests/aub_stream_mocks/aub_stream_interface_mock.cpp b/unit_tests/aub_stream_mocks/aub_stream_interface_mock.cpp index ecc7e1c392..2fda9e5c72 100644 --- a/unit_tests/aub_stream_mocks/aub_stream_interface_mock.cpp +++ b/unit_tests/aub_stream_mocks/aub_stream_interface_mock.cpp @@ -8,7 +8,7 @@ #include "unit_tests/mocks/mock_aub_manager.h" namespace OCLRT { -aub_stream::AubManager *createAubManager(uint32_t productFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, const std::string &aubFileName, uint32_t streamMode) { - return new MockAubManager(productFamily, devicesCount, memoryBankSize, localMemorySupported, aubFileName, streamMode); +aub_stream::AubManager *createAubManager(uint32_t productFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, uint32_t streamMode) { + return new MockAubManager(productFamily, devicesCount, memoryBankSize, localMemorySupported, streamMode); } } // namespace OCLRT diff --git a/unit_tests/aub_tests/command_stream/aub_command_stream_fixture.h b/unit_tests/aub_tests/command_stream/aub_command_stream_fixture.h index 0d371b4cbb..ef7d4d6b29 100644 --- a/unit_tests/aub_tests/command_stream/aub_command_stream_fixture.h +++ b/unit_tests/aub_tests/command_stream/aub_command_stream_fixture.h @@ -39,20 +39,6 @@ class AUBCommandStreamFixture : public CommandStreamFixture { template void expectMMIO(uint32_t mmioRegister, uint32_t expectedValue) { - using AubMemDump::CmdServicesMemTraceRegisterCompare; - CmdServicesMemTraceRegisterCompare header; - memset(&header, 0, sizeof(header)); - header.setHeader(); - - header.data[0] = expectedValue; - header.registerOffset = mmioRegister; - header.noReadExpect = CmdServicesMemTraceRegisterCompare::NoReadExpectValues::ReadExpect; - header.registerSize = CmdServicesMemTraceRegisterCompare::RegisterSizeValues::Dword; - header.registerSpace = CmdServicesMemTraceRegisterCompare::RegisterSpaceValues::Mmio; - header.readMaskLow = 0xffffffff; - header.readMaskHigh = 0xffffffff; - header.dwordCount = (sizeof(header) / sizeof(uint32_t)) - 1; - CommandStreamReceiver *csr = pCommandStreamReceiver; if (testMode == TestMode::AubTestsWithTbx) { csr = reinterpret_cast> *>(pCommandStreamReceiver)->aubCSR.get(); @@ -61,7 +47,7 @@ class AUBCommandStreamFixture : public CommandStreamFixture { if (csr) { // Write our pseudo-op to the AUB file auto aubCsr = reinterpret_cast *>(csr); - aubCsr->getAubStream()->fileHandle.write(reinterpret_cast(&header), sizeof(header)); + aubCsr->expectMMIO(mmioRegister, expectedValue); } } diff --git a/unit_tests/command_stream/aub_command_stream_receiver_1_tests.cpp b/unit_tests/command_stream/aub_command_stream_receiver_1_tests.cpp index 4fc6691aae..ef26005d97 100644 --- a/unit_tests/command_stream/aub_command_stream_receiver_1_tests.cpp +++ b/unit_tests/command_stream/aub_command_stream_receiver_1_tests.cpp @@ -172,7 +172,18 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenMultipl EXPECT_EQ(addressMapper1, addressMapper2); } -HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWithAubManagerWhenItIsCreatedThenFileIsNotCreated) { +HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenMultipleInstancesAreCreatedThenTheyUseTheSameSubCaptureManager) { + ExecutionEnvironment executionEnvironment; + auto aubCsr1 = std::make_unique>(**platformDevices, "", true, executionEnvironment); + auto subCaptureManager1 = executionEnvironment.aubCenter->getSubCaptureManager(); + EXPECT_NE(nullptr, subCaptureManager1); + auto aubCsr2 = std::make_unique>(**platformDevices, "", true, executionEnvironment); + auto subCaptureManager2 = executionEnvironment.aubCenter->getSubCaptureManager(); + EXPECT_NE(nullptr, subCaptureManager2); + EXPECT_EQ(subCaptureManager1, subCaptureManager2); +} + +HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWithAubManagerWhenItIsCreatedThenFileIsCreated) { HardwareInfo hwInfo = *platformDevices[0]; std::string fileName = "file_name.aub"; MockAubManager *mockManager = new MockAubManager(); @@ -184,7 +195,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWithAubMana std::unique_ptr> aubCsr(reinterpret_cast *>(AUBCommandStreamReceiver::create(hwInfo, fileName, true, executionEnvironment))); ASSERT_NE(nullptr, aubCsr); - EXPECT_FALSE(aubCsr->isFileOpen()); + EXPECT_TRUE(aubCsr->isFileOpen()); } HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrWhenOsContextIsSetThenCreateHardwareContext) { @@ -236,27 +247,6 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur EXPECT_FALSE(aubCsr->isFileOpen()); } -HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrInSubCaptureModeWhenItIsCreatedWithoutDebugFilterSettingsThenItInitializesSubCaptureFiltersWithDefaults) { - DebugManagerStateRestore stateRestore; - DebugManager.flags.AUBDumpSubCaptureMode.set(static_cast(AubSubCaptureManager::SubCaptureMode::Filter)); - std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", true, *pDevice->executionEnvironment)); - EXPECT_EQ(0u, aubCsr->subCaptureManager->subCaptureFilter.dumpKernelStartIdx); - EXPECT_EQ(static_cast(-1), aubCsr->subCaptureManager->subCaptureFilter.dumpKernelEndIdx); - EXPECT_STREQ("", aubCsr->subCaptureManager->subCaptureFilter.dumpKernelName.c_str()); -} - -HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrInSubCaptureModeWhenItIsCreatedWithDebugFilterSettingsThenItInitializesSubCaptureFiltersWithDebugFilterSettings) { - DebugManagerStateRestore stateRestore; - DebugManager.flags.AUBDumpSubCaptureMode.set(static_cast(AubSubCaptureManager::SubCaptureMode::Filter)); - DebugManager.flags.AUBDumpFilterKernelStartIdx.set(10); - DebugManager.flags.AUBDumpFilterKernelEndIdx.set(100); - DebugManager.flags.AUBDumpFilterKernelName.set("kernel_name"); - std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", true, *pDevice->executionEnvironment)); - EXPECT_EQ(static_cast(DebugManager.flags.AUBDumpFilterKernelStartIdx.get()), aubCsr->subCaptureManager->subCaptureFilter.dumpKernelStartIdx); - EXPECT_EQ(static_cast(DebugManager.flags.AUBDumpFilterKernelEndIdx.get()), aubCsr->subCaptureManager->subCaptureFilter.dumpKernelEndIdx); - EXPECT_STREQ(DebugManager.flags.AUBDumpFilterKernelName.get().c_str(), aubCsr->subCaptureManager->subCaptureFilter.dumpKernelName.c_str()); -} - HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationWhenMakeResidentCalledMultipleTimesAffectsResidencyOnce) { std::unique_ptr memoryManager(nullptr); std::unique_ptr> aubCsr(new AUBCommandStreamReceiverHw(*platformDevices[0], "", true, *pDevice->executionEnvironment)); @@ -336,10 +326,10 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur auto aubExecutionEnvironment = getEnvironment>(true, true, true); auto aubCsr = aubExecutionEnvironment->template getCsr>(); - auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto aubSubCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); aubSubCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; aubSubCaptureManagerMock->disableSubCapture(); - aubCsr->subCaptureManager.reset(aubSubCaptureManagerMock); + aubCsr->subCaptureManager = aubSubCaptureManagerMock.get(); ASSERT_FALSE(aubCsr->subCaptureManager->isSubCaptureEnabled()); MockGraphicsAllocation allocation(reinterpret_cast(0x1000), 0x1000); @@ -357,11 +347,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur const DispatchInfo dispatchInfo; MultiDispatchInfo multiDispatchInfo; multiDispatchInfo.push(dispatchInfo); - auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto aubSubCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); aubSubCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; aubSubCaptureManagerMock->setSubCaptureToggleActive(true); aubSubCaptureManagerMock->activateSubCapture(multiDispatchInfo); - aubCsr->subCaptureManager.reset(aubSubCaptureManagerMock); + aubCsr->subCaptureManager = aubSubCaptureManagerMock.get(); ASSERT_TRUE(aubCsr->subCaptureManager->isSubCaptureEnabled()); MockGraphicsAllocation allocation(reinterpret_cast(0x1000), 0); @@ -376,10 +366,10 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur auto aubCsr = aubExecutionEnvironment->template getCsr>(); LinearStream cs(aubExecutionEnvironment->commandBuffer); - auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto aubSubCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); aubSubCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; aubSubCaptureManagerMock->disableSubCapture(); - aubCsr->subCaptureManager.reset(aubSubCaptureManagerMock); + aubCsr->subCaptureManager = aubSubCaptureManagerMock.get(); ASSERT_FALSE(aubCsr->subCaptureManager->isSubCaptureEnabled()); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs}; @@ -458,10 +448,10 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInStandalon auto aubCsr = aubExecutionEnvironment->template getCsr>(); LinearStream cs(aubExecutionEnvironment->commandBuffer); - auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto aubSubCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); aubSubCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; aubSubCaptureManagerMock->disableSubCapture(); - aubCsr->subCaptureManager.reset(aubSubCaptureManagerMock); + aubCsr->subCaptureManager = aubSubCaptureManagerMock.get(); ASSERT_FALSE(aubCsr->subCaptureManager->isSubCaptureEnabled()); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs}; @@ -483,10 +473,10 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInNonStanda auto aubCsr = aubExecutionEnvironment->template getCsr>(); LinearStream cs(aubExecutionEnvironment->commandBuffer); - auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto aubSubCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); aubSubCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; aubSubCaptureManagerMock->disableSubCapture(); - aubCsr->subCaptureManager.reset(aubSubCaptureManagerMock); + aubCsr->subCaptureManager = aubSubCaptureManagerMock.get(); ASSERT_FALSE(aubCsr->subCaptureManager->isSubCaptureEnabled()); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs}; @@ -513,11 +503,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur const DispatchInfo dispatchInfo; MultiDispatchInfo multiDispatchInfo; multiDispatchInfo.push(dispatchInfo); - auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto aubSubCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); aubSubCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; aubSubCaptureManagerMock->setSubCaptureToggleActive(true); aubSubCaptureManagerMock->activateSubCapture(multiDispatchInfo); - aubCsr->subCaptureManager.reset(aubSubCaptureManagerMock); + aubCsr->subCaptureManager = aubSubCaptureManagerMock.get(); ASSERT_TRUE(aubCsr->subCaptureManager->isSubCaptureEnabled()); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs}; @@ -637,11 +627,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInStandalon const DispatchInfo dispatchInfo; MultiDispatchInfo multiDispatchInfo; multiDispatchInfo.push(dispatchInfo); - auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto aubSubCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); aubSubCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; aubSubCaptureManagerMock->setSubCaptureToggleActive(true); aubSubCaptureManagerMock->activateSubCapture(multiDispatchInfo); - aubCsr->subCaptureManager.reset(aubSubCaptureManagerMock); + aubCsr->subCaptureManager = aubSubCaptureManagerMock.get(); ASSERT_TRUE(aubCsr->subCaptureManager->isSubCaptureEnabled()); auto gfxAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}); @@ -887,11 +877,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", false, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(true); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; @@ -908,11 +898,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", false, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(true); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; @@ -933,12 +923,12 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", false, *pDevice->executionEnvironment)); std::string newFileName = "new_file_name.aub"; - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(true); subCaptureManagerMock->setExternalFileName(newFileName); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; @@ -961,12 +951,12 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", false, *pDevice->executionEnvironment)); std::string newFileName = "new_file_name.aub"; - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(true); subCaptureManagerMock->setExternalFileName(newFileName); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; @@ -990,11 +980,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsrToTestDumpAubNonWritable(*platformDevices[0], "", false, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(true); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; @@ -1009,11 +999,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsrToTestDumpAubNonWritable(*platformDevices[0], "", false, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(true); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; @@ -1029,11 +1019,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", false, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(false); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); const DispatchInfo dispatchInfo; MultiDispatchInfo multiDispatchInfo; @@ -1047,11 +1037,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", false, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(true); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; @@ -1065,11 +1055,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInStandalon DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", true, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(false); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; @@ -1084,11 +1074,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInStandalon DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", true, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(true); subCaptureManagerMock->setSubCaptureToggleActive(true); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; @@ -1103,11 +1093,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInStandalon DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", true, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(false); subCaptureManagerMock->setSubCaptureToggleActive(true); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; diff --git a/unit_tests/command_stream/aub_command_stream_receiver_2_tests.cpp b/unit_tests/command_stream/aub_command_stream_receiver_2_tests.cpp index d19e1167d7..1c83baa80a 100644 --- a/unit_tests/command_stream/aub_command_stream_receiver_2_tests.cpp +++ b/unit_tests/command_stream/aub_command_stream_receiver_2_tests.cpp @@ -33,11 +33,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInStandalon DebugManagerStateRestore stateRestore; std::unique_ptr> aubCsr(new MockAubCsr(*platformDevices[0], "", true, *pDevice->executionEnvironment)); - auto subCaptureManagerMock = new AubSubCaptureManagerMock(""); + auto subCaptureManagerMock = std::unique_ptr(new AubSubCaptureManagerMock("")); subCaptureManagerMock->subCaptureMode = AubSubCaptureManager::SubCaptureMode::Toggle; subCaptureManagerMock->setSubCaptureIsActive(true); subCaptureManagerMock->setSubCaptureToggleActive(false); - aubCsr->subCaptureManager.reset(subCaptureManagerMock); + aubCsr->subCaptureManager = subCaptureManagerMock.get(); MockKernelWithInternals kernelInternals(*pDevice); Kernel *kernel = kernelInternals.mockKernel; diff --git a/unit_tests/command_stream/aub_file_stream_tests.cpp b/unit_tests/command_stream/aub_file_stream_tests.cpp index b0a1004b7e..da192847bc 100644 --- a/unit_tests/command_stream/aub_file_stream_tests.cpp +++ b/unit_tests/command_stream/aub_file_stream_tests.cpp @@ -65,19 +65,75 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenReopenFileIsCalled EXPECT_STREQ(newFileName.c_str(), aubCsr->getFileName().c_str()); } -HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenInitFileIsCalledThenFileShouldBeInitializedWithHeaderOnce) { +HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithoutAubManagerWhenInitFileIsCalledThenFileShouldBeInitializedWithHeaderOnce) { auto mockAubFileStream = std::make_unique(); auto aubCsr = std::make_unique>(**platformDevices, "", true, *pDevice->executionEnvironment); std::string fileName = "file_name.aub"; - + aubCsr->aubManager = nullptr; aubCsr->stream = mockAubFileStream.get(); aubCsr->initFile(fileName); aubCsr->initFile(fileName); + EXPECT_EQ(1u, mockAubFileStream->openCalledCnt); EXPECT_EQ(1u, mockAubFileStream->initCalledCnt); } +HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithAubManagerWhenInitFileIsCalledThenFileShouldBeInitializedOnce) { + auto mockAubManager = std::make_unique(); + auto aubCsr = std::make_unique>(**platformDevices, "", true, *pDevice->executionEnvironment); + std::string fileName = "file_name.aub"; + aubCsr->aubManager = mockAubManager.get(); + + aubCsr->initFile(fileName); + aubCsr->initFile(fileName); + + EXPECT_EQ(1u, mockAubManager->openCalledCnt); +} + +HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithoutAubManagerWhenFileFunctionsAreCalledThenTheyShouldCallTheExpectedAubManagerFunctions) { + auto mockAubFileStream = std::make_unique(); + auto aubCsr = std::make_unique>(**platformDevices, "", true, *pDevice->executionEnvironment); + std::string fileName = "file_name.aub"; + aubCsr->aubManager = nullptr; + aubCsr->stream = mockAubFileStream.get(); + + aubCsr->initFile(fileName); + EXPECT_EQ(1u, mockAubFileStream->initCalledCnt); + + EXPECT_TRUE(aubCsr->isFileOpen()); + EXPECT_TRUE(mockAubFileStream->isOpenCalled); + + EXPECT_STREQ(fileName.c_str(), aubCsr->getFileName().c_str()); + EXPECT_TRUE(mockAubFileStream->getFileNameCalled); + + aubCsr->closeFile(); + EXPECT_FALSE(aubCsr->isFileOpen()); + EXPECT_TRUE(aubCsr->getFileName().empty()); + EXPECT_TRUE(mockAubFileStream->closeCalled); +} + +HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithAubManagerWhenFileFunctionsAreCalledThenTheyShouldCallTheExpectedAubManagerFunctions) { + auto mockAubManager = std::make_unique(); + auto aubCsr = std::make_unique>(**platformDevices, "", true, *pDevice->executionEnvironment); + std::string fileName = "file_name.aub"; + aubCsr->aubManager = mockAubManager.get(); + + aubCsr->initFile(fileName); + EXPECT_EQ(1u, mockAubManager->openCalledCnt); + + EXPECT_TRUE(aubCsr->isFileOpen()); + EXPECT_TRUE(mockAubManager->isOpenCalled); + + EXPECT_STREQ(fileName.c_str(), aubCsr->getFileName().c_str()); + EXPECT_TRUE(mockAubManager->getFileNameCalled); + + aubCsr->closeFile(); + EXPECT_FALSE(aubCsr->isFileOpen()); + EXPECT_TRUE(aubCsr->getFileName().empty()); + EXPECT_TRUE(mockAubManager->closeCalled); +} + HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenOpenFileIsCalledThenFileStreamShouldBeLocked) { auto mockAubFileStream = std::make_unique(); auto aubCsr = std::make_unique>(**platformDevices, "", true, *pDevice->executionEnvironment); @@ -437,31 +493,37 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenExpectMemoryIsCall EXPECT_EQ(MemoryConstants::pageSize, mockAubFileStream->sizeCapturedFromExpectMemory); } -HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenExpectMMIOIsCalledThenHeaderIsWrittenToFile) { +HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithoutAubManagerWhenExpectMMIOIsCalledThenTheCorrectFunctionIsCalledFromAubFileStream) { std::string fileName = "file_name.aub"; auto mockAubFileStream = std::make_unique(); auto aubCsr = std::make_unique>(**platformDevices, fileName.c_str(), true, *pDevice->executionEnvironment); - aubCsr->setupContext(pDevice->executionEnvironment->commandStreamReceivers[0][0]->getOsContext()); - - std::remove(fileName.c_str()); + aubCsr->aubManager = nullptr; aubCsr->stream = mockAubFileStream.get(); + aubCsr->setupContext(pDevice->executionEnvironment->commandStreamReceivers[0][0]->getOsContext()); aubCsr->initFile(fileName); aubCsr->expectMMIO(5, 10); - aubCsr->getAubStream()->fileHandle.flush(); + EXPECT_EQ(5u, mockAubFileStream->mmioRegisterFromExpectMMIO); + EXPECT_EQ(10u, mockAubFileStream->expectedValueFromExpectMMIO); +} - std::ifstream aubFile(fileName); - EXPECT_TRUE(aubFile.is_open()); +HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithAubManagerWhenExpectMMIOIsCalledThenNoFunctionIsCalledFromAubFileStream) { + std::string fileName = "file_name.aub"; + auto mockAubManager = std::make_unique(); + auto mockAubFileStream = std::make_unique(); + auto aubCsr = std::make_unique>(**platformDevices, fileName.c_str(), true, *pDevice->executionEnvironment); - if (aubFile.is_open()) { - AubMemDump::CmdServicesMemTraceRegisterCompare header; - aubFile.read(reinterpret_cast(&header), sizeof(AubMemDump::CmdServicesMemTraceRegisterCompare)); - EXPECT_EQ(5u, header.registerOffset); - EXPECT_EQ(10u, header.data[0]); - aubFile.close(); - } + aubCsr->aubManager = mockAubManager.get(); + aubCsr->stream = mockAubFileStream.get(); + aubCsr->setupContext(pDevice->executionEnvironment->commandStreamReceivers[0][0]->getOsContext()); + aubCsr->initFile(fileName); + + aubCsr->expectMMIO(5, 10); + + EXPECT_NE(5u, mockAubFileStream->mmioRegisterFromExpectMMIO); + EXPECT_NE(10u, mockAubFileStream->expectedValueFromExpectMMIO); } HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenInitializeEngineIsCalledThenMemTraceCommentWithDriverVersionIsPutIntoAubStream) { diff --git a/unit_tests/mocks/mock_aub_csr.h b/unit_tests/mocks/mock_aub_csr.h index 8f0c6cb919..c31eb6cd98 100644 --- a/unit_tests/mocks/mock_aub_csr.h +++ b/unit_tests/mocks/mock_aub_csr.h @@ -131,7 +131,7 @@ struct MockAubCsr : public AUBCommandStreamReceiverHw { bool isFileOpen() const override { return fileIsOpen; } - const std::string &getFileName() override { + const std::string getFileName() override { return openFileName; } bool fileIsOpen = false; diff --git a/unit_tests/mocks/mock_aub_file_stream.h b/unit_tests/mocks/mock_aub_file_stream.h index fb3790a73f..3a5c244986 100644 --- a/unit_tests/mocks/mock_aub_file_stream.h +++ b/unit_tests/mocks/mock_aub_file_stream.h @@ -22,6 +22,22 @@ struct MockAubFileStream : public AUBCommandStreamReceiver::AubFileStream { initCalledCnt++; return true; } + void open(const char *filePath) override { + fileName.assign(filePath); + openCalledCnt++; + } + void close() override { + fileName.clear(); + closeCalled = true; + } + bool isOpen() const override { + isOpenCalled = true; + return !fileName.empty(); + } + const std::string &getFileName() const override { + getFileNameCalled = true; + return fileName; + } void flush() override { flushCalled = true; } @@ -29,6 +45,10 @@ struct MockAubFileStream : public AUBCommandStreamReceiver::AubFileStream { lockStreamCalled = true; return AUBCommandStreamReceiver::AubFileStream::lockStream(); } + void expectMMIO(uint32_t mmioRegister, uint32_t expectedValue) { + mmioRegisterFromExpectMMIO = mmioRegister; + expectedValueFromExpectMMIO = expectedValue; + } void expectMemory(uint64_t physAddress, const void *memory, size_t size, uint32_t addressSpace, uint32_t compareOperation) override { physAddressCapturedFromExpectMemory = physAddress; memoryCapturedFromExpectMemory = reinterpret_cast(memory); @@ -40,10 +60,17 @@ struct MockAubFileStream : public AUBCommandStreamReceiver::AubFileStream { registerPollCalled = true; AUBCommandStreamReceiver::AubFileStream::registerPoll(registerOffset, mask, value, pollNotEqual, timeoutAction); } + uint32_t openCalledCnt = 0; + std::string fileName = ""; + bool closeCalled = false; uint32_t initCalledCnt = 0; + mutable bool isOpenCalled = false; + mutable bool getFileNameCalled = false; bool registerPollCalled = false; bool flushCalled = false; bool lockStreamCalled = false; + uint32_t mmioRegisterFromExpectMMIO = 0; + uint32_t expectedValueFromExpectMMIO = 0; uint64_t physAddressCapturedFromExpectMemory = 0; uintptr_t memoryCapturedFromExpectMemory = 0; size_t sizeCapturedFromExpectMemory = 0; diff --git a/unit_tests/mocks/mock_aub_manager.h b/unit_tests/mocks/mock_aub_manager.h index e9dc3818e3..cf59e6969a 100644 --- a/unit_tests/mocks/mock_aub_manager.h +++ b/unit_tests/mocks/mock_aub_manager.h @@ -40,12 +40,11 @@ class MockAubManager : public aub_stream::AubManager { public: MockAubManager(){}; - MockAubManager(uint32_t productFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, const std::string &aubFileName, uint32_t streamMode) { + MockAubManager(uint32_t productFamily, uint32_t devicesCount, uint64_t memoryBankSize, bool localMemorySupported, uint32_t streamMode) { mockAubManagerParams.productFamily = productFamily; mockAubManagerParams.devicesCount = devicesCount; mockAubManagerParams.memoryBankSize = memoryBankSize; mockAubManagerParams.localMemorySupported = localMemorySupported; - mockAubManagerParams.aubFileName.assign(aubFileName); mockAubManagerParams.streamMode = streamMode; } ~MockAubManager() override {} @@ -55,8 +54,33 @@ class MockAubManager : public aub_stream::AubManager { contextFlags = flags; return new MockHardwareContext(device, engine); } - void writeMemory(uint64_t gfxAddress, const void *memory, size_t size, uint32_t memoryBanks, int hint, size_t pageSize = 65536) override { writeMemoryCalled = true; } + void open(const std::string &aubFileName) override { + fileName.assign(aubFileName); + openCalledCnt++; + } + void close() override { + fileName.clear(); + closeCalled = true; + } + bool isOpen() override { + isOpenCalled = true; + return !fileName.empty(); + } + const std::string getFileName() override { + getFileNameCalled = true; + return fileName; + } + + void writeMemory(uint64_t gfxAddress, const void *memory, size_t size, uint32_t memoryBanks, int hint, size_t pageSize = 65536) override { + writeMemoryCalled = true; + } + + uint32_t openCalledCnt = 0; + std::string fileName = ""; + bool closeCalled = false; + bool isOpenCalled = false; + bool getFileNameCalled = false; bool writeMemoryCalled = false; uint32_t contextFlags = 0; @@ -65,7 +89,6 @@ class MockAubManager : public aub_stream::AubManager { int32_t devicesCount = 0; uint64_t memoryBankSize = 0; bool localMemorySupported = false; - std::string aubFileName = ""; uint32_t streamMode = 0xFFFFFFFF; } mockAubManagerParams;