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

Make platformImpl a vector

Browse Source 
Related-To: NEO-4207
Change-Id: I85fa2d5a44160e1cf98321f9835a5173e59e479c
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2020-02-03 16:18:21 +01:00
committed by sys_ocldev
parent 3aec3d41c2
commit e77ed5f4fa
59 changed files with 143 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/unit_tests/preemption/preemption_tests.cpp
View File

@@ -505,7 +505,7 @@ HWTEST_P(PreemptionTest, whenFailToCreatePreemptionAllocationThenFailToCreateDev
} }
}; };
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
std::unique_ptr<MockDevice> mockDevice(MockDevice::create<MockDeviceReturnedDebuggerActive>(executionEnvironment, 0)); std::unique_ptr<MockDevice> mockDevice(MockDevice::create<MockDeviceReturnedDebuggerActive>(executionEnvironment, 0));
EXPECT_EQ(nullptr, mockDevice); EXPECT_EQ(nullptr, mockDevice);
@@ -547,7 +547,7 @@ HWTEST_F(MidThreadPreemptionTests, givenMidThreadPreemptionWhenFailingOnCsrSurfa
uint32_t allocateGraphicsMemoryCount = 0; uint32_t allocateGraphicsMemoryCount = 0;
}; };
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->memoryManager = std::make_unique<FailingMemoryManager>(*executionEnvironment); executionEnvironment->memoryManager = std::make_unique<FailingMemoryManager>(*executionEnvironment);
std::unique_ptr<MockDevice> mockDevice(MockDevice::create<MockDevice>(executionEnvironment, 0)); std::unique_ptr<MockDevice> mockDevice(MockDevice::create<MockDevice>(executionEnvironment, 0));

15
runtime/platform/platform.cpp
View File

@@ -35,19 +35,24 @@
namespace NEO { namespace NEO {
std::unique_ptr<Platform> platformImpl; std::vector<std::unique_ptr<Platform>> platformsImpl;
bool getDevices(size_t &numDevicesReturned, ExecutionEnvironment &executionEnvironment); bool getDevices(size_t &numDevicesReturned, ExecutionEnvironment &executionEnvironment);
Platform *platform() { return platformImpl.get(); } Platform *platform() {
if (platformsImpl.empty()) {
return nullptr;
}
return platformsImpl[0].get();
}
Platform *constructPlatform() { Platform *constructPlatform() {
static std::mutex mutex; static std::mutex mutex;
std::unique_lock<std::mutex> lock(mutex); std::unique_lock<std::mutex> lock(mutex);
if (!platformImpl) { if (platformsImpl.empty()) {
platformImpl.reset(new Platform()); platformsImpl.push_back(std::make_unique<Platform>());
} }
return platformImpl.get(); return platformsImpl[0].get();
} }
Platform::Platform() { Platform::Platform() {

2
runtime/platform/platform.h
View File

@@ -78,7 +78,7 @@ class Platform : public BaseObject<_cl_platform_id> {
ExecutionEnvironment *executionEnvironment = nullptr; ExecutionEnvironment *executionEnvironment = nullptr;
}; };
extern std::unique_ptr<Platform> platformImpl; extern std::vector<std::unique_ptr<Platform>> platformsImpl;
Platform *platform(); Platform *platform();
Platform *constructPlatform(); Platform *constructPlatform();
} // namespace NEO } // namespace NEO

2
unit_tests/api/cl_create_command_queue_with_properties_tests.cpp
View File

@@ -53,7 +53,7 @@ struct clCreateCommandQueueWithPropertiesApi : public ApiFixture,
} }
void SetUp() override { void SetUp() override {
platformImpl.reset(); platformsImpl.clear();
MemoryManagementFixture::SetUp(); MemoryManagementFixture::SetUp();
ApiFixture::SetUp(); ApiFixture::SetUp();
} }

2
unit_tests/api/cl_get_platform_ids_tests.inl
View File

@@ -61,6 +61,6 @@ TEST(clGetPlatformIDsNegativeTests, GivenFailedInitializationWhenGettingPlatform
EXPECT_EQ(0u, numPlatforms); EXPECT_EQ(0u, numPlatforms);
EXPECT_EQ(nullptr, platformRet); EXPECT_EQ(nullptr, platformRet);
platformImpl.reset(nullptr); platformsImpl.clear();
} }
} // namespace ULT } // namespace ULT

2
unit_tests/aub_tests/fixtures/aub_fixture.h
View File

@@ -35,7 +35,7 @@ class AUBFixture : public CommandQueueHwFixture {
std::stringstream strfilename; std::stringstream strfilename;
strfilename << testInfo->test_case_name() << "_" << testInfo->name() << "_" << hwHelper.getCsTraits(engineType).name; strfilename << testInfo->test_case_name() << "_" << testInfo->name() << "_" << hwHelper.getCsTraits(engineType).name;
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->setHwInfo(&hwInfo); executionEnvironment->setHwInfo(&hwInfo);
if (testMode == TestMode::AubTestsWithTbx) { if (testMode == TestMode::AubTestsWithTbx) {
this->csr = TbxCommandStreamReceiver::create(strfilename.str(), true, *executionEnvironment, 0); this->csr = TbxCommandStreamReceiver::create(strfilename.str(), true, *executionEnvironment, 0);

4
unit_tests/aub_tests/fixtures/unified_memory_fixture.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2019 Intel Corporation * Copyright (C) 2019-2020 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -22,7 +22,7 @@ class UnifiedMemoryAubFixture : public AUBFixture {
void SetUp() override { void SetUp() override {
AUBFixture::SetUp(nullptr); AUBFixture::SetUp(nullptr);
if (!platformImpl->peekExecutionEnvironment()->memoryManager->getPageFaultManager()) { if (!platform()->peekExecutionEnvironment()->memoryManager->getPageFaultManager()) {
skipped = true; skipped = true;
GTEST_SKIP(); GTEST_SKIP();
} }

2
unit_tests/command_queue/command_queue_tests.cpp
View File

@@ -51,7 +51,7 @@ struct CommandQueueMemoryDevice
void TearDown() override { void TearDown() override {
DeviceFixture::TearDown(); DeviceFixture::TearDown();
platformImpl.reset(); platformsImpl.clear();
MemoryManagementFixture::TearDown(); MemoryManagementFixture::TearDown();
} }
}; };

2
unit_tests/command_queue/enqueue_handler_tests.cpp
View File

@@ -525,7 +525,7 @@ HWTEST_F(EnqueueHandlerTest, givenEnqueueHandlerWhenClSetKernelExecInfoAlreadyse
struct EnqueueHandlerTestBasic : public ::testing::Test { struct EnqueueHandlerTestBasic : public ::testing::Test {
template <typename FamilyType> template <typename FamilyType>
std::unique_ptr<MockCommandQueueHw<FamilyType>> setupFixtureAndCreateMockCommandQueue() { std::unique_ptr<MockCommandQueueHw<FamilyType>> setupFixtureAndCreateMockCommandQueue() {
auto executionEnvironment = platformImpl->peekExecutionEnvironment(); auto executionEnvironment = platform()->peekExecutionEnvironment();
device = std::make_unique<MockClDevice>(MockDevice::createWithExecutionEnvironment<MockDevice>(nullptr, executionEnvironment, 0u)); device = std::make_unique<MockClDevice>(MockDevice::createWithExecutionEnvironment<MockDevice>(nullptr, executionEnvironment, 0u));
context = std::make_unique<MockContext>(device.get()); context = std::make_unique<MockContext>(device.get());

8
unit_tests/command_queue/enqueue_svm_tests.cpp
View File

@@ -38,7 +38,7 @@ struct EnqueueSvmTest : public DeviceFixture,
} }
void SetUp() override { void SetUp() override {
if (platformImpl->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm == false) { if (platform()->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm == false) {
GTEST_SKIP(); GTEST_SKIP();
} }
DeviceFixture::SetUp(); DeviceFixture::SetUp();
@@ -47,7 +47,7 @@ struct EnqueueSvmTest : public DeviceFixture,
} }
void TearDown() override { void TearDown() override {
if (platformImpl->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm == false) { if (platform()->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm == false) {
return; return;
} }
context->getSVMAllocsManager()->freeSVMAlloc(ptrSVM); context->getSVMAllocsManager()->freeSVMAlloc(ptrSVM);
@@ -893,7 +893,7 @@ TEST(CreateSvmAllocTests, givenVariousSvmAllocationPropertiesWhenAllocatingSvmTh
struct EnqueueSvmTestLocalMemory : public DeviceFixture, struct EnqueueSvmTestLocalMemory : public DeviceFixture,
public ::testing::Test { public ::testing::Test {
void SetUp() override { void SetUp() override {
if (platformImpl->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm == false) { if (platform()->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm == false) {
GTEST_SKIP(); GTEST_SKIP();
} }
dbgRestore = std::make_unique<DebugManagerStateRestore>(); dbgRestore = std::make_unique<DebugManagerStateRestore>();
@@ -908,7 +908,7 @@ struct EnqueueSvmTestLocalMemory : public DeviceFixture,
} }
void TearDown() override { void TearDown() override {
if (platformImpl->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm == false) { if (platform()->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm == false) {
return; return;
} }
context->getSVMAllocsManager()->freeSVMAlloc(svmPtr); context->getSVMAllocsManager()->freeSVMAlloc(svmPtr);

4
unit_tests/command_stream/aub_command_stream_receiver_2_tests.cpp
View File

@@ -453,7 +453,7 @@ class OsAgnosticMemoryManagerForImagesWithNoHostPtr : public OsAgnosticMemoryMan
using AubCommandStreamReceiverNoHostPtrTests = ::testing::Test; using AubCommandStreamReceiverNoHostPtrTests = ::testing::Test;
HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWhenWriteMemoryIsCalledOnImageWithNoHostPtrThenResourceShouldBeLockedToGetCpuAddress) { HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWhenWriteMemoryIsCalledOnImageWithNoHostPtrThenResourceShouldBeLockedToGetCpuAddress) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto memoryManager = new OsAgnosticMemoryManagerForImagesWithNoHostPtr(*executionEnvironment); auto memoryManager = new OsAgnosticMemoryManagerForImagesWithNoHostPtr(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);
auto engineInstance = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0]; auto engineInstance = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0];
@@ -486,7 +486,7 @@ HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWh
} }
HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWhenWriteMemoryIsCalledOnLockedResourceThenResourceShouldNotBeUnlocked) { HWTEST_F(AubCommandStreamReceiverNoHostPtrTests, givenAubCommandStreamReceiverWhenWriteMemoryIsCalledOnLockedResourceThenResourceShouldNotBeUnlocked) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto memoryManager = new OsAgnosticMemoryManagerForImagesWithNoHostPtr(*executionEnvironment); auto memoryManager = new OsAgnosticMemoryManagerForImagesWithNoHostPtr(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);

2
unit_tests/command_stream/command_stream_receiver_flush_task_3_tests.cpp
View File

@@ -669,7 +669,7 @@ struct MockedMemoryManager : public OsAgnosticMemoryManager {
HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenTotalResourceUsedExhaustsTheBudgetThenDoImplicitFlush) { HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenTotalResourceUsedExhaustsTheBudgetThenDoImplicitFlush) {
CommandQueueHw<FamilyType> commandQueue(nullptr, pClDevice, 0); CommandQueueHw<FamilyType> commandQueue(nullptr, pClDevice, 0);
auto &commandStream = commandQueue.getCS(4096u); auto &commandStream = commandQueue.getCS(4096u);
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto mockedMemoryManager = new MockedMemoryManager(*executionEnvironment); auto mockedMemoryManager = new MockedMemoryManager(*executionEnvironment);
executionEnvironment->memoryManager.reset(mockedMemoryManager); executionEnvironment->memoryManager.reset(mockedMemoryManager);
auto mockCsr = std::make_unique<MockCsrHw2<FamilyType>>(*executionEnvironment, 0); auto mockCsr = std::make_unique<MockCsrHw2<FamilyType>>(*executionEnvironment, 0);

4
unit_tests/command_stream/command_stream_receiver_tests.cpp
View File

@@ -404,7 +404,7 @@ TEST(CommandStreamReceiverSimpleTest, givenVariousDataSetsWhenVerifyingMemoryThe
} }
TEST(CommandStreamReceiverMultiContextTests, givenMultipleCsrsWhenSameResourcesAreUsedThenResidencyIsProperlyHandled) { TEST(CommandStreamReceiverMultiContextTests, givenMultipleCsrsWhenSameResourcesAreUsedThenResidencyIsProperlyHandled) {
auto executionEnvironment = platformImpl->peekExecutionEnvironment(); auto executionEnvironment = platform()->peekExecutionEnvironment();
std::unique_ptr<MockDevice> device(Device::create<MockDevice>(executionEnvironment, 0u)); std::unique_ptr<MockDevice> device(Device::create<MockDevice>(executionEnvironment, 0u));
@@ -441,7 +441,7 @@ TEST(CommandStreamReceiverMultiContextTests, givenMultipleCsrsWhenSameResourcesA
struct CreateAllocationForHostSurfaceTest : public ::testing::Test { struct CreateAllocationForHostSurfaceTest : public ::testing::Test {
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->setHwInfo(&hwInfo); executionEnvironment->setHwInfo(&hwInfo);
gmockMemoryManager = new ::testing::NiceMock<GMockMemoryManager>(*executionEnvironment); gmockMemoryManager = new ::testing::NiceMock<GMockMemoryManager>(*executionEnvironment);
executionEnvironment->memoryManager.reset(gmockMemoryManager); executionEnvironment->memoryManager.reset(gmockMemoryManager);

16
unit_tests/command_stream/command_stream_receiver_with_aub_dump_tests.cpp
View File

@@ -113,7 +113,7 @@ struct MyMockCsrWithAubDump : CommandStreamReceiverWithAUBDump<BaseCSR> {
struct CommandStreamReceiverWithAubDumpTest : public ::testing::TestWithParam<bool /*createAubCSR*/>, MockAubCenterFixture { struct CommandStreamReceiverWithAubDumpTest : public ::testing::TestWithParam<bool /*createAubCSR*/>, MockAubCenterFixture {
void SetUp() override { void SetUp() override {
MockAubCenterFixture::SetUp(); MockAubCenterFixture::SetUp();
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
memoryManager = executionEnvironment->memoryManager.get(); memoryManager = executionEnvironment->memoryManager.get();
ASSERT_NE(nullptr, memoryManager); ASSERT_NE(nullptr, memoryManager);
@@ -141,7 +141,7 @@ struct CommandStreamReceiverWithAubDumpTest : public ::testing::TestWithParam<bo
using CommandStreamReceiverWithAubDumpSimpleTest = Test<MockAubCenterFixture>; using CommandStreamReceiverWithAubDumpSimpleTest = Test<MockAubCenterFixture>;
HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenCsrWithAubDumpWhenSettingOsContextThenReplicateItToAubCsr) { HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenCsrWithAubDumpWhenSettingOsContextThenReplicateItToAubCsr) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
CommandStreamReceiverWithAUBDump<UltCommandStreamReceiver<FamilyType>> csrWithAubDump("aubfile", *executionEnvironment, 0); CommandStreamReceiverWithAUBDump<UltCommandStreamReceiver<FamilyType>> csrWithAubDump("aubfile", *executionEnvironment, 0);
@@ -154,7 +154,7 @@ HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenCsrWithAubDumpWhenSett
} }
HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenAubManagerAvailableWhenTbxCsrWithAubDumpIsCreatedThenAubCsrIsNotCreated) { HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenAubManagerAvailableWhenTbxCsrWithAubDumpIsCreatedThenAubCsrIsNotCreated) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
std::string fileName = "file_name.aub"; std::string fileName = "file_name.aub";
MockAubManager *mockManager = new MockAubManager(); MockAubManager *mockManager = new MockAubManager();
@@ -173,7 +173,7 @@ HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenAubManagerAvailableWhe
MockAubCenter *mockAubCenter = new MockAubCenter(*platformDevices, false, fileName, CommandStreamReceiverType::CSR_HW_WITH_AUB); MockAubCenter *mockAubCenter = new MockAubCenter(*platformDevices, false, fileName, CommandStreamReceiverType::CSR_HW_WITH_AUB);
mockAubCenter->aubManager = std::unique_ptr<MockAubManager>(mockManager); mockAubCenter->aubManager = std::unique_ptr<MockAubManager>(mockManager);
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter); executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter);
@@ -186,7 +186,7 @@ HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenCsrWithAubDumpWhenWait
MockAubCenter *mockAubCenter = new MockAubCenter(*platformDevices, false, "file_name.aub", CommandStreamReceiverType::CSR_HW_WITH_AUB); MockAubCenter *mockAubCenter = new MockAubCenter(*platformDevices, false, "file_name.aub", CommandStreamReceiverType::CSR_HW_WITH_AUB);
mockAubCenter->aubManager = std::unique_ptr<MockAubManager>(new MockAubManager()); mockAubCenter->aubManager = std::unique_ptr<MockAubManager>(new MockAubManager());
auto executionEnvironment = platformImpl->peekExecutionEnvironment(); auto executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter); executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter);
@@ -209,7 +209,7 @@ HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenCsrWithAubDumpWhenCrea
MockAubCenter *mockAubCenter = new MockAubCenter(*platformDevices, false, "file_name.aub", CommandStreamReceiverType::CSR_HW_WITH_AUB); MockAubCenter *mockAubCenter = new MockAubCenter(*platformDevices, false, "file_name.aub", CommandStreamReceiverType::CSR_HW_WITH_AUB);
mockAubCenter->aubManager = std::unique_ptr<MockAubManager>(new MockAubManager()); mockAubCenter->aubManager = std::unique_ptr<MockAubManager>(new MockAubManager());
auto executionEnvironment = platformImpl->peekExecutionEnvironment(); auto executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter); executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter);
@@ -252,7 +252,7 @@ struct CommandStreamReceiverTagTests : public ::testing::Test {
MockAubCenter *mockAubCenter = new MockAubCenter(*platformDevices, false, fileName, CommandStreamReceiverType::CSR_HW_WITH_AUB); MockAubCenter *mockAubCenter = new MockAubCenter(*platformDevices, false, fileName, CommandStreamReceiverType::CSR_HW_WITH_AUB);
mockAubCenter->aubManager = std::unique_ptr<MockAubManager>(mockManager); mockAubCenter->aubManager = std::unique_ptr<MockAubManager>(mockManager);
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter); executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter);
} }
@@ -311,7 +311,7 @@ HWTEST_F(SimulatedCsrTest, givenTbxWithAubDumpCsrTypeWhenCreateCommandStreamRece
HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenNullAubManagerAvailableWhenTbxCsrWithAubDumpIsCreatedThenAubCsrIsCreated) { HWTEST_F(CommandStreamReceiverWithAubDumpSimpleTest, givenNullAubManagerAvailableWhenTbxCsrWithAubDumpIsCreatedThenAubCsrIsCreated) {
MockAubCenter *mockAubCenter = new MockAubCenter(); MockAubCenter *mockAubCenter = new MockAubCenter();
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter); executionEnvironment->rootDeviceEnvironments[0]->aubCenter = std::unique_ptr<MockAubCenter>(mockAubCenter);

6
unit_tests/command_stream/get_devices_tests.cpp
View File

@@ -62,7 +62,7 @@ HWTEST_F(GetDevicesTest, givenGetDevicesWhenCsrIsSetToVariousTypesThenTheFunctio
} }
DebugManager.flags.ProductFamilyOverride.set(productFamily); DebugManager.flags.ProductFamilyOverride.set(productFamily);
ExecutionEnvironment *exeEnv = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *exeEnv = platform()->peekExecutionEnvironment();
const auto ret = getDevices(numDevices, *exeEnv); const auto ret = getDevices(numDevices, *exeEnv);
hwInfo = exeEnv->getHardwareInfo(); hwInfo = exeEnv->getHardwareInfo();
@@ -133,7 +133,7 @@ HWTEST_F(GetDevicesTest, givenUpperCaseProductFamilyOverrideFlagSetWhenCreatingD
DebugManager.flags.ProductFamilyOverride.set(hwPrefixUpperCase); DebugManager.flags.ProductFamilyOverride.set(hwPrefixUpperCase);
DebugManager.flags.SetCommandStreamReceiver.set(CommandStreamReceiverType::CSR_AUB); DebugManager.flags.SetCommandStreamReceiver.set(CommandStreamReceiverType::CSR_AUB);
ExecutionEnvironment *exeEnv = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *exeEnv = platform()->peekExecutionEnvironment();
bool ret = getDevices(numDevices, *exeEnv); bool ret = getDevices(numDevices, *exeEnv);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@@ -151,7 +151,7 @@ HWTEST_F(GetDevicesTest, givenGetDevicesAndUnknownProductFamilyWhenCsrIsSetToVal
DebugManager.flags.SetCommandStreamReceiver.set(csrType); DebugManager.flags.SetCommandStreamReceiver.set(csrType);
DebugManager.flags.ProductFamilyOverride.set(productFamily); DebugManager.flags.ProductFamilyOverride.set(productFamily);
ExecutionEnvironment *exeEnv = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *exeEnv = platform()->peekExecutionEnvironment();
auto ret = getDevices(numDevices, *exeEnv); auto ret = getDevices(numDevices, *exeEnv);
hwInfo = exeEnv->getHardwareInfo(); hwInfo = exeEnv->getHardwareInfo();

6
unit_tests/command_stream/tbx_command_stream_tests.cpp
View File

@@ -137,7 +137,7 @@ HWTEST_F(TbxCommandStreamTests, DISABLED_getCsTraits) {
} }
TEST(TbxCommandStreamReceiverTest, givenNullFactoryEntryWhenTbxCsrIsCreatedThenNullptrIsReturned) { TEST(TbxCommandStreamReceiverTest, givenNullFactoryEntryWhenTbxCsrIsCreatedThenNullptrIsReturned) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
GFXCORE_FAMILY family = executionEnvironment->getHardwareInfo()->platform.eRenderCoreFamily; GFXCORE_FAMILY family = executionEnvironment->getHardwareInfo()->platform.eRenderCoreFamily;
VariableBackup<TbxCommandStreamReceiverCreateFunc> tbxCsrFactoryBackup(&tbxCommandStreamReceiverFactory[family]); VariableBackup<TbxCommandStreamReceiverCreateFunc> tbxCsrFactoryBackup(&tbxCommandStreamReceiverFactory[family]);
@@ -148,7 +148,7 @@ TEST(TbxCommandStreamReceiverTest, givenNullFactoryEntryWhenTbxCsrIsCreatedThenN
} }
TEST(TbxCommandStreamReceiverTest, givenTbxCommandStreamReceiverWhenItIsCreatedWithWrongGfxCoreFamilyThenNullPointerShouldBeReturned) { TEST(TbxCommandStreamReceiverTest, givenTbxCommandStreamReceiverWhenItIsCreatedWithWrongGfxCoreFamilyThenNullPointerShouldBeReturned) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto hwInfo = executionEnvironment->getMutableHardwareInfo(); auto hwInfo = executionEnvironment->getMutableHardwareInfo();
hwInfo->platform.eRenderCoreFamily = GFXCORE_FAMILY_FORCE_ULONG; // wrong gfx core family hwInfo->platform.eRenderCoreFamily = GFXCORE_FAMILY_FORCE_ULONG; // wrong gfx core family
@@ -158,7 +158,7 @@ TEST(TbxCommandStreamReceiverTest, givenTbxCommandStreamReceiverWhenItIsCreatedW
} }
TEST(TbxCommandStreamReceiverTest, givenTbxCommandStreamReceiverWhenTypeIsCheckedThenTbxCsrIsReturned) { TEST(TbxCommandStreamReceiverTest, givenTbxCommandStreamReceiverWhenTypeIsCheckedThenTbxCsrIsReturned) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
std::unique_ptr<CommandStreamReceiver> csr(TbxCommandStreamReceiver::create("", false, *executionEnvironment, 0)); std::unique_ptr<CommandStreamReceiver> csr(TbxCommandStreamReceiver::create("", false, *executionEnvironment, 0));
EXPECT_NE(nullptr, csr); EXPECT_NE(nullptr, csr);

2
unit_tests/context/context_tests.cpp
View File

@@ -301,7 +301,7 @@ TEST_F(ContextTest, givenContextWhenSharingTableIsNotEmptyThenReturnsSharingFunc
} }
TEST(Context, givenFtrSvmFalseWhenContextIsCreatedThenSVMAllocsManagerIsNotCreated) { TEST(Context, givenFtrSvmFalseWhenContextIsCreatedThenSVMAllocsManagerIsNotCreated) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto hwInfo = executionEnvironment->getMutableHardwareInfo(); auto hwInfo = executionEnvironment->getMutableHardwareInfo();
hwInfo->capabilityTable.ftrSvm = false; hwInfo->capabilityTable.ftrSvm = false;

8
unit_tests/device/device_tests.cpp
View File

@@ -195,7 +195,7 @@ TEST(DeviceCreation, givenDeviceWhenItIsCreatedThenOsContextIsRegistredInMemoryM
} }
TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachOsContextHasUniqueId) { TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachOsContextHasUniqueId) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
const size_t numDevices = 2; const size_t numDevices = 2;
executionEnvironment->prepareRootDeviceEnvironments(numDevices); executionEnvironment->prepareRootDeviceEnvironments(numDevices);
const auto &numGpgpuEngines = static_cast<uint32_t>(HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size()); const auto &numGpgpuEngines = static_cast<uint32_t>(HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size());
@@ -221,7 +221,7 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachOsContextHasU
} }
TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSeperateDeviceIndex) { TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSeperateDeviceIndex) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
const size_t numDevices = 2; const size_t numDevices = 2;
executionEnvironment->prepareRootDeviceEnvironments(numDevices); executionEnvironment->prepareRootDeviceEnvironments(numDevices);
auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u)); auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
@@ -232,7 +232,7 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSepe
} }
TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSeperateCommandStreamReceiver) { TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSeperateCommandStreamReceiver) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
const size_t numDevices = 2; const size_t numDevices = 2;
executionEnvironment->prepareRootDeviceEnvironments(numDevices); executionEnvironment->prepareRootDeviceEnvironments(numDevices);
const auto &numGpgpuEngines = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size(); const auto &numGpgpuEngines = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size();
@@ -248,7 +248,7 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSepe
} }
TEST(DeviceCreation, givenDeviceWhenAskingForDefaultEngineThenReturnValidValue) { TEST(DeviceCreation, givenDeviceWhenAskingForDefaultEngineThenReturnValidValue) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0)); auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0));
auto osContext = device->getDefaultEngine().osContext; auto osContext = device->getDefaultEngine().osContext;

2
unit_tests/event/event_tests.cpp
View File

@@ -391,7 +391,7 @@ TEST_F(EventTest, Event_Wait_NonBlocking) {
struct UpdateEventTest : public ::testing::Test { struct UpdateEventTest : public ::testing::Test {
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = new MockMemoryManager(*executionEnvironment); memoryManager = new MockMemoryManager(*executionEnvironment);
hostPtrManager = static_cast<MockHostPtrManager *>(memoryManager->getHostPtrManager()); hostPtrManager = static_cast<MockHostPtrManager *>(memoryManager->getHostPtrManager());
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);

10
unit_tests/execution_environment/execution_environment_tests.cpp
View File

@@ -87,7 +87,7 @@ TEST(ExecutionEnvironment, givenPlatformWhenItIsCreatedThenItCreatesMemoryManage
} }
TEST(ExecutionEnvironment, givenDeviceWhenItIsDestroyedThenMemoryManagerIsStillAvailable) { TEST(ExecutionEnvironment, givenDeviceWhenItIsDestroyedThenMemoryManagerIsStillAvailable) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
std::unique_ptr<Device> device(Device::create<RootDevice>(executionEnvironment, 0u)); std::unique_ptr<Device> device(Device::create<RootDevice>(executionEnvironment, 0u));
device.reset(nullptr); device.reset(nullptr);
@@ -108,7 +108,7 @@ TEST(RootDeviceEnvironment, givenUseAubStreamFalseWhenGetAubManagerIsCalledThenR
DebugManagerStateRestore dbgRestore; DebugManagerStateRestore dbgRestore;
DebugManager.flags.UseAubStream.set(false); DebugManager.flags.UseAubStream.set(false);
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[0].get(); auto rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[0].get();
rootDeviceEnvironment->initAubCenter(false, "", CommandStreamReceiverType::CSR_AUB); rootDeviceEnvironment->initAubCenter(false, "", CommandStreamReceiverType::CSR_AUB);
auto aubManager = rootDeviceEnvironment->aubCenter->getAubManager(); auto aubManager = rootDeviceEnvironment->aubCenter->getAubManager();
@@ -116,7 +116,7 @@ TEST(RootDeviceEnvironment, givenUseAubStreamFalseWhenGetAubManagerIsCalledThenR
} }
TEST(RootDeviceEnvironment, givenExecutionEnvironmentWhenInitializeAubCenterIsCalledThenItIsInitalizedOnce) { TEST(RootDeviceEnvironment, givenExecutionEnvironmentWhenInitializeAubCenterIsCalledThenItIsInitalizedOnce) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[0].get(); auto rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[0].get();
rootDeviceEnvironment->initAubCenter(false, "", CommandStreamReceiverType::CSR_AUB); rootDeviceEnvironment->initAubCenter(false, "", CommandStreamReceiverType::CSR_AUB);
auto currentAubCenter = rootDeviceEnvironment->aubCenter.get(); auto currentAubCenter = rootDeviceEnvironment->aubCenter.get();
@@ -141,7 +141,7 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerI
} }
TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenItIsInitalized) { TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenItIsInitalized) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
EXPECT_NE(nullptr, executionEnvironment->memoryManager); EXPECT_NE(nullptr, executionEnvironment->memoryManager);
} }
@@ -199,7 +199,7 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWithVariousMembersWhenItIsDe
} }
TEST(ExecutionEnvironment, givenMultipleRootDevicesWhenTheyAreCreatedTheyAllReuseTheSameMemoryManager) { TEST(ExecutionEnvironment, givenMultipleRootDevicesWhenTheyAreCreatedTheyAllReuseTheSameMemoryManager) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(2); executionEnvironment->prepareRootDeviceEnvironments(2);
std::unique_ptr<MockDevice> device(Device::create<MockDevice>(executionEnvironment, 0u)); std::unique_ptr<MockDevice> device(Device::create<MockDevice>(executionEnvironment, 0u));
auto &commandStreamReceiver = device->getGpgpuCommandStreamReceiver(); auto &commandStreamReceiver = device->getGpgpuCommandStreamReceiver();

2
unit_tests/fixtures/image_fixture.h
View File

@@ -116,7 +116,7 @@ struct ImageClearColorFixture : ::testing::Test {
void setUpImpl() { void setUpImpl() {
hardwareInfo.capabilityTable.ftrRenderCompressedImages = true; hardwareInfo.capabilityTable.ftrRenderCompressedImages = true;
NEO::platformImpl.reset(); NEO::platformsImpl.clear();
NEO::constructPlatform()->peekExecutionEnvironment()->setHwInfo(&hardwareInfo); NEO::constructPlatform()->peekExecutionEnvironment()->setHwInfo(&hardwareInfo);
NEO::platform()->peekExecutionEnvironment()->prepareRootDeviceEnvironments(1u); NEO::platform()->peekExecutionEnvironment()->prepareRootDeviceEnvironments(1u);
NEO::platform()->peekExecutionEnvironment()->initGmm(); NEO::platform()->peekExecutionEnvironment()->initGmm();

2
unit_tests/fixtures/memory_allocator_fixture.h
View File

@@ -35,7 +35,7 @@ class MemoryAllocatorFixture : public MemoryManagementFixture {
void TearDown() override { void TearDown() override {
device.reset(); device.reset();
platformImpl.reset(); platformsImpl.clear();
MemoryManagementFixture::TearDown(); MemoryManagementFixture::TearDown();
} }

4
unit_tests/fixtures/mock_aub_center_fixture.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2019 Intel Corporation * Copyright (C) 2019-2020 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -20,7 +20,7 @@ struct MockAubCenterFixture {
MockAubCenterFixture(CommandStreamReceiverType commandStreamReceiverType) : commandStreamReceiverType(commandStreamReceiverType){}; MockAubCenterFixture(CommandStreamReceiverType commandStreamReceiverType) : commandStreamReceiverType(commandStreamReceiverType){};
void SetUp() { void SetUp() {
setMockAubCenter(*platformImpl->peekExecutionEnvironment()->rootDeviceEnvironments[0], commandStreamReceiverType); setMockAubCenter(*platform()->peekExecutionEnvironment()->rootDeviceEnvironments[0], commandStreamReceiverType);
} }
void TearDown() { void TearDown() {
} }

2
unit_tests/fixtures/platform_fixture.cpp
View File

@@ -41,7 +41,7 @@ void PlatformFixture::SetUp() {
} }
void PlatformFixture::TearDown() { void PlatformFixture::TearDown() {
platformImpl.reset(nullptr); platformsImpl.clear();
delete[] devices; delete[] devices;
} }
} // namespace NEO } // namespace NEO

2
unit_tests/gen12lp/hw_helper_tests_gen12lp.inl
View File

@@ -112,7 +112,7 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, whenGetGpgpuEnginesThenReturnTwoRcsEnginesAnd
class HwHelperTestsGen12LpBuffer : public ::testing::Test { class HwHelperTestsGen12LpBuffer : public ::testing::Test {
public: public:
void SetUp() override { void SetUp() override {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
device = std::make_unique<MockClDevice>(Device::create<MockDevice>(executionEnvironment, 0u)); device = std::make_unique<MockClDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
context = std::make_unique<MockContext>(device.get(), true); context = std::make_unique<MockContext>(device.get(), true);
context->contextType = ContextType::CONTEXT_TYPE_UNRESTRICTIVE; context->contextType = ContextType::CONTEXT_TYPE_UNRESTRICTIVE;

2
unit_tests/gen12lp/windows/gmm_callbacks_tests_gen12lp.cpp
View File

@@ -44,7 +44,7 @@ GEN12LPTEST_F(Gen12LpGmmCallbacksTests, givenCsrWithoutAubDumpWhenNotifyAubCaptu
GEN12LPTEST_F(Gen12LpGmmCallbacksTests, givenWddmCsrWhenWriteL3CalledThenWriteTwoMmio) { GEN12LPTEST_F(Gen12LpGmmCallbacksTests, givenWddmCsrWhenWriteL3CalledThenWriteTwoMmio) {
typedef typename FamilyType::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM; typedef typename FamilyType::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
UltCommandStreamReceiver<FamilyType> csr(*executionEnvironment, 0); UltCommandStreamReceiver<FamilyType> csr(*executionEnvironment, 0);
uint8_t buffer[128] = {}; uint8_t buffer[128] = {};

4
unit_tests/gen8/coherency_tests_gen8.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2017-2019 Intel Corporation * Copyright (C) 2017-2020 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -16,7 +16,7 @@ using namespace NEO;
typedef ::testing::Test Gen8CoherencyRequirements; typedef ::testing::Test Gen8CoherencyRequirements;
GEN8TEST_F(Gen8CoherencyRequirements, noCoherencyProgramming) { GEN8TEST_F(Gen8CoherencyRequirements, noCoherencyProgramming) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
CommandStreamReceiverHw<BDWFamily> csr(*executionEnvironment, 0); CommandStreamReceiverHw<BDWFamily> csr(*executionEnvironment, 0);
LinearStream stream; LinearStream stream;

4
unit_tests/gen9/coherency_tests_gen9.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2017-2019 Intel Corporation * Copyright (C) 2017-2020 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -16,7 +16,7 @@ using namespace NEO;
typedef ::testing::Test Gen9CoherencyRequirements; typedef ::testing::Test Gen9CoherencyRequirements;
GEN9TEST_F(Gen9CoherencyRequirements, noCoherencyProgramming) { GEN9TEST_F(Gen9CoherencyRequirements, noCoherencyProgramming) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
CommandStreamReceiverHw<SKLFamily> csr(*executionEnvironment, 0); CommandStreamReceiverHw<SKLFamily> csr(*executionEnvironment, 0);
LinearStream stream; LinearStream stream;

4
unit_tests/gmm_helper/gmm_helper_tests.cpp
View File

@@ -39,7 +39,7 @@ extern bool copyInputArgs;
struct GmmTests : public ::testing::Test { struct GmmTests : public ::testing::Test {
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
} }
ExecutionEnvironment *executionEnvironment; ExecutionEnvironment *executionEnvironment;
}; };
@@ -779,7 +779,7 @@ TEST(GmmHelperTest, givenPlatformAlreadyDestroyedWhenResourceIsBeingDestroyedThe
auto executionEnvironment = platform()->peekExecutionEnvironment(); auto executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->incRefInternal(); executionEnvironment->incRefInternal();
platformImpl.reset(); platformsImpl.clear();
EXPECT_EQ(nullptr, platform()); EXPECT_EQ(nullptr, platform());
EXPECT_NO_THROW(delete gmmResourceInfo); EXPECT_NO_THROW(delete gmmResourceInfo);

4
unit_tests/gtpin/gtpin_tests.cpp
View File

@@ -142,7 +142,7 @@ class GTPinFixture : public ContextFixture, public MemoryManagementFixture {
public: public:
void SetUp() override { void SetUp() override {
platformImpl.reset(); platformsImpl.clear();
MemoryManagementFixture::SetUp(); MemoryManagementFixture::SetUp();
constructPlatform(); constructPlatform();
pPlatform = platform(); pPlatform = platform();
@@ -174,7 +174,7 @@ class GTPinFixture : public ContextFixture, public MemoryManagementFixture {
void TearDown() override { void TearDown() override {
ContextFixture::TearDown(); ContextFixture::TearDown();
platformImpl.reset(nullptr); platformsImpl.clear();
MemoryManagementFixture::TearDown(); MemoryManagementFixture::TearDown();
NEO::isGTPinInitialized = false; NEO::isGTPinInitialized = false;
} }

4
unit_tests/helpers/execution_environment_helper.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018-2019 Intel Corporation * Copyright (C) 2018-2020 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -14,7 +14,7 @@
namespace NEO { namespace NEO {
ExecutionEnvironment *getExecutionEnvironmentImpl(HardwareInfo *&hwInfo, uint32_t rootDeviceEnvironments) { ExecutionEnvironment *getExecutionEnvironmentImpl(HardwareInfo *&hwInfo, uint32_t rootDeviceEnvironments) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(rootDeviceEnvironments); executionEnvironment->prepareRootDeviceEnvironments(rootDeviceEnvironments);
DebugManagerStateRestore restorer; DebugManagerStateRestore restorer;
DebugManager.flags.CreateMultipleRootDevices.set(rootDeviceEnvironments); DebugManager.flags.CreateMultipleRootDevices.set(rootDeviceEnvironments);

2
unit_tests/helpers/timestamp_packet_tests.cpp
View File

@@ -48,7 +48,7 @@ struct TimestampPacketSimpleTests : public ::testing::Test {
struct TimestampPacketTests : public TimestampPacketSimpleTests { struct TimestampPacketTests : public TimestampPacketSimpleTests {
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(2); executionEnvironment->prepareRootDeviceEnvironments(2);
device = std::make_unique<MockClDevice>(Device::create<MockDevice>(executionEnvironment, 0u)); device = std::make_unique<MockClDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
context = new MockContext(device.get()); context = new MockContext(device.get());

1
unit_tests/main.cpp
View File

@@ -68,6 +68,7 @@ extern std::string lastTest;
bool generateRandomInput = false; bool generateRandomInput = false;
void applyWorkarounds() { void applyWorkarounds() {
platformsImpl.reserve(1);
{ {
std::ofstream f; std::ofstream f;
const std::string fileName("_tmp_"); const std::string fileName("_tmp_");

10
unit_tests/mem_obj/buffer_tests.cpp
View File

@@ -442,7 +442,7 @@ TEST(Buffer, givenZeroFlagsNoSharedContextAndRenderCompressedBuffersDisabledWhen
} }
TEST(Buffer, givenClMemCopyHostPointerPassedToBufferCreateWhenAllocationIsNotInSystemMemoryPoolThenAllocationIsWrittenByEnqueueWriteBuffer) { TEST(Buffer, givenClMemCopyHostPointerPassedToBufferCreateWhenAllocationIsNotInSystemMemoryPoolThenAllocationIsWrittenByEnqueueWriteBuffer) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto *memoryManager = new ::testing::NiceMock<GMockMemoryManagerFailFirstAllocation>(*executionEnvironment); auto *memoryManager = new ::testing::NiceMock<GMockMemoryManagerFailFirstAllocation>(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);
@@ -468,7 +468,7 @@ TEST(Buffer, givenClMemCopyHostPointerPassedToBufferCreateWhenAllocationIsNotInS
} }
struct RenderCompressedBuffersTests : public ::testing::Test { struct RenderCompressedBuffersTests : public ::testing::Test {
void SetUp() override { void SetUp() override {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
hwInfo = executionEnvironment->getMutableHardwareInfo(); hwInfo = executionEnvironment->getMutableHardwareInfo();
device = std::make_unique<MockClDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0u)); device = std::make_unique<MockClDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0u));
context = std::make_unique<MockContext>(device.get(), true); context = std::make_unique<MockContext>(device.get(), true);
@@ -590,7 +590,7 @@ TEST_F(RenderCompressedBuffersTests, givenDebugVariableSetWhenHwFlagIsNotSetThen
struct RenderCompressedBuffersSvmTests : public RenderCompressedBuffersTests { struct RenderCompressedBuffersSvmTests : public RenderCompressedBuffersTests {
void SetUp() override { void SetUp() override {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
hwInfo = executionEnvironment->getMutableHardwareInfo(); hwInfo = executionEnvironment->getMutableHardwareInfo();
hwInfo->capabilityTable.gpuAddressSpace = MemoryConstants::max48BitAddress; hwInfo->capabilityTable.gpuAddressSpace = MemoryConstants::max48BitAddress;
RenderCompressedBuffersTests::SetUp(); RenderCompressedBuffersTests::SetUp();
@@ -611,7 +611,7 @@ TEST_F(RenderCompressedBuffersSvmTests, givenSvmAllocationWhenCreatingBufferThen
struct RenderCompressedBuffersCopyHostMemoryTests : public RenderCompressedBuffersTests { struct RenderCompressedBuffersCopyHostMemoryTests : public RenderCompressedBuffersTests {
void SetUp() override { void SetUp() override {
RenderCompressedBuffersTests::SetUp(); RenderCompressedBuffersTests::SetUp();
device->injectMemoryManager(new MockMemoryManager(true, false, *platformImpl->peekExecutionEnvironment())); device->injectMemoryManager(new MockMemoryManager(true, false, *platform()->peekExecutionEnvironment()));
context->memoryManager = device->getMemoryManager(); context->memoryManager = device->getMemoryManager();
mockCmdQ = new MockCommandQueue(); mockCmdQ = new MockCommandQueue();
context->setSpecialQueue(mockCmdQ); context->setSpecialQueue(mockCmdQ);
@@ -1484,7 +1484,7 @@ struct ValidHostPtr
void TearDown() override { void TearDown() override {
delete buffer; delete buffer;
BaseClass::TearDown(); BaseClass::TearDown();
platformImpl.reset(); platformsImpl.clear();
MemoryManagementFixture::TearDown(); MemoryManagementFixture::TearDown();
} }

2
unit_tests/mem_obj/destructor_callback_tests.cpp
View File

@@ -26,7 +26,7 @@ class DestructorCallbackFixture : public MemoryManagementFixture {
void TearDown() override { void TearDown() override {
delete BufferDefaults::context; delete BufferDefaults::context;
platformImpl.reset(); platformsImpl.clear();
MemoryManagementFixture::TearDown(); MemoryManagementFixture::TearDown();
} }

4
unit_tests/mem_obj/image_tests.cpp
View File

@@ -525,7 +525,7 @@ struct CreateImageHostPtr
void TearDown() override { void TearDown() override {
delete image; delete image;
BaseClass::TearDown(); BaseClass::TearDown();
platformImpl.reset(); platformsImpl.clear();
MemoryManagementFixture::TearDown(); MemoryManagementFixture::TearDown();
} }
@@ -1175,7 +1175,7 @@ TEST(ImageTest, givenClMemForceLinearStorageSetWhenCreateImageThenDisallowTiling
} }
TEST(ImageTest, givenClMemCopyHostPointerPassedToImageCreateWhenAllocationIsNotInSystemMemoryPoolThenAllocationIsWrittenByEnqueueWriteImage) { TEST(ImageTest, givenClMemCopyHostPointerPassedToImageCreateWhenAllocationIsNotInSystemMemoryPoolThenAllocationIsWrittenByEnqueueWriteImage) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto *memoryManager = new ::testing::NiceMock<GMockMemoryManagerFailFirstAllocation>(*executionEnvironment); auto *memoryManager = new ::testing::NiceMock<GMockMemoryManagerFailFirstAllocation>(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);
EXPECT_CALL(*memoryManager, allocateGraphicsMemoryInDevicePool(::testing::_, ::testing::_)) EXPECT_CALL(*memoryManager, allocateGraphicsMemoryInDevicePool(::testing::_, ::testing::_))

2
unit_tests/mem_obj/mem_obj_destruction_tests.cpp
View File

@@ -31,7 +31,7 @@ void CL_CALLBACK emptyDestructorCallback(cl_mem memObj, void *userData) {
class MemObjDestructionTest : public ::testing::TestWithParam<bool> { class MemObjDestructionTest : public ::testing::TestWithParam<bool> {
public: public:
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = new MockMemoryManager(*executionEnvironment); memoryManager = new MockMemoryManager(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);
device = std::make_unique<MockClDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0)); device = std::make_unique<MockClDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0));

2
unit_tests/mem_obj/mem_obj_tests.cpp
View File

@@ -168,7 +168,7 @@ TEST(MemObj, givenNotReadyGraphicsAllocationWhenMemObjDestroysAllocationAsyncThe
} }
TEST(MemObj, givenReadyGraphicsAllocationWhenMemObjDestroysAllocationAsyncThenAllocationIsNotAddedToMemoryManagerAllocationList) { TEST(MemObj, givenReadyGraphicsAllocationWhenMemObjDestroysAllocationAsyncThenAllocationIsNotAddedToMemoryManagerAllocationList) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto device = std::make_unique<MockClDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0)); auto device = std::make_unique<MockClDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0));
MockContext context(device.get()); MockContext context(device.get());
auto memoryManager = executionEnvironment->memoryManager.get(); auto memoryManager = executionEnvironment->memoryManager.get();

4
unit_tests/memory_manager/deferrable_allocation_deletion_tests.cpp
View File

@@ -37,7 +37,7 @@ struct DeferredDeleterPublic : DeferredDeleter {
struct DeferrableAllocationDeletionTest : ::testing::Test { struct DeferrableAllocationDeletionTest : ::testing::Test {
void SetUp() override { void SetUp() override {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
memoryManager = new MockMemoryManager(*executionEnvironment); memoryManager = new MockMemoryManager(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);
device.reset(Device::create<MockDevice>(executionEnvironment, 0u)); device.reset(Device::create<MockDevice>(executionEnvironment, 0u));
@@ -159,7 +159,7 @@ TEST_F(DeferrableAllocationDeletionTest, givenAllocationUsedByUnregisteredEngine
DeferrableAllocationDeletion deletion{*memoryManager, *allocation}; DeferrableAllocationDeletion deletion{*memoryManager, *allocation};
device.reset(); device.reset();
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->rootDeviceEnvironments.clear(); executionEnvironment->rootDeviceEnvironments.clear();
EXPECT_EQ(0u, memoryManager->registeredEngines.size()); EXPECT_EQ(0u, memoryManager->registeredEngines.size());
EXPECT_TRUE(allocation->isUsed()); EXPECT_TRUE(allocation->isUsed());

22
unit_tests/memory_manager/memory_manager_tests.cpp
View File

@@ -618,7 +618,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAskedFor32BitAllocationWhenL
GTEST_SKIP(); GTEST_SKIP();
} }
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
MockMemoryManager memoryManager(*executionEnvironment); MockMemoryManager memoryManager(*executionEnvironment);
memoryManager.setForce32BitAllocations(true); memoryManager.setForce32BitAllocations(true);
memoryManager.forceLimitedRangeAllocator(0, 0xFFFFFFFFF); memoryManager.forceLimitedRangeAllocator(0, 0xFFFFFFFFF);
@@ -637,7 +637,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAskedForNon32BitAllocationWh
GTEST_SKIP(); GTEST_SKIP();
} }
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
MockMemoryManager memoryManager(*executionEnvironment); MockMemoryManager memoryManager(*executionEnvironment);
memoryManager.forceLimitedRangeAllocator(0, 0xFFFFFFFFF); memoryManager.forceLimitedRangeAllocator(0, 0xFFFFFFFFF);
@@ -651,7 +651,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAskedForNon32BitAllocationWh
} }
TEST(OsAgnosticMemoryManager, givenDefaultMemoryManagerWhenAllocateGraphicsMemoryForImageIsCalledThenGraphicsAllocationIsReturned) { TEST(OsAgnosticMemoryManager, givenDefaultMemoryManagerWhenAllocateGraphicsMemoryForImageIsCalledThenGraphicsAllocationIsReturned) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
MockMemoryManager memoryManager(*executionEnvironment); MockMemoryManager memoryManager(*executionEnvironment);
cl_image_desc imgDesc = {}; cl_image_desc imgDesc = {};
imgDesc.image_width = 512; imgDesc.image_width = 512;
@@ -670,7 +670,7 @@ TEST(OsAgnosticMemoryManager, givenDefaultMemoryManagerWhenAllocateGraphicsMemor
} }
TEST(OsAgnosticMemoryManager, givenEnabledLocalMemoryWhenAllocateGraphicsMemoryForImageIsCalledThenUseLocalMemoryIsNotSet) { TEST(OsAgnosticMemoryManager, givenEnabledLocalMemoryWhenAllocateGraphicsMemoryForImageIsCalledThenUseLocalMemoryIsNotSet) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
MockMemoryManager memoryManager(false, true, *executionEnvironment); MockMemoryManager memoryManager(false, true, *executionEnvironment);
cl_image_desc imgDesc = {}; cl_image_desc imgDesc = {};
imgDesc.image_width = 1; imgDesc.image_width = 1;
@@ -688,7 +688,7 @@ TEST(OsAgnosticMemoryManager, givenEnabledLocalMemoryWhenAllocateGraphicsMemoryF
} }
TEST(OsAgnosticMemoryManager, givenHostPointerNotRequiringCopyWhenAllocateGraphicsMemoryForImageFromHostPtrIsCalledThenGraphicsAllocationIsReturned) { TEST(OsAgnosticMemoryManager, givenHostPointerNotRequiringCopyWhenAllocateGraphicsMemoryForImageFromHostPtrIsCalledThenGraphicsAllocationIsReturned) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
MockMemoryManager memoryManager(false, false, *executionEnvironment); MockMemoryManager memoryManager(false, false, *executionEnvironment);
cl_image_desc imgDesc = {}; cl_image_desc imgDesc = {};
@@ -728,7 +728,7 @@ TEST(OsAgnosticMemoryManager, givenHostPointerNotRequiringCopyWhenAllocateGraphi
} }
TEST(OsAgnosticMemoryManager, givenHostPointerRequiringCopyWhenAllocateGraphicsMemoryForImageFromHostPtrIsCalledThenNullptrIsReturned) { TEST(OsAgnosticMemoryManager, givenHostPointerRequiringCopyWhenAllocateGraphicsMemoryForImageFromHostPtrIsCalledThenNullptrIsReturned) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
MockMemoryManager memoryManager(false, false, *executionEnvironment); MockMemoryManager memoryManager(false, false, *executionEnvironment);
cl_image_desc imgDesc = {}; cl_image_desc imgDesc = {};
@@ -1263,7 +1263,7 @@ TEST(OsAgnosticMemoryManager, givenOsAgnosticMemoryManagerAndFreeMemoryDisabledW
} }
TEST(MemoryManager, givenSharedResourceCopyWhenAllocatingGraphicsMemoryThenAllocateGraphicsMemoryForImageIsCalled) { TEST(MemoryManager, givenSharedResourceCopyWhenAllocatingGraphicsMemoryThenAllocateGraphicsMemoryForImageIsCalled) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
MockMemoryManager memoryManager(false, true, *executionEnvironment); MockMemoryManager memoryManager(false, true, *executionEnvironment);
cl_image_desc imgDesc = {}; cl_image_desc imgDesc = {};
imgDesc.image_width = 1; imgDesc.image_width = 1;
@@ -1282,7 +1282,7 @@ TEST(MemoryManager, givenSharedResourceCopyWhenAllocatingGraphicsMemoryThenAlloc
} }
TEST(MemoryManager, givenShareableWhenAllocatingGraphicsMemoryThenAllocateShareableIsCalled) { TEST(MemoryManager, givenShareableWhenAllocatingGraphicsMemoryThenAllocateShareableIsCalled) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
MockMemoryManager memoryManager(false, true, *executionEnvironment); MockMemoryManager memoryManager(false, true, *executionEnvironment);
MockMemoryManager::AllocationData allocationData; MockMemoryManager::AllocationData allocationData;
@@ -1589,7 +1589,7 @@ HWTEST_F(GraphicsAllocationTests, givenAllocationUsedOnlyByNonDefaultCsrWhenChec
} }
HWTEST_F(GraphicsAllocationTests, givenAllocationUsedOnlyByNonDefaultDeviceWhenCheckingUsageBeforeDestroyThenStoreItAsTemporaryAllocation) { HWTEST_F(GraphicsAllocationTests, givenAllocationUsedOnlyByNonDefaultDeviceWhenCheckingUsageBeforeDestroyThenStoreItAsTemporaryAllocation) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u)); auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
auto &defaultCommandStreamReceiver = device->getGpgpuCommandStreamReceiver(); auto &defaultCommandStreamReceiver = device->getGpgpuCommandStreamReceiver();
auto &nonDefaultCommandStreamReceiver = static_cast<UltCommandStreamReceiver<FamilyType> &>(*device->commandStreamReceivers[1]); auto &nonDefaultCommandStreamReceiver = static_cast<UltCommandStreamReceiver<FamilyType> &>(*device->commandStreamReceivers[1]);
@@ -1611,7 +1611,7 @@ HWTEST_F(GraphicsAllocationTests, givenAllocationUsedOnlyByNonDefaultDeviceWhenC
} }
HWTEST_F(GraphicsAllocationTests, givenAllocationUsedByManyOsContextsWhenCheckingUsageBeforeDestroyThenMultiContextDestructorIsUsedForWaitingForAllOsContexts) { HWTEST_F(GraphicsAllocationTests, givenAllocationUsedByManyOsContextsWhenCheckingUsageBeforeDestroyThenMultiContextDestructorIsUsedForWaitingForAllOsContexts) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto memoryManager = new MockMemoryManager(false, false, *executionEnvironment); auto memoryManager = new MockMemoryManager(false, false, *executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);
auto multiContextDestructor = new MockDeferredDeleter(); auto multiContextDestructor = new MockDeferredDeleter();
@@ -2213,7 +2213,7 @@ HWTEST_F(MemoryAllocatorTest, givenMemoryManagerWhenHostPtrTrackingEnabledThenNo
using PageTableManagerTest = ::testing::Test; using PageTableManagerTest = ::testing::Test;
HWTEST_F(PageTableManagerTest, givenMemoryManagerThatSupportsPageTableManagerWhenMapAuxGpuVAIsCalledThenItReturnsTrue) { HWTEST_F(PageTableManagerTest, givenMemoryManagerThatSupportsPageTableManagerWhenMapAuxGpuVAIsCalledThenItReturnsTrue) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(2); executionEnvironment->prepareRootDeviceEnvironments(2);
auto memoryManager = new MockMemoryManager(false, false, *executionEnvironment); auto memoryManager = new MockMemoryManager(false, false, *executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager); executionEnvironment->memoryManager.reset(memoryManager);

4
unit_tests/memory_manager/surface_tests.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2017-2019 Intel Corporation * Copyright (C) 2017-2020 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -60,7 +60,7 @@ TYPED_TEST_CASE(SurfaceTest, SurfaceTypes);
HWTEST_TYPED_TEST(SurfaceTest, GivenSurfaceWhenInterfaceIsUsedThenSurfaceBehavesCorrectly) { HWTEST_TYPED_TEST(SurfaceTest, GivenSurfaceWhenInterfaceIsUsedThenSurfaceBehavesCorrectly) {
int32_t execStamp; int32_t execStamp;
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->initializeMemoryManager(); executionEnvironment->initializeMemoryManager();
auto csr = std::make_unique<MockCsr<FamilyType>>(execStamp, *executionEnvironment, 0); auto csr = std::make_unique<MockCsr<FamilyType>>(execStamp, *executionEnvironment, 0);
auto engine = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0]; auto engine = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0];

2
unit_tests/memory_manager/unified_memory_manager_tests.cpp
View File

@@ -554,7 +554,7 @@ TEST_F(UnifiedMemoryManagerPropertiesTest, givenDeviceBitfieldWithSingleBitSetWh
struct ShareableUnifiedMemoryManagerPropertiesTest : public ::testing::Test { struct ShareableUnifiedMemoryManagerPropertiesTest : public ::testing::Test {
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
bool svmSupported = executionEnvironment->getHardwareInfo()->capabilityTable.ftrSvm; bool svmSupported = executionEnvironment->getHardwareInfo()->capabilityTable.ftrSvm;
if (!svmSupported) { if (!svmSupported) {
GTEST_SKIP(); GTEST_SKIP();

2
unit_tests/os_interface/device_factory_tests.cpp
View File

@@ -28,7 +28,7 @@ struct DeviceFactoryTest : public ::testing::Test {
public: public:
void SetUp() override { void SetUp() override {
const HardwareInfo *hwInfo = platformDevices[0]; const HardwareInfo *hwInfo = platformDevices[0];
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
mockGdiDll = setAdapterInfo(&hwInfo->platform, &hwInfo->gtSystemInfo, hwInfo->capabilityTable.gpuAddressSpace); mockGdiDll = setAdapterInfo(&hwInfo->platform, &hwInfo->gtSystemInfo, hwInfo->capabilityTable.gpuAddressSpace);
} }

6
unit_tests/os_interface/linux/drm_memory_manager_tests.cpp
View File

@@ -3353,9 +3353,9 @@ TEST(DrmMemoryMangerTest, givenMultipleRootDeviceWhenMemoryManagerGetsDrmThenDrm
ultHwConfig.useMockedGetDevicesFunc = false; ultHwConfig.useMockedGetDevicesFunc = false;
platform()->initialize(); platform()->initialize();
TestedDrmMemoryManager drmMemoryManager(*platformImpl->peekExecutionEnvironment()); TestedDrmMemoryManager drmMemoryManager(*platform()->peekExecutionEnvironment());
for (auto i = 0u; i < platformImpl->peekExecutionEnvironment()->rootDeviceEnvironments.size(); i++) { for (auto i = 0u; i < platform()->peekExecutionEnvironment()->rootDeviceEnvironments.size(); i++) {
auto drmFromRootDevice = platformImpl->peekExecutionEnvironment()->rootDeviceEnvironments[i]->osInterface->get()->getDrm(); auto drmFromRootDevice = platform()->peekExecutionEnvironment()->rootDeviceEnvironments[i]->osInterface->get()->getDrm();
EXPECT_EQ(drmFromRootDevice, &drmMemoryManager.getDrm(i)); EXPECT_EQ(drmFromRootDevice, &drmMemoryManager.getDrm(i));
} }
} }

6
unit_tests/os_interface/windows/device_command_stream_tests.cpp
View File

@@ -143,7 +143,7 @@ using WddmDefaultTest = ::Test<DeviceFixture>;
using DeviceCommandStreamTest = ::Test<MockAubCenterFixture>; using DeviceCommandStreamTest = ::Test<MockAubCenterFixture>;
TEST_F(DeviceCommandStreamTest, CreateWddmCSR) { TEST_F(DeviceCommandStreamTest, CreateWddmCSR) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto wddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()); auto wddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get());
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>(); executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(static_cast<WddmMock *>(wddm)); executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(static_cast<WddmMock *>(wddm));
@@ -155,7 +155,7 @@ TEST_F(DeviceCommandStreamTest, CreateWddmCSR) {
} }
TEST_F(DeviceCommandStreamTest, CreateWddmCSRWithAubDump) { TEST_F(DeviceCommandStreamTest, CreateWddmCSRWithAubDump) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto wddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()); auto wddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get());
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>(); executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(static_cast<WddmMock *>(wddm)); executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(static_cast<WddmMock *>(wddm));
@@ -817,7 +817,7 @@ using WddmSimpleTest = ::testing::Test;
HWTEST_F(WddmSimpleTest, givenDefaultWddmCsrWhenItIsCreatedThenBatchingIsTurnedOn) { HWTEST_F(WddmSimpleTest, givenDefaultWddmCsrWhenItIsCreatedThenBatchingIsTurnedOn) {
DebugManager.flags.CsrDispatchMode.set(0); DebugManager.flags.CsrDispatchMode.set(0);
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
std::unique_ptr<MockDevice> device(Device::create<MockDevice>(executionEnvironment, 0u)); std::unique_ptr<MockDevice> device(Device::create<MockDevice>(executionEnvironment, 0u));
auto wddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()); auto wddm = Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get());
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>(); executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();

2
unit_tests/os_interface/windows/wddm23_tests.cpp
View File

@@ -25,7 +25,7 @@ struct Wddm23TestsWithoutWddmInit : public ::testing::Test, GdiDllFixture {
void SetUp() override { void SetUp() override {
GdiDllFixture::SetUp(); GdiDllFixture::SetUp();
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get())); wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
osInterface = std::make_unique<OSInterface>(); osInterface = std::make_unique<OSInterface>();
osInterface->get()->setWddm(wddm); osInterface->get()->setWddm(wddm);

6
unit_tests/os_interface/windows/wddm_fixture.h
View File

@@ -28,7 +28,7 @@
namespace NEO { namespace NEO {
struct WddmFixture : ::testing::Test { struct WddmFixture : ::testing::Test {
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get())); wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>(); executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(wddm); executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->setWddm(wddm);
@@ -54,7 +54,7 @@ struct WddmFixture : ::testing::Test {
struct WddmFixtureWithMockGdiDll : public GdiDllFixture { struct WddmFixtureWithMockGdiDll : public GdiDllFixture {
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
GdiDllFixture::SetUp(); GdiDllFixture::SetUp();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get())); wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
wddmMockInterface = new WddmMockInterface20(*wddm); wddmMockInterface = new WddmMockInterface20(*wddm);
@@ -87,7 +87,7 @@ struct WddmFixtureWithMockGdiDll : public GdiDllFixture {
struct WddmInstrumentationGmmFixture { struct WddmInstrumentationGmmFixture {
void SetUp() { void SetUp() {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
wddm.reset(static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()))); wddm.reset(static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get())));
gmmMem = new ::testing::NiceMock<GmockGmmMemory>(executionEnvironment->getGmmClientContext()); gmmMem = new ::testing::NiceMock<GmockGmmMemory>(executionEnvironment->getGmmClientContext());
wddm->gmmMemory.reset(gmmMem); wddm->gmmMemory.reset(gmmMem);

2
unit_tests/os_interface/windows/wddm_kmdaf_listener_tests.cpp
View File

@@ -39,7 +39,7 @@ class WddmWithKmDafMock : public Wddm {
class WddmKmDafListenerTest : public ::testing::Test { class WddmKmDafListenerTest : public ::testing::Test {
public: public:
void SetUp() { void SetUp() {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
wddmWithKmDafMock.reset(new WddmWithKmDafMock(*executionEnvironment->rootDeviceEnvironments[0].get())); wddmWithKmDafMock.reset(new WddmWithKmDafMock(*executionEnvironment->rootDeviceEnvironments[0].get()));
wddmWithKmDafMock->gdi.reset(new MockGdi()); wddmWithKmDafMock->gdi.reset(new MockGdi());
auto hwInfo = *platformDevices[0]; auto hwInfo = *platformDevices[0];

12
unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@@ -37,7 +37,7 @@ using namespace ::testing;
void WddmMemoryManagerFixture::SetUp() { void WddmMemoryManagerFixture::SetUp() {
GdiDllFixture::SetUp(); GdiDllFixture::SetUp();
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get())); wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
if (platformDevices[0]->capabilityTable.ftrRenderCompressedBuffers || platformDevices[0]->capabilityTable.ftrRenderCompressedImages) { if (platformDevices[0]->capabilityTable.ftrRenderCompressedBuffers || platformDevices[0]->capabilityTable.ftrRenderCompressedImages) {
GMM_TRANSLATIONTABLE_CALLBACKS dummyTTCallbacks = {}; GMM_TRANSLATIONTABLE_CALLBACKS dummyTTCallbacks = {};
@@ -1808,9 +1808,9 @@ TEST(WddmMemoryManager, givenMultipleRootDeviceWhenMemoryManagerGetsWddmThenWddm
ultHwConfig.useMockedGetDevicesFunc = false; ultHwConfig.useMockedGetDevicesFunc = false;
platform()->initialize(); platform()->initialize();
MockWddmMemoryManager wddmMemoryManager(*platformImpl->peekExecutionEnvironment()); MockWddmMemoryManager wddmMemoryManager(*platform()->peekExecutionEnvironment());
for (auto i = 0u; i < platformImpl->peekExecutionEnvironment()->rootDeviceEnvironments.size(); i++) { for (auto i = 0u; i < platform()->peekExecutionEnvironment()->rootDeviceEnvironments.size(); i++) {
auto wddmFromRootDevice = platformImpl->peekExecutionEnvironment()->rootDeviceEnvironments[i]->osInterface->get()->getWddm(); auto wddmFromRootDevice = platform()->peekExecutionEnvironment()->rootDeviceEnvironments[i]->osInterface->get()->getWddm();
EXPECT_EQ(wddmFromRootDevice, &wddmMemoryManager.getWddm(i)); EXPECT_EQ(wddmFromRootDevice, &wddmMemoryManager.getWddm(i));
} }
} }
@@ -1823,11 +1823,11 @@ TEST(WddmMemoryManager, givenMultipleRootDeviceWhenCreateMemoryManagerThenTakeMa
ultHwConfig.useMockedGetDevicesFunc = false; ultHwConfig.useMockedGetDevicesFunc = false;
platform()->initialize(); platform()->initialize();
for (auto i = 0u; i < numRootDevices; i++) { for (auto i = 0u; i < numRootDevices; i++) {
auto wddm = static_cast<WddmMock *>(platformImpl->peekExecutionEnvironment()->rootDeviceEnvironments[i]->osInterface->get()->getWddm()); auto wddm = static_cast<WddmMock *>(platform()->peekExecutionEnvironment()->rootDeviceEnvironments[i]->osInterface->get()->getWddm());
wddm->minAddress = i * (numRootDevices - i); wddm->minAddress = i * (numRootDevices - i);
} }
MockWddmMemoryManager wddmMemoryManager(*platformImpl->peekExecutionEnvironment()); MockWddmMemoryManager wddmMemoryManager(*platform()->peekExecutionEnvironment());
EXPECT_EQ(4u, wddmMemoryManager.getAlignedMallocRestrictions()->minAddress); EXPECT_EQ(4u, wddmMemoryManager.getAlignedMallocRestrictions()->minAddress);
} }

4
unit_tests/os_interface/windows/wddm_memory_manager_tests.h
View File

@@ -45,7 +45,7 @@ typedef ::Test<WddmMemoryManagerFixture> WddmMemoryManagerTest;
class MockWddmMemoryManagerFixture { class MockWddmMemoryManagerFixture {
public: public:
void SetUp() { void SetUp() {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
gdi = new MockGdi(); gdi = new MockGdi();
wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get())); wddm = static_cast<WddmMock *>(Wddm::createWddm(*executionEnvironment->rootDeviceEnvironments[0].get()));
@@ -84,7 +84,7 @@ typedef ::Test<MockWddmMemoryManagerFixture> WddmMemoryManagerResidencyTest;
class ExecutionEnvironmentFixture : public ::testing::Test { class ExecutionEnvironmentFixture : public ::testing::Test {
public: public:
ExecutionEnvironmentFixture() { ExecutionEnvironmentFixture() {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
} }
ExecutionEnvironment *executionEnvironment; ExecutionEnvironment *executionEnvironment;

2
unit_tests/os_interface/windows/wddm_residency_controller_tests.cpp
View File

@@ -111,7 +111,7 @@ struct WddmResidencyControllerWithGdiTest : ::testing::Test {
struct WddmResidencyControllerWithMockWddmTest : public WddmResidencyControllerTest { struct WddmResidencyControllerWithMockWddmTest : public WddmResidencyControllerTest {
void SetUp() { void SetUp() {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
wddm = new ::testing::NiceMock<GmockWddm>(*executionEnvironment->rootDeviceEnvironments[0].get()); wddm = new ::testing::NiceMock<GmockWddm>(*executionEnvironment->rootDeviceEnvironments[0].get());
wddm->gdi = std::make_unique<MockGdi>(); wddm->gdi = std::make_unique<MockGdi>();

20
unit_tests/platform/platform_tests.cpp
View File

@@ -355,26 +355,24 @@ TEST_F(PlatformTest, testRemoveLastSpace) {
EXPECT_EQ(std::string("x"), xSpaceString); EXPECT_EQ(std::string("x"), xSpaceString);
} }
TEST(PlatformConstructionTest, givenPlatformConstructorWhenItIsCalledTwiceThenTheSamePlatformIsReturned) { TEST(PlatformConstructionTest, givenPlatformConstructorWhenItIsCalledTwiceThenTheSamePlatformIsReturned) {
platformImpl.reset(); platformsImpl.clear();
ASSERT_EQ(nullptr, platformImpl); auto platform1 = constructPlatform();
auto platform = constructPlatform(); EXPECT_EQ(platform1, platform());
EXPECT_EQ(platform, platformImpl.get());
auto platform2 = constructPlatform(); auto platform2 = constructPlatform();
EXPECT_EQ(platform2, platform); EXPECT_EQ(platform2, platform1);
EXPECT_NE(platform, nullptr); EXPECT_NE(platform1, nullptr);
} }
TEST(PlatformConstructionTest, givenPlatformConstructorWhenItIsCalledAfterResetThenNewPlatformIsConstructed) { TEST(PlatformConstructionTest, givenPlatformConstructorWhenItIsCalledAfterResetThenNewPlatformIsConstructed) {
platformImpl.reset(); platformsImpl.clear();
ASSERT_EQ(nullptr, platformImpl);
auto platform = constructPlatform(); auto platform = constructPlatform();
std::unique_ptr<Platform> temporaryOwnership(std::move(platformImpl)); std::unique_ptr<Platform> temporaryOwnership(std::move(platformsImpl[0]));
EXPECT_EQ(nullptr, platformImpl.get()); platformsImpl.clear();
auto platform2 = constructPlatform(); auto platform2 = constructPlatform();
EXPECT_NE(platform2, platform); EXPECT_NE(platform2, platform);
EXPECT_NE(platform, nullptr); EXPECT_NE(platform, nullptr);
EXPECT_NE(platform2, nullptr); EXPECT_NE(platform2, nullptr);
platformImpl.reset(nullptr); platformsImpl.clear();
} }
TEST(PlatformInitLoopTests, givenPlatformWhenInitLoopHelperIsCalledThenItDoesNothing) { TEST(PlatformInitLoopTests, givenPlatformWhenInitLoopHelperIsCalledThenItDoesNothing) {

6
unit_tests/program/program_tests.cpp
View File

@@ -2581,14 +2581,14 @@ TEST(SimpleProgramTests, givenDefaultProgramWhenSetDeviceIsCalledThenDeviceIsSet
} }
TEST(ProgramDestructionTests, givenProgramUsingDeviceWhenItIsDestroyedAfterPlatfromCleanupThenItIsCleanedUpProperly) { TEST(ProgramDestructionTests, givenProgramUsingDeviceWhenItIsDestroyedAfterPlatfromCleanupThenItIsCleanedUpProperly) {
platformImpl->initialize(); platform()->initialize();
auto device = platformImpl->getClDevice(0); auto device = platform()->getClDevice(0);
MockContext *context = new MockContext(device, false); MockContext *context = new MockContext(device, false);
MockProgram *pProgram = new MockProgram(*device->getExecutionEnvironment(), context, false); MockProgram *pProgram = new MockProgram(*device->getExecutionEnvironment(), context, false);
auto globalAllocation = device->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}); auto globalAllocation = device->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
pProgram->setGlobalSurface(globalAllocation); pProgram->setGlobalSurface(globalAllocation);
platformImpl.reset(nullptr); platformsImpl.clear();
EXPECT_EQ(1, device->getRefInternalCount()); EXPECT_EQ(1, device->getRefInternalCount());
EXPECT_EQ(1, pProgram->getRefInternalCount()); EXPECT_EQ(1, pProgram->getRefInternalCount());
context->decRefInternal(); context->decRefInternal();

2
unit_tests/sharings/gl/windows/gl_arb_sync_event_tests.cpp
View File

@@ -64,7 +64,7 @@ struct GlArbSyncEventTest : public ::testing::Test {
} }
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
auto mockCsr = new MockCommandStreamReceiver(*executionEnvironment, 0); auto mockCsr = new MockCommandStreamReceiver(*executionEnvironment, 0);
executionEnvironment->memoryManager = std::make_unique<OsAgnosticMemoryManager>(*executionEnvironment); executionEnvironment->memoryManager = std::make_unique<OsAgnosticMemoryManager>(*executionEnvironment);
device = std::make_unique<MockClDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0u)); device = std::make_unique<MockClDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0u));

2
unit_tests/sharings/gl/windows/gl_texture_tests.cpp
View File

@@ -49,7 +49,7 @@ class GlSharingTextureTests : public ::testing::Test {
}; };
void SetUp() override { void SetUp() override {
executionEnvironment = platformImpl->peekExecutionEnvironment(); executionEnvironment = platform()->peekExecutionEnvironment();
imgDesc = {}; imgDesc = {};
imgDesc.image_type = CL_MEM_OBJECT_IMAGE1D; imgDesc.image_type = CL_MEM_OBJECT_IMAGE1D;
imgDesc.image_width = 10; imgDesc.image_width = 10;

6
unit_tests/source_level_debugger/source_level_debugger_device_tests.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018-2019 Intel Corporation * Copyright (C) 2018-2020 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -37,7 +37,7 @@ class MockDeviceWithDebuggerActive : public MockDevice {
}; };
TEST(DeviceWithSourceLevelDebugger, givenDeviceWithSourceLevelDebuggerActiveWhenDeviceIsDestructedThenSourceLevelDebuggerIsNotified) { TEST(DeviceWithSourceLevelDebugger, givenDeviceWithSourceLevelDebuggerActiveWhenDeviceIsDestructedThenSourceLevelDebuggerIsNotified) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
auto gmock = new ::testing::NiceMock<GMockSourceLevelDebugger>(new MockOsLibrary); auto gmock = new ::testing::NiceMock<GMockSourceLevelDebugger>(new MockOsLibrary);
executionEnvironment->sourceLevelDebugger.reset(gmock); executionEnvironment->sourceLevelDebugger.reset(gmock);
auto device = std::unique_ptr<MockDevice>(MockDevice::create<MockDeviceWithDebuggerActive>(executionEnvironment, 0u)); auto device = std::unique_ptr<MockDevice>(MockDevice::create<MockDeviceWithDebuggerActive>(executionEnvironment, 0u));
@@ -46,7 +46,7 @@ TEST(DeviceWithSourceLevelDebugger, givenDeviceWithSourceLevelDebuggerActiveWhen
} }
TEST(DeviceWithSourceLevelDebugger, givenDeviceWithSourceLevelDebuggerActiveWhenDeviceIsCreatedThenPreemptionIsDisabled) { TEST(DeviceWithSourceLevelDebugger, givenDeviceWithSourceLevelDebuggerActiveWhenDeviceIsCreatedThenPreemptionIsDisabled) {
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->sourceLevelDebugger.reset(new MockActiveSourceLevelDebugger(new MockOsLibrary)); executionEnvironment->sourceLevelDebugger.reset(new MockActiveSourceLevelDebugger(new MockOsLibrary));
auto device = std::unique_ptr<MockDevice>(MockDevice::create<MockDeviceWithDebuggerActive>(executionEnvironment, 0u)); auto device = std::unique_ptr<MockDevice>(MockDevice::create<MockDeviceWithDebuggerActive>(executionEnvironment, 0u));

4
unit_tests/source_level_debugger/source_level_debugger_tests.cpp
View File

@@ -529,7 +529,7 @@ TEST(SourceLevelDebugger, givenTwoRootDevicesWhenSecondIsCreatedThenNotCreatingN
DebuggerLibrary::setDebuggerActive(true); DebuggerLibrary::setDebuggerActive(true);
DebuggerLibrary::injectDebuggerLibraryInterceptor(&interceptor); DebuggerLibrary::injectDebuggerLibraryInterceptor(&interceptor);
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(2); executionEnvironment->prepareRootDeviceEnvironments(2);
std::unique_ptr<Device> device1(Device::create<MockDevice>(executionEnvironment, 0u)); std::unique_ptr<Device> device1(Device::create<MockDevice>(executionEnvironment, 0u));
@@ -550,7 +550,7 @@ TEST(SourceLevelDebugger, givenMultipleRootDevicesWhenTheyAreCreatedTheyAllReuse
DebuggerLibrary::setLibraryAvailable(true); DebuggerLibrary::setLibraryAvailable(true);
DebuggerLibrary::setDebuggerActive(true); DebuggerLibrary::setDebuggerActive(true);
ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(2); executionEnvironment->prepareRootDeviceEnvironments(2);
std::unique_ptr<Device> device1(Device::create<NEO::MockDevice>(executionEnvironment, 0u)); std::unique_ptr<Device> device1(Device::create<NEO::MockDevice>(executionEnvironment, 0u));
auto sourceLevelDebugger = device1->getSourceLevelDebugger(); auto sourceLevelDebugger = device1->getSourceLevelDebugger();

2
unit_tests/ult_config_listener.cpp
View File

@@ -23,7 +23,7 @@ void NEO::UltConfigListener::OnTestStart(const ::testing::TestInfo &testInfo) {
} }
void NEO::UltConfigListener::OnTestEnd(const ::testing::TestInfo &testInfo) { void NEO::UltConfigListener::OnTestEnd(const ::testing::TestInfo &testInfo) {
// Clear global platform that it shouldn't be reused between tests // Clear global platform that it shouldn't be reused between tests
platformImpl.reset(); platformsImpl.clear();
MemoryManager::maxOsContextCount = 0u; MemoryManager::maxOsContextCount = 0u;
// Ensure that global state is restored // Ensure that global state is restored

5
unit_tests/windows/get_devices_tests.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2019 Intel Corporation * Copyright (C) 2019-2020 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -24,7 +24,8 @@ HWTEST_F(GetDevicesTests, WhenGetDevicesIsCalledThenSuccessIsReturned) {
} }
HWTEST_F(GetDevicesTests, whenGetDevicesIsCalledThenGmmIsBeingInitializedAfterFillingHwInfo) { HWTEST_F(GetDevicesTests, whenGetDevicesIsCalledThenGmmIsBeingInitializedAfterFillingHwInfo) {
platformImpl.reset(new Platform()); platformsImpl.clear();
platformsImpl.push_back(std::make_unique<Platform>());
size_t numDevicesReturned = 0; size_t numDevicesReturned = 0;
auto hwInfo = platform()->peekExecutionEnvironment()->getMutableHardwareInfo(); auto hwInfo = platform()->peekExecutionEnvironment()->getMutableHardwareInfo();
hwInfo->platform.eProductFamily = PRODUCT_FAMILY::IGFX_UNKNOWN; hwInfo->platform.eProductFamily = PRODUCT_FAMILY::IGFX_UNKNOWN;