Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Enable AUB sub-capture in AubStream captures (1/n) 

Change-Id: I6bd0605d06cf4dc3937e2dbeba7ed7037ae91476
This commit is contained in:
Milczarek, Slawomir 2019-02-19 22:50:52 +01:00 committed by sys_ocldev
parent 56972935ad
commit 278bb83c56
18 changed files with 292 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
runtime/aub/aub_center.cpp
View File

@ -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<AddressMapper>();
streamProvider = std::make_unique<AubFileStreamProvider>();
subCaptureManager = std::make_unique<AubSubCaptureManager>(aubFileName);
if (DebugManager.flags.AUBDumpSubCaptureMode.get()) {
this->subCaptureManager->subCaptureMode = static_cast<AubSubCaptureManager::SubCaptureMode>(DebugManager.flags.AUBDumpSubCaptureMode.get());
this->subCaptureManager->subCaptureFilter.dumpKernelStartIdx = static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterKernelStartIdx.get());
this->subCaptureManager->subCaptureFilter.dumpKernelEndIdx = static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterKernelEndIdx.get());
this->subCaptureManager->subCaptureFilter.dumpNamedKernelStartIdx = static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterNamedKernelStartIdx.get());
this->subCaptureManager->subCaptureFilter.dumpNamedKernelEndIdx = static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterNamedKernelEndIdx.get());
if (DebugManager.flags.AUBDumpFilterKernelName.get() != "unk") {
this->subCaptureManager->subCaptureFilter.dumpKernelName = DebugManager.flags.AUBDumpFilterKernelName.get();
}
}
}
AubCenter::AubCenter() {
addressMapper = std::make_unique<AddressMapper>();
streamProvider = std::make_unique<AubFileStreamProvider>();
subCaptureManager = std::make_unique<AubSubCaptureManager>("");
}
uint32_t AubCenter::getAubStreamMode(const std::string &aubFileName, uint32_t csrType) {

6
runtime/aub/aub_center.h
View File

@ -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> addressMapper;
std::unique_ptr<AubStreamProvider> streamProvider;
std::unique_ptr<AubSubCaptureManager> subCaptureManager;
std::unique_ptr<aub_stream::AubManager> aubManager;
uint32_t aubStreamMode = 0;
};

4
runtime/aub/aub_stream_interface.cpp
View File

@ -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

5
runtime/aub_mem_dump/aub_mem_dump.h
View File

@ -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);

2
runtime/aub_mem_dump/aub_stream_stubs.cpp
View File

@ -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;
}

18
runtime/command_stream/aub_command_stream_receiver.cpp
View File

@ -181,6 +181,24 @@ void AubFileStream::registerPoll(uint32_t registerOffset, uint32_t mask, uint32_
write(reinterpret_cast<char *>(&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<char *>(&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;

4
runtime/command_stream/aub_command_stream_receiver_hw.h
View File

@ -81,7 +81,7 @@ class AUBCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw<GfxFa
MOCKABLE_VIRTUAL void initFile(const std::string &fileName);
MOCKABLE_VIRTUAL void closeFile();
MOCKABLE_VIRTUAL bool isFileOpen() const;
MOCKABLE_VIRTUAL const std::string &getFileName();
MOCKABLE_VIRTUAL const std::string getFileName();
MOCKABLE_VIRTUAL void initializeEngine();
void freeEngineInfoTable();
@ -90,7 +90,7 @@ class AUBCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw<GfxFa
return new OsAgnosticMemoryManager(enable64kbPages, enableLocalMemory, true, this->executionEnvironment);
}
std::unique_ptr<AubSubCaptureManager> subCaptureManager;
AubSubCaptureManager *subCaptureManager = nullptr;
uint32_t aubDeviceId;
bool standalone;

51
runtime/command_stream/aub_command_stream_receiver_hw.inl
View File

@ -37,13 +37,13 @@ namespace OCLRT {
template <typename GfxFamily>
AUBCommandStreamReceiverHw<GfxFamily>::AUBCommandStreamReceiverHw(const HardwareInfo &hwInfoIn, const std::string &fileName, bool standalone, ExecutionEnvironment &executionEnvironment)
: BaseClass(hwInfoIn, executionEnvironment),
subCaptureManager(std::make_unique<AubSubCaptureManager>(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<GfxFamily>::AUBCommandStreamReceiverHw(const Hardware
this->dispatchMode = (DispatchMode)DebugManager.flags.CsrDispatchMode.get();
}
if (DebugManager.flags.AUBDumpSubCaptureMode.get()) {
this->subCaptureManager->subCaptureMode = static_cast<AubSubCaptureManager::SubCaptureMode>(DebugManager.flags.AUBDumpSubCaptureMode.get());
this->subCaptureManager->subCaptureFilter.dumpKernelStartIdx = static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterKernelStartIdx.get());
this->subCaptureManager->subCaptureFilter.dumpKernelEndIdx = static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterKernelEndIdx.get());
this->subCaptureManager->subCaptureFilter.dumpNamedKernelStartIdx = static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterNamedKernelStartIdx.get());
this->subCaptureManager->subCaptureFilter.dumpNamedKernelEndIdx = static_cast<uint32_t>(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<GfxFamily>::openFile(const std::string &fileName
template <typename GfxFamily>
bool AUBCommandStreamReceiverHw<GfxFamily>::reopenFile(const std::string &fileName) {
auto streamLocked = getAubStream()->lockStream();
if (isFileOpen()) {
if (fileName != getFileName()) {
closeFile();
@ -118,6 +109,14 @@ bool AUBCommandStreamReceiverHw<GfxFamily>::reopenFile(const std::string &fileNa
template <typename GfxFamily>
void AUBCommandStreamReceiverHw<GfxFamily>::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<GfxFamily>::initFile(const std::string &fileName
template <typename GfxFamily>
void AUBCommandStreamReceiverHw<GfxFamily>::closeFile() {
stream->close();
aubManager ? aubManager->close() : stream->close();
}
template <typename GfxFamily>
bool AUBCommandStreamReceiverHw<GfxFamily>::isFileOpen() const {
return getAubStream()->isOpen();
return aubManager ? aubManager->isOpen() : getAubStream()->isOpen();
}
template <typename GfxFamily>
const std::string &AUBCommandStreamReceiverHw<GfxFamily>::getFileName() {
return getAubStream()->getFileName();
const std::string AUBCommandStreamReceiverHw<GfxFamily>::getFileName() {
return aubManager ? aubManager->getFileName() : getAubStream()->getFileName();
}
template <typename GfxFamily>
@ -290,7 +289,7 @@ template <typename GfxFamily>
CommandStreamReceiver *AUBCommandStreamReceiverHw<GfxFamily>::create(const HardwareInfo &hwInfoIn, const std::string &fileName, bool standalone, ExecutionEnvironment &executionEnvironment) {
auto csr = new AUBCommandStreamReceiverHw<GfxFamily>(hwInfoIn, fileName, standalone, executionEnvironment);
if (!csr->aubManager && !csr->subCaptureManager->isSubCaptureMode()) {
if (!csr->subCaptureManager->isSubCaptureMode()) {
csr->openFile(fileName);
}
@ -664,21 +663,11 @@ bool AUBCommandStreamReceiverHw<GfxFamily>::writeMemory(AllocationView &allocati
template <typename GfxFamily>
void AUBCommandStreamReceiverHw<GfxFamily>::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<char *>(&header), sizeof(header));
if (hardwareContextController) {
//Add support for expectMMIO to AubStream
return;
}
this->getAubStream()->expectMMIO(mmioRegister, expectedValue);
}
template <typename GfxFamily>

9
third_party/aub_stream/headers/aub_manager.h vendored
View File

@ -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

32
unit_tests/aub/aub_center_tests.cpp
View File

@ -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>(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<int32_t>(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<uint32_t>(-1), subCaptureManager->subCaptureFilter.dumpKernelEndIdx);
EXPECT_STREQ("", subCaptureManager->subCaptureFilter.dumpKernelName.c_str());
}
TEST(AubCenter, GivenAubCenterInSubCaptureModeWhenItIsCreatedWithDebugFilterSettingsThenItInitializesSubCaptureFiltersWithDebugFilterSettings) {
DebugManagerStateRestore restorer;
DebugManager.flags.AUBDumpSubCaptureMode.set(static_cast<int32_t>(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<uint32_t>(DebugManager.flags.AUBDumpFilterKernelStartIdx.get()), subCaptureManager->subCaptureFilter.dumpKernelStartIdx);
EXPECT_EQ(static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterKernelEndIdx.get()), subCaptureManager->subCaptureFilter.dumpKernelEndIdx);
EXPECT_STREQ(DebugManager.flags.AUBDumpFilterKernelName.get().c_str(), subCaptureManager->subCaptureFilter.dumpKernelName.c_str());
}

4
unit_tests/aub_stream_mocks/aub_stream_interface_mock.cpp
View File

@ -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

16
unit_tests/aub_tests/command_stream/aub_command_stream_fixture.h
View File

@ -39,20 +39,6 @@ class AUBCommandStreamFixture : public CommandStreamFixture {
template <typename FamilyType>
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<CommandStreamReceiverWithAUBDump<TbxCommandStreamReceiverHw<FamilyType>> *>(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<AUBCommandStreamReceiverHw<FamilyType> *>(csr);
aubCsr->getAubStream()->fileHandle.write(reinterpret_cast<char *>(&header), sizeof(header));
aubCsr->expectMMIO(mmioRegister, expectedValue);
}
}

108
unit_tests/command_stream/aub_command_stream_receiver_1_tests.cpp
View File

@ -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<AUBCommandStreamReceiverHw<FamilyType>>(**platformDevices, "", true, executionEnvironment);
auto subCaptureManager1 = executionEnvironment.aubCenter->getSubCaptureManager();
EXPECT_NE(nullptr, subCaptureManager1);
auto aubCsr2 = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>(**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<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(reinterpret_cast<AUBCommandStreamReceiverHw<FamilyType> *>(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<int32_t>(AubSubCaptureManager::SubCaptureMode::Filter));
std::unique_ptr<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
EXPECT_EQ(0u, aubCsr->subCaptureManager->subCaptureFilter.dumpKernelStartIdx);
EXPECT_EQ(static_cast<uint32_t>(-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<int32_t>(AubSubCaptureManager::SubCaptureMode::Filter));
DebugManager.flags.AUBDumpFilterKernelStartIdx.set(10);
DebugManager.flags.AUBDumpFilterKernelEndIdx.set(100);
DebugManager.flags.AUBDumpFilterKernelName.set("kernel_name");
std::unique_ptr<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
EXPECT_EQ(static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterKernelStartIdx.get()), aubCsr->subCaptureManager->subCaptureFilter.dumpKernelStartIdx);
EXPECT_EQ(static_cast<uint32_t>(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> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
@ -336,10 +326,10 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur
auto aubExecutionEnvironment = getEnvironment<MockAubCsr<FamilyType>>(true, true, true);
auto aubCsr = aubExecutionEnvironment->template getCsr<MockAubCsr<FamilyType>>();
auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock("");
auto aubSubCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<void *>(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<AubSubCaptureManagerMock>(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<void *>(0x1000), 0);
@ -376,10 +366,10 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur
auto aubCsr = aubExecutionEnvironment->template getCsr<AUBCommandStreamReceiverHw<FamilyType>>();
LinearStream cs(aubExecutionEnvironment->commandBuffer);
auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock("");
auto aubSubCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>>();
LinearStream cs(aubExecutionEnvironment->commandBuffer);
auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock("");
auto aubSubCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>>();
LinearStream cs(aubExecutionEnvironment->commandBuffer);
auto aubSubCaptureManagerMock = new AubSubCaptureManagerMock("");
auto aubSubCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<AubSubCaptureManagerMock>(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<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", false, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", false, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", false, *pDevice->executionEnvironment));
std::string newFileName = "new_file_name.aub";
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", false, *pDevice->executionEnvironment));
std::string newFileName = "new_file_name.aub";
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsrToTestDumpAubNonWritable<FamilyType>> aubCsr(new MockAubCsrToTestDumpAubNonWritable<FamilyType>(*platformDevices[0], "", false, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsrToTestDumpAubNonWritable<FamilyType>> aubCsr(new MockAubCsrToTestDumpAubNonWritable<FamilyType>(*platformDevices[0], "", false, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", false, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", false, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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;

4
unit_tests/command_stream/aub_command_stream_receiver_2_tests.cpp
View File

@ -33,11 +33,11 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInStandalon
DebugManagerStateRestore stateRestore;
std::unique_ptr<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
auto subCaptureManagerMock = new AubSubCaptureManagerMock("");
auto subCaptureManagerMock = std::unique_ptr<AubSubCaptureManagerMock>(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;

94
unit_tests/command_stream/aub_file_stream_tests.cpp
View File

@ -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<MockAubFileStream>();
auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>(**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<MockAubManager>();
auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>(**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<MockAubFileStream>();
auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>(**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<MockAubManager>();
auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>(**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<MockAubFileStream>();
auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>(**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<MockAubFileStream>();
auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>(**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<MockAubManager>();
auto mockAubFileStream = std::make_unique<MockAubFileStream>();
auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>(**platformDevices, fileName.c_str(), true, *pDevice->executionEnvironment);
if (aubFile.is_open()) {
AubMemDump::CmdServicesMemTraceRegisterCompare header;
aubFile.read(reinterpret_cast<char *>(&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) {

2
unit_tests/mocks/mock_aub_csr.h
View File

@ -131,7 +131,7 @@ struct MockAubCsr : public AUBCommandStreamReceiverHw<GfxFamily> {
bool isFileOpen() const override {
return fileIsOpen;
}
const std::string &getFileName() override {
const std::string getFileName() override {
return openFileName;
}
bool fileIsOpen = false;

27
unit_tests/mocks/mock_aub_file_stream.h
View File

@ -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<uintptr_t>(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;

31
unit_tests/mocks/mock_aub_manager.h
View File

@ -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;