Skip to content

Commit c238f73

Browse files
km-nowakCompute-Runtime-Automation
km-nowak
authored and
Compute-Runtime-Automation
committed
fix: Skip mapping copy engines for unsupported ones
Based on the info retrieved from product helper, skip mapping returned copy engines from KMD to disabled ones. - Unify logic for EngineInfo ctors (remove redundant code). Related-To: NEO-8356 Signed-off-by: Kacper Nowak <kacper.nowak@intel.com>
1 parent 976d112 commit c238f73

File tree

7 files changed

+142
-53
lines changed

7 files changed

+142
-53
lines changed

‎shared/source/os_interface/linux/engine_info.cpp‎

Lines changed: 45 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (C) 2022-2023 Intel Corporation
2+
* Copyright (C) 2022-2024 Intel Corporation
33
*
44
* SPDX-License-Identifier: MIT
55
*
@@ -15,8 +15,10 @@
1515
#include "shared/source/helpers/hw_info.h"
1616
#include "shared/source/os_interface/linux/drm_neo.h"
1717
#include "shared/source/os_interface/linux/drm_wrappers.h"
18+
#include "shared/source/os_interface/product_helper.h"
1819

1920
#include <array>
21+
#include <iterator>
2022

2123
namespace NEO {
2224
namespace DrmEngineMappingHelper {
@@ -47,8 +49,38 @@ void assignLinkCopyEngine(std::vector<EngineInfo::EngineToInstanceMap> &tileToEn
4749
UNRECOVERABLE_IF(bcsInfoMask.test(engineMaskIndex));
4850
bcsInfoMask.set(engineMaskIndex, true);
4951
}
52+
53+
auto getCopyEnginesMappingIterator(const NEO::RootDeviceEnvironment &rootDeviceEnvironment) {
54+
auto mappingCopyEngineIt = DrmEngineMappingHelper::engineMapping.begin();
55+
if (const auto defaultCopyEngine = rootDeviceEnvironment.getProductHelper().getDefaultCopyEngine(); defaultCopyEngine != *mappingCopyEngineIt) {
56+
mappingCopyEngineIt++;
57+
} // Note that BCS0 may not be enabled
58+
return mappingCopyEngineIt;
59+
}
60+
61+
uint32_t getBcsEngineMaskIndex(const aub_stream::EngineType *mappingCopyEngineIt) {
62+
if (*mappingCopyEngineIt == aub_stream::EngineType::ENGINE_BCS) {
63+
return 0u;
64+
} else
65+
return *mappingCopyEngineIt - aub_stream::EngineType::ENGINE_BCS1 + 1;
66+
}
5067
} // namespace
5168

69+
void EngineInfo::mapEngine(const NEO::IoctlHelper *ioctlHelper, const EngineClassInstance &engine, BcsInfoMask &bcsInfoMask, const NEO::RootDeviceEnvironment &rootDeviceEnvironment,
70+
const aub_stream::EngineType *&mappingCopyEngineIt, uint32_t &computeEnginesCounter, uint32_t tileId) {
71+
72+
tileToEngineMap.emplace(tileId, engine);
73+
if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)) {
74+
tileToEngineToInstanceMap[tileId][EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, rootDeviceEnvironment)] = engine;
75+
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)) {
76+
tileToEngineToInstanceMap[tileId][*(mappingCopyEngineIt)] = engine;
77+
bcsInfoMask.set(getBcsEngineMaskIndex(mappingCopyEngineIt++), true);
78+
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCompute)) {
79+
tileToEngineToInstanceMap[tileId][static_cast<aub_stream::EngineType>(aub_stream::ENGINE_CCS + computeEnginesCounter)] = engine;
80+
computeEnginesCounter++;
81+
}
82+
}
83+
5284
EngineInfo::EngineInfo(Drm *drm, const std::vector<EngineCapabilities> &engineInfos) : engines(engineInfos), tileToEngineToInstanceMap(1) {
5385
auto computeEngines = 0u;
5486
BcsInfoMask bcsInfoMask = 0;
@@ -79,57 +111,40 @@ EngineInfo::EngineInfo(Drm *drm, const StackVec<std::vector<EngineClassInstance>
79111
auto ioctlHelper = drm->getIoctlHelper();
80112
auto &rootDeviceEnvironment = drm->getRootDeviceEnvironment();
81113
auto computeEnginesPerTile = 0u;
82-
auto copyEnginesPerTile = 0u;
114+
BcsInfoMask bcsInfoMask = {};
115+
83116
for (auto tile = 0u; tile < engineClassInstancePerTile.size(); tile++) {
84-
copyEnginesPerTile = 0u;
85117
computeEnginesPerTile = 0u;
118+
auto copyEnginesMappingIt = getCopyEnginesMappingIterator(rootDeviceEnvironment);
119+
86120
for (const auto &engine : engineClassInstancePerTile[tile]) {
87-
tileToEngineMap.emplace(tile, engine);
88-
if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)) {
89-
tileToEngineToInstanceMap[tile][EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, rootDeviceEnvironment)] = engine;
90-
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)) {
91-
tileToEngineToInstanceMap[tile][DrmEngineMappingHelper::engineMapping[copyEnginesPerTile]] = engine;
92-
copyEnginesPerTile++;
93-
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCompute)) {
94-
tileToEngineToInstanceMap[tile][static_cast<aub_stream::EngineType>(aub_stream::ENGINE_CCS + computeEnginesPerTile)] = engine;
95-
computeEnginesPerTile++;
96-
}
121+
mapEngine(ioctlHelper, engine, bcsInfoMask, rootDeviceEnvironment, copyEnginesMappingIt, computeEnginesPerTile, tile);
97122
}
98123
}
99-
BcsInfoMask bcsInfoMask = maxNBitValue(copyEnginesPerTile);
100124
setSupportedEnginesInfo(rootDeviceEnvironment, computeEnginesPerTile, bcsInfoMask);
101125
}
102126

103127
EngineInfo::EngineInfo(Drm *drm, uint32_t tileCount, const std::vector<DistanceInfo> &distanceInfos, const std::vector<QueryItem> &queryItems, const std::vector<EngineCapabilities> &engineInfos)
104128
: engines(engineInfos), tileToEngineToInstanceMap(tileCount) {
105129
auto tile = 0u;
106130
auto computeEnginesPerTile = 0u;
107-
auto copyEnginesPerTile = 0u;
108131
auto ioctlHelper = drm->getIoctlHelper();
109132
auto &rootDeviceEnvironment = drm->getRootDeviceEnvironment();
133+
BcsInfoMask bcsInfoMask = {};
134+
135+
auto copyEnginesMappingIt = getCopyEnginesMappingIterator(rootDeviceEnvironment);
110136
for (auto i = 0u; i < distanceInfos.size(); i++) {
111137
if (i > 0u && distanceInfos[i].region.memoryInstance != distanceInfos[i - 1u].region.memoryInstance) {
112138
tile++;
113139
computeEnginesPerTile = 0u;
114-
copyEnginesPerTile = 0u;
140+
copyEnginesMappingIt = getCopyEnginesMappingIterator(rootDeviceEnvironment);
115141
}
116-
if (queryItems[i].length < 0 || distanceInfos[i].distance != 0)
142+
if (queryItems[i].length < 0 || distanceInfos[i].distance != 0) {
117143
continue;
118-
119-
auto engine = distanceInfos[i].engine;
120-
tileToEngineMap.emplace(tile, engine);
121-
if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)) {
122-
tileToEngineToInstanceMap[tile][EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, rootDeviceEnvironment)] = engine;
123-
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy)) {
124-
tileToEngineToInstanceMap[tile][DrmEngineMappingHelper::engineMapping[copyEnginesPerTile]] = engine;
125-
copyEnginesPerTile++;
126-
} else if (engine.engineClass == ioctlHelper->getDrmParamValue(DrmParam::engineClassCompute)) {
127-
tileToEngineToInstanceMap[tile][static_cast<aub_stream::EngineType>(aub_stream::ENGINE_CCS + computeEnginesPerTile)] = engine;
128-
computeEnginesPerTile++;
129144
}
145+
auto engine = distanceInfos[i].engine;
146+
mapEngine(ioctlHelper, engine, bcsInfoMask, rootDeviceEnvironment, copyEnginesMappingIt, computeEnginesPerTile, tile);
130147
}
131-
132-
BcsInfoMask bcsInfoMask = maxNBitValue(copyEnginesPerTile);
133148
setSupportedEnginesInfo(rootDeviceEnvironment, computeEnginesPerTile, bcsInfoMask);
134149
}
135150

‎shared/source/os_interface/linux/engine_info.h‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (C) 2019-2023 Intel Corporation
2+
* Copyright (C) 2019-2024 Intel Corporation
33
*
44
* SPDX-License-Identifier: MIT
55
*
@@ -43,6 +43,8 @@ struct EngineInfo {
4343

4444
void assignCopyEngine(aub_stream::EngineType baseEngineType, uint32_t tileId, const EngineClassInstance &engine,
4545
BcsInfoMask &bcsInfoMask, uint32_t &numHostLinkCopyEngines, uint32_t &numScaleUpLinkCopyEngines);
46+
void mapEngine(const NEO::IoctlHelper *ioctlHelper, const EngineClassInstance &engine, BcsInfoMask &bcsInfoMask, const NEO::RootDeviceEnvironment &rootDeviceEnvironment,
47+
const aub_stream::EngineType *&mappingCopyEngineIt, uint32_t &computeEnginesCounter, uint32_t tileId = 0u);
4648

4749
std::vector<EngineToInstanceMap> tileToEngineToInstanceMap;
4850
std::multimap<uint32_t, EngineClassInstance> tileToEngineMap;

‎shared/test/common/helpers/mock_product_helper_hw.h‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (C) 2022-2023 Intel Corporation
2+
* Copyright (C) 2022-2024 Intel Corporation
33
*
44
* SPDX-License-Identifier: MIT
55
*
@@ -25,6 +25,7 @@ struct MockProductHelperHw : NEO::ProductHelperHw<productFamily> {
2525
uint32_t getL1CachePolicy(bool isDebuggerActive) const override;
2626
bool isUnlockingLockedPtrNecessary(const HardwareInfo &hwInfo) const override;
2727
std::vector<uint32_t> getSupportedNumGrfs(const ReleaseHelper *releaseHelper) const override;
28+
aub_stream::EngineType getDefaultCopyEngine() const override;
2829

2930
bool use128MbEdram = false;
3031
bool enableMidThreadPreemption = false;
@@ -37,5 +38,6 @@ struct MockProductHelperHw : NEO::ProductHelperHw<productFamily> {
3738
uint32_t returnedL1CachePolicy = 0;
3839
uint32_t returnedL1CachePolicyIfDebugger = 0;
3940
std::vector<int32_t> threadArbPolicies = {};
41+
aub_stream::EngineType mockDefaultCopyEngine = aub_stream::EngineType::ENGINE_BCS;
4042
};
4143
} // namespace NEO

‎shared/test/common/helpers/mock_product_helper_hw.inl‎

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (C) 2022-2023 Intel Corporation
2+
* Copyright (C) 2022-2024 Intel Corporation
33
*
44
* SPDX-License-Identifier: MIT
55
*
@@ -82,4 +82,10 @@ std::vector<uint32_t> MockProductHelperHw<gfxProduct>::getSupportedNumGrfs(const
8282
}
8383
return {128u};
8484
}
85+
86+
template <>
87+
aub_stream::EngineType MockProductHelperHw<gfxProduct>::getDefaultCopyEngine() const {
88+
return this->mockDefaultCopyEngine;
89+
}
90+
8591
} // namespace NEO

‎shared/test/unit_test/os_interface/linux/drm_engine_info_prelim_tests.cpp‎

Lines changed: 20 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (C) 2022-2023 Intel Corporation
2+
* Copyright (C) 2022-2024 Intel Corporation
33
*
44
* SPDX-License-Identifier: MIT
55
*
@@ -11,6 +11,7 @@
1111
#include "shared/source/os_interface/linux/engine_info.h"
1212
#include "shared/source/os_interface/linux/i915.h"
1313
#include "shared/source/os_interface/linux/memory_info.h"
14+
#include "shared/source/os_interface/product_helper.h"
1415
#include "shared/test/common/helpers/debug_manager_state_restore.h"
1516
#include "shared/test/common/helpers/default_hw_info.h"
1617
#include "shared/test/common/helpers/variable_backup.h"
@@ -201,11 +202,14 @@ static void givenBcsEngineTypeWhenBindingDrmContextThenContextParamEngineIsSet(s
201202
HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenBcsEngineWhenBindingDrmContextThenContextParamEngineIsSet) {
202203
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
203204
executionEnvironment->rootDeviceEnvironments[0]->initGmm();
205+
auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getProductHelper();
206+
auto defaultCopyEngine = productHelper.getDefaultCopyEngine();
204207

205208
auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
206-
givenEngineTypeWhenBindingDrmContextThenContextParamEngineIsSet(drm, aub_stream::ENGINE_BCS, drm_i915_gem_engine_class::I915_ENGINE_CLASS_COPY);
209+
givenEngineTypeWhenBindingDrmContextThenContextParamEngineIsSet(drm, defaultCopyEngine, drm_i915_gem_engine_class::I915_ENGINE_CLASS_COPY);
207210
auto hwInfo = drm->rootDeviceEnvironment.getHardwareInfo();
208-
EXPECT_EQ(1u, hwInfo->featureTable.ftrBcsInfo.to_ulong());
211+
auto ftrBcsInfoVal = static_cast<unsigned long>(1u << (aub_stream::EngineType::ENGINE_BCS == defaultCopyEngine ? 0 : 1));
212+
EXPECT_EQ(ftrBcsInfoVal, hwInfo->featureTable.ftrBcsInfo.to_ulong());
209213
}
210214

211215
HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenLinkBcsEngineWhenBindingSingleTileDrmContextThenContextParamEngineIsSet) {
@@ -348,24 +352,32 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenLinkBcsEngineWhenBindingM
348352

349353
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
350354
executionEnvironment->rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(&localHwInfo);
355+
auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getProductHelper();
356+
bool bcs0Enabled = (aub_stream::EngineType::ENGINE_BCS == productHelper.getDefaultCopyEngine());
357+
351358
auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
352359
drm->supportedCopyEnginesMask = maxNBitValue(9);
360+
if (false == bcs0Enabled) {
361+
drm->supportedCopyEnginesMask.set(0, false);
362+
}
353363

354364
drm->queryEngineInfo();
355365
EXPECT_NE(nullptr, drm->engineInfo);
356366
auto hwInfo = drm->rootDeviceEnvironment.getHardwareInfo();
357367
EXPECT_EQ(drm->supportedCopyEnginesMask.count(), hwInfo->featureTable.ftrBcsInfo.count());
358368

359369
for (auto tileId = 0; tileId < hwInfo->gtSystemInfo.MultiTileArchInfo.TileCount; tileId++) {
360-
for (auto engineIndex = 0u; engineIndex < drm->supportedCopyEnginesMask.count(); engineIndex++) {
370+
auto engineIndex = bcs0Enabled ? 0u : 1u;
371+
while (engineIndex < drm->supportedCopyEnginesMask.count()) {
361372
auto numBcsSiblings = drm->supportedCopyEnginesMask.count();
362-
auto engineType = aub_stream::ENGINE_BCS;
373+
auto engineType = bcs0Enabled ? aub_stream::EngineType::ENGINE_BCS : aub_stream::EngineType::ENGINE_BCS1;
363374
if (engineIndex > 0) {
364375
engineType = static_cast<aub_stream::EngineType>(aub_stream::ENGINE_BCS1 + engineIndex - 1);
365376
numBcsSiblings -= 1;
366377
}
367378

368379
givenBcsEngineTypeWhenBindingDrmContextThenContextParamEngineIsSet(drm, engineType, numBcsSiblings, engineIndex, static_cast<uint32_t>(tileId));
380+
engineIndex++;
369381
}
370382
}
371383
}
@@ -682,6 +694,8 @@ TEST(DrmTest, givenVirtualEnginesEnabledAndNotEnoughCcsEnginesWhenCreatingContex
682694
TEST(DrmTest, givenVirtualEnginesEnabledAndNonCcsEnginesWhenCreatingContextThenDontEnableLoadBalancing) {
683695
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
684696
executionEnvironment->rootDeviceEnvironments[0]->initGmm();
697+
auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getProductHelper();
698+
auto defaultCopyEngine = productHelper.getDefaultCopyEngine();
685699

686700
auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
687701
drm->rootDeviceEnvironment.getMutableHardwareInfo()->featureTable.ftrBcsInfo = 1;
@@ -691,7 +705,7 @@ TEST(DrmTest, givenVirtualEnginesEnabledAndNonCcsEnginesWhenCreatingContextThenD
691705

692706
drm->receivedContextParamRequestCount = 0u;
693707
auto drmContextId = 42u;
694-
auto engineFlag = drm->bindDrmContext(drmContextId, 0u, aub_stream::ENGINE_BCS, false);
708+
auto engineFlag = drm->bindDrmContext(drmContextId, 0u, defaultCopyEngine, false);
695709

696710
EXPECT_EQ(static_cast<unsigned int>(I915_EXEC_DEFAULT), engineFlag);
697711
EXPECT_EQ(1u, drm->receivedContextParamRequestCount);

‎shared/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp‎

Lines changed: 44 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (C) 2019-2023 Intel Corporation
2+
* Copyright (C) 2019-2024 Intel Corporation
33
*
44
* SPDX-License-Identifier: MIT
55
*
@@ -8,8 +8,11 @@
88
#include "shared/source/os_interface/linux/engine_info.h"
99
#include "shared/source/os_interface/linux/i915.h"
1010
#include "shared/source/os_interface/linux/memory_info.h"
11+
#include "shared/test/common/helpers/mock_product_helper_hw.h"
12+
#include "shared/test/common/helpers/raii_product_helper.h"
1113
#include "shared/test/common/libult/linux/drm_mock.h"
1214
#include "shared/test/common/mocks/mock_execution_environment.h"
15+
#include "shared/test/common/test_macros/hw_test.h"
1316

1417
#include "gtest/gtest.h"
1518

@@ -114,6 +117,9 @@ TEST(EngineInfoTest, whenGetEngineInstanceAndTileThenCorrectValuesReturned) {
114117
auto drm = std::make_unique<DrmMockEngine>(*executionEnvironment->rootDeviceEnvironments[0]);
115118
auto ioctlHelper = drm->getIoctlHelper();
116119

120+
const auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getProductHelper();
121+
const auto defaultCopyEngine = productHelper.getDefaultCopyEngine();
122+
117123
std::vector<EngineCapabilities> engines(4);
118124
engines[0].engine = {static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)), 0};
119125
engines[0].capabilities = 0;
@@ -145,7 +151,7 @@ TEST(EngineInfoTest, whenGetEngineInstanceAndTileThenCorrectValuesReturned) {
145151
EXPECT_EQ(engines[0].engine.engineClass, engine->engineClass);
146152
EXPECT_EQ(engines[0].engine.engineInstance, engine->engineInstance);
147153

148-
engine = engineInfo->getEngineInstance(1, aub_stream::EngineType::ENGINE_BCS);
154+
engine = engineInfo->getEngineInstance(1, defaultCopyEngine);
149155
EXPECT_EQ(engines[3].engine.engineClass, engine->engineClass);
150156
EXPECT_EQ(engines[3].engine.engineInstance, engine->engineInstance);
151157

@@ -203,3 +209,39 @@ TEST(EngineInfoTest, whenEmptyEngineInfoCreatedThen0TileReturned) {
203209
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), 0, distances, queryItems, engines);
204210
EXPECT_EQ(0u, engineInfo->getEngineTileIndex({static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassRender)), 1}));
205211
}
212+
213+
using DisabledBCSEngineInfoTest = ::testing::Test;
214+
215+
HWTEST2_F(DisabledBCSEngineInfoTest, whenBCS0IsNotEnabledThenSkipMappingItAndSetProperBcsInfoMask, MatchAny) {
216+
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
217+
auto &rootDeviceEnvironment = *executionEnvironment->rootDeviceEnvironments[0];
218+
auto drm = std::make_unique<DrmMockEngine>(rootDeviceEnvironment);
219+
auto ioctlHelper = drm->getIoctlHelper();
220+
221+
RAIIProductHelperFactory<MockProductHelperHw<productFamily>> raii(rootDeviceEnvironment);
222+
raii.mockProductHelper->mockDefaultCopyEngine = aub_stream::EngineType::ENGINE_BCS1;
223+
auto emplaceCopyEngine = [&ioctlHelper](std::vector<EngineClassInstance> &vec) {
224+
auto &emplaced = vec.emplace_back();
225+
emplaced.engineClass = static_cast<uint16_t>(ioctlHelper->getDrmParamValue(DrmParam::engineClassCopy));
226+
emplaced.engineInstance = 0u;
227+
};
228+
229+
StackVec<std::vector<EngineClassInstance>, 2> enginesPerTile{};
230+
enginesPerTile.resize(2u);
231+
for (int tileIdx = 0; tileIdx < 2; tileIdx++) {
232+
emplaceCopyEngine(enginesPerTile[tileIdx]);
233+
emplaceCopyEngine(enginesPerTile[tileIdx]);
234+
}
235+
236+
auto engineInfo = std::make_unique<EngineInfo>(drm.get(), enginesPerTile);
237+
EXPECT_EQ(nullptr, engineInfo->getEngineInstance(0u, aub_stream::EngineType::ENGINE_BCS));
238+
EXPECT_NE(nullptr, engineInfo->getEngineInstance(0u, aub_stream::EngineType::ENGINE_BCS1));
239+
EXPECT_NE(nullptr, engineInfo->getEngineInstance(0u, aub_stream::EngineType::ENGINE_BCS2));
240+
241+
EXPECT_EQ(nullptr, engineInfo->getEngineInstance(1u, aub_stream::EngineType::ENGINE_BCS));
242+
EXPECT_NE(nullptr, engineInfo->getEngineInstance(1u, aub_stream::EngineType::ENGINE_BCS1));
243+
EXPECT_NE(nullptr, engineInfo->getEngineInstance(1u, aub_stream::EngineType::ENGINE_BCS2));
244+
245+
const auto hwInfo = rootDeviceEnvironment.getHardwareInfo();
246+
EXPECT_EQ(false, hwInfo->featureTable.ftrBcsInfo.test(0));
247+
}

0 commit comments

Comments
 (0)