intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 23:03:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

test: use realistic values in topology query tests

Browse Source 
Related-To: NEO-9489

Signed-off-by: Wenbin Lu <wenbin.lu@intel.com>
This commit is contained in:
Wenbin Lu
2024-07-26 23:52:13 +00:00
committed by Compute-Runtime-Automation
parent 6796f41c77
commit e2f1735cc5
8 changed files with 295 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
shared/test/common/libult/linux/drm_mock.cpp
View File

@@ -9,13 +9,13 @@
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/os_interface/linux/i915.h"
#include "shared/source/os_interface/linux/sys_calls.h"
#include "gtest/gtest.h"
#include <cmath>
#include <cstring>
const int DrmMock::mockFd;
@@ -293,8 +293,17 @@ int DrmMock::ioctl(DrmIoctl request, void *arg) {
auto queryItemArg = reinterpret_cast<QueryItem *>(queryArg->itemsPtr);
storedQueryItem = *queryItemArg;
auto realEuCount = std::max(rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.EUCount, static_cast<uint32_t>(this->storedEUVal));
auto dataSize = static_cast<size_t>(std::ceil(realEuCount / 8.0));
UNRECOVERABLE_IF((this->storedSVal != 0) && (this->storedSSVal % this->storedSVal != 0));
UNRECOVERABLE_IF((this->storedSSVal != 0) && (this->storedEUVal % this->storedSSVal != 0));
const uint16_t subslicesPerSlice = this->storedSVal ? (this->storedSSVal / this->storedSVal) : 0u;
const uint16_t eusPerSubslice = this->storedSSVal ? (this->storedEUVal / this->storedSSVal) : 0u;
const uint16_t subsliceOffset = static_cast<uint16_t>(Math::divideAndRoundUp(this->storedSVal, 8u));
const uint16_t subsliceStride = static_cast<uint16_t>(Math::divideAndRoundUp(subslicesPerSlice, 8u));
const uint16_t euOffset = subsliceOffset + this->storedSVal * subsliceStride;
const uint16_t euStride = static_cast<uint16_t>(Math::divideAndRoundUp(eusPerSubslice, 8u));
const uint16_t dataSize = euOffset + this->storedSSVal * euStride;
if (queryItemArg->length == 0) {
if (queryItemArg->queryId == DRM_I915_QUERY_TOPOLOGY_INFO) {
@@ -308,13 +317,17 @@ int DrmMock::ioctl(DrmIoctl request, void *arg) {
return -1;
}
topologyArg->maxSlices = this->storedSVal;
topologyArg->maxSubslices = this->storedSVal ? (this->storedSSVal / this->storedSVal) : 0;
topologyArg->maxEusPerSubslice = this->storedSSVal ? (this->storedEUVal / this->storedSSVal) : 0;
topologyArg->maxSubslices = subslicesPerSlice;
topologyArg->maxEusPerSubslice = eusPerSubslice;
topologyArg->subsliceOffset = subsliceOffset;
topologyArg->subsliceStride = subsliceStride;
topologyArg->euOffset = euOffset;
topologyArg->euStride = euStride;
if (this->disableSomeTopology) {
memset(topologyArg->data, 0xCA, dataSize);
memset(topologyArg->data, 0b11000110, dataSize);
} else {
memset(topologyArg->data, 0xFF, dataSize);
memset(topologyArg->data, 0b11111111, dataSize);
}
return 0;

41
shared/test/common/libult/linux/drm_mock_prelim_context.cpp
View File

@@ -18,7 +18,6 @@
#include <gtest/gtest.h>
#include <cmath>
#include <errno.h>
namespace {
@@ -434,14 +433,15 @@ bool DrmMockPrelimContext::handlePrelimQueryItem(void *arg) {
case PRELIM_DRM_I915_QUERY_COMPUTE_SUBSLICES: {
auto &gtSystemInfo = rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo;
auto maxEuPerSubslice = gtSystemInfo.MaxEuPerSubSlice;
auto maxSlices = gtSystemInfo.MaxSlicesSupported;
auto maxSubslices = gtSystemInfo.MaxSubSlicesSupported / maxSlices;
auto threadsPerEu = gtSystemInfo.ThreadCount / gtSystemInfo.EUCount;
auto realEuCount = threadsPerEu * maxEuPerSubslice * maxSubslices * maxSlices;
const uint16_t subslicesPerSlice = gtSystemInfo.MaxSubSlicesSupported / gtSystemInfo.MaxSlicesSupported;
const uint16_t eusPerSubslice = gtSystemInfo.MaxEuPerSubSlice;
const uint16_t threadsPerEu = gtSystemInfo.ThreadCount / gtSystemInfo.EUCount;
const uint16_t subsliceOffset = static_cast<uint16_t>(Math::divideAndRoundUp(gtSystemInfo.MaxSlicesSupported, 8u));
const uint16_t subsliceStride = static_cast<uint16_t>(Math::divideAndRoundUp(subslicesPerSlice, 8u));
const uint16_t euOffset = subsliceOffset + gtSystemInfo.MaxSlicesSupported * subsliceStride;
const uint16_t euStride = static_cast<uint16_t>(Math::divideAndRoundUp(eusPerSubslice, 8u));
auto dataSize = static_cast<size_t>(std::ceil(realEuCount / 8.0)) + maxSlices * static_cast<uint16_t>(std::ceil(maxSubslices / 8.0)) +
static_cast<uint16_t>(std::ceil(maxSlices / 8.0));
const uint16_t dataSize = euOffset + gtSystemInfo.MaxSubSlicesSupported * euStride;
if (queryItem->length == 0) {
queryItem->length = static_cast<int32_t>(sizeof(QueryTopologyInfo) + dataSize);
@@ -451,21 +451,20 @@ bool DrmMockPrelimContext::handlePrelimQueryItem(void *arg) {
if (failRetTopology) {
return false;
}
topologyArg->maxSlices = maxSlices;
topologyArg->maxSubslices = maxSubslices;
topologyArg->maxEusPerSubslice = maxEuPerSubslice;
topologyArg->subsliceStride = static_cast<uint16_t>(std::ceil(maxSubslices / 8.0));
topologyArg->euStride = static_cast<uint16_t>(std::ceil(maxEuPerSubslice / 8.0));
topologyArg->subsliceOffset = static_cast<uint16_t>(std::ceil(maxSlices / 8.0));
topologyArg->euOffset = static_cast<uint16_t>(std::ceil(maxSubslices / 8.0)) * maxSlices;
topologyArg->maxSlices = gtSystemInfo.MaxSlicesSupported;
topologyArg->maxSubslices = subslicesPerSlice;
topologyArg->maxEusPerSubslice = eusPerSubslice;
topologyArg->subsliceOffset = subsliceOffset;
topologyArg->subsliceStride = subsliceStride;
topologyArg->euOffset = euOffset;
topologyArg->euStride = euStride;
int threadData = (threadsPerEu == 8) ? 0xff : 0x7f;
uint8_t *data = topologyArg->data;
for (uint32_t sliceId = 0; sliceId < maxSlices; sliceId++) {
for (uint32_t sliceId = 0; sliceId < gtSystemInfo.MaxSlicesSupported; sliceId++) {
data[0] |= 1 << (sliceId % 8);
if (sliceId == 7 || sliceId == maxSlices - 1) {
if (((sliceId + 1) % 8) == 0 || sliceId == gtSystemInfo.MaxSlicesSupported - 1) {
data++;
}
}
@@ -473,11 +472,11 @@ bool DrmMockPrelimContext::handlePrelimQueryItem(void *arg) {
DEBUG_BREAK_IF(ptrDiff(data, topologyArg->data) != topologyArg->subsliceOffset);
data = ptrOffset(topologyArg->data, topologyArg->subsliceOffset);
for (uint32_t sliceId = 0; sliceId < maxSlices; sliceId++) {
for (uint32_t i = 0; i < maxSubslices; i++) {
for (uint32_t sliceId = 0; sliceId < gtSystemInfo.MaxSlicesSupported; sliceId++) {
for (uint32_t i = 0; i < subslicesPerSlice; i++) {
data[0] |= 1 << (i % 8);
if (i == 7 || i == maxSubslices - 1) {
if (((i + 1) % 8) == 0 || i == static_cast<uint32_t>(subslicesPerSlice) - 1) {
data++;
}
}

83
shared/test/unit_test/os_interface/linux/drm_query_topology_prelim_tests.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/os_interface/linux/engine_info.h"
#include "shared/source/os_interface/os_interface.h"
@@ -19,8 +20,6 @@
#include "gtest/gtest.h"
#include <cmath>
TEST(DrmQueryTopologyTest, givenDrmWhenQueryTopologyCalledThenPassNoFlags) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
@@ -51,8 +50,22 @@ struct QueryTopologyTests : ::testing::Test {
return false;
}
auto realEuCount = std::max(static_cast<uint32_t>(queryComputeSlicesEuCount / queryComputeSlicesSSCount), rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.EUCount);
auto dataSize = static_cast<size_t>(std::ceil(realEuCount / 8.0));
// Values cannot exceed what this GT allows
queryComputeSlicesSCount = std::min(queryComputeSlicesSCount, static_cast<uint16_t>(rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.SliceCount));
queryComputeSlicesSSCount = std::min(queryComputeSlicesSSCount, static_cast<uint16_t>(rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.SubSliceCount));
queryComputeSlicesEuCount = std::min(queryComputeSlicesEuCount, static_cast<uint16_t>(rootDeviceEnvironment.getHardwareInfo()->gtSystemInfo.EUCount));
UNRECOVERABLE_IF((queryComputeSlicesSCount != 0) && (queryComputeSlicesSSCount % queryComputeSlicesSCount != 0));
UNRECOVERABLE_IF((queryComputeSlicesSSCount != 0) && (queryComputeSlicesEuCount % queryComputeSlicesSSCount != 0));
uint16_t subslicesPerSlice = queryComputeSlicesSCount ? (queryComputeSlicesSSCount / queryComputeSlicesSCount) : 0u;
uint16_t eusPerSubslice = queryComputeSlicesSSCount ? (queryComputeSlicesEuCount / queryComputeSlicesSSCount) : 0u;
uint16_t subsliceOffset = static_cast<uint16_t>(Math::divideAndRoundUp(queryComputeSlicesSCount, 8u));
uint16_t subsliceStride = static_cast<uint16_t>(Math::divideAndRoundUp(subslicesPerSlice, 8u));
uint16_t euOffset = subsliceOffset + queryComputeSlicesSCount * subsliceStride;
uint16_t euStride = static_cast<uint16_t>(Math::divideAndRoundUp(eusPerSubslice, 8u));
const uint16_t dataSize = euOffset + queryComputeSlicesSSCount * euStride;
if (queryItem->length == 0) {
queryItem->length = static_cast<int32_t>(sizeof(QueryTopologyInfo) + dataSize);
@@ -64,14 +77,33 @@ struct QueryTopologyTests : ::testing::Test {
uint16_t finalEUVal = queryComputeSlicesEuCount;
if (useSmallerValuesOnSecondCall && queryComputeSlicesCallCount == 2) {
finalSVal /= 2;
finalSSVal /= 2;
finalEUVal /= 2;
if ((finalSSVal % 2 == 0) && (finalEUVal % 2 == 0)) {
finalSSVal /= 2;
finalEUVal /= 2;
} else if ((finalSSVal % 3 == 0) && (finalEUVal % 3 == 0)) {
finalSSVal /= 3;
finalEUVal /= 3;
} else {
finalSVal = 1;
finalSSVal = subslicesPerSlice;
finalEUVal = subslicesPerSlice * eusPerSubslice;
}
subslicesPerSlice = finalSVal ? (finalSSVal / finalSVal) : 0u;
eusPerSubslice = finalSSVal ? (finalEUVal / finalSSVal) : 0u;
subsliceOffset = static_cast<uint16_t>(Math::divideAndRoundUp(finalSVal, 8u));
subsliceStride = static_cast<uint16_t>(Math::divideAndRoundUp(subslicesPerSlice, 8u));
euOffset = subsliceOffset + finalSVal * subsliceStride;
euStride = static_cast<uint16_t>(Math::divideAndRoundUp(eusPerSubslice, 8u));
}
topologyArg->maxSlices = finalSVal;
topologyArg->maxSubslices = (finalSSVal / finalSVal);
topologyArg->maxEusPerSubslice = (finalEUVal / finalSSVal);
topologyArg->maxSubslices = subslicesPerSlice;
topologyArg->maxEusPerSubslice = eusPerSubslice;
topologyArg->subsliceOffset = subsliceOffset;
topologyArg->subsliceStride = subsliceStride;
topologyArg->euOffset = euOffset;
topologyArg->euStride = euStride;
memset(topologyArg->data, 0xFF, dataSize);
}
@@ -102,13 +134,14 @@ struct QueryTopologyTests : ::testing::Test {
drmMock = std::make_unique<MyDrmQueryMock>(*rootDeviceEnvironment);
drmMock->storedSVal = 8;
drmMock->storedSSVal = 32;
drmMock->storedEUVal = 512;
drmMock->storedSVal = rootDeviceEnvironment->getHardwareInfo()->gtSystemInfo.SliceCount;
drmMock->storedSSVal = rootDeviceEnvironment->getHardwareInfo()->gtSystemInfo.SubSliceCount;
drmMock->storedEUVal = rootDeviceEnvironment->getHardwareInfo()->gtSystemInfo.EUCount;
drmMock->queryComputeSlicesSCount = rootDeviceEnvironment->getHardwareInfo()->gtSystemInfo.SliceCount;
drmMock->queryComputeSlicesSSCount = rootDeviceEnvironment->getHardwareInfo()->gtSystemInfo.SubSliceCount;
drmMock->queryComputeSlicesEuCount = rootDeviceEnvironment->getHardwareInfo()->gtSystemInfo.EUCount;
drmMock->queryComputeSlicesSCount = 4;
drmMock->queryComputeSlicesSSCount = 16;
drmMock->queryComputeSlicesEuCount = 256;
drmMock->memoryInfoQueried = false;
EXPECT_TRUE(drmMock->queryMemoryInfo());
EXPECT_TRUE(drmMock->queryEngineInfo());
@@ -244,9 +277,19 @@ TEST_F(QueryTopologyTests, givenAsymetricTilesWhenQueryingThenPickSmallerValue)
DrmQueryTopologyData topologyData = {};
drmMock->queryTopology(*rootDeviceEnvironment->getHardwareInfo(), topologyData);
EXPECT_EQ(drmMock->queryComputeSlicesSCount / 2, topologyData.sliceCount);
EXPECT_EQ(drmMock->queryComputeSlicesSSCount / 2, topologyData.subSliceCount);
EXPECT_EQ(drmMock->queryComputeSlicesEuCount / 2, topologyData.euCount);
EXPECT_NE(0, drmMock->queryComputeSlicesSCount);
EXPECT_NE(0, topologyData.sliceCount);
EXPECT_LE(topologyData.sliceCount, drmMock->queryComputeSlicesSCount);
if ((drmMock->queryComputeSlicesSSCount % 2 == 0) && (drmMock->queryComputeSlicesEuCount % 2 == 0)) {
EXPECT_EQ(drmMock->queryComputeSlicesSSCount / 2, topologyData.subSliceCount);
EXPECT_EQ(drmMock->queryComputeSlicesEuCount / 2, topologyData.euCount);
} else if ((drmMock->queryComputeSlicesSSCount % 3 == 0) && (drmMock->queryComputeSlicesEuCount % 3 == 0)) {
EXPECT_EQ(drmMock->queryComputeSlicesSSCount / 3, topologyData.subSliceCount);
EXPECT_EQ(drmMock->queryComputeSlicesEuCount / 3, topologyData.euCount);
} else {
EXPECT_EQ(drmMock->queryComputeSlicesSSCount / drmMock->queryComputeSlicesSCount, topologyData.subSliceCount);
EXPECT_EQ(drmMock->queryComputeSlicesEuCount / drmMock->queryComputeSlicesSSCount * topologyData.subSliceCount, topologyData.euCount);
}
EXPECT_EQ(drmMock->queryComputeSlicesSCount, topologyData.maxSlices);
EXPECT_EQ(drmMock->queryComputeSlicesSSCount / drmMock->queryComputeSlicesSCount, topologyData.maxSubSlicesPerSlice);
@@ -264,8 +307,8 @@ TEST_F(QueryTopologyTests, givenAsymetricTilesWhenGettingSliceMappingsThenCorrec
auto device0SliceMapping = drmMock->getSliceMappings(0);
auto device1SliceMapping = drmMock->getSliceMappings(1);
ASSERT_EQ(static_cast<size_t>(drmMock->queryComputeSlicesSCount / 2), device0SliceMapping.size());
for (int i = 0; i < drmMock->queryComputeSlicesSCount / 2; i++) {
ASSERT_GE(static_cast<size_t>(drmMock->queryComputeSlicesSCount), device0SliceMapping.size());
for (int i = 0; i < static_cast<int>(device0SliceMapping.size()); i++) {
EXPECT_EQ(i, device0SliceMapping[i]);
}

114
shared/test/unit_test/os_interface/linux/drm_tests.cpp
View File

@@ -973,25 +973,68 @@ TEST(DrmQueryTest, GivenDrmWhenSetupHardwareInfoCalledThenCorrectMaxValuesInGtSy
TEST(DrmQueryTest, GivenLessAvailableSubSlicesThanMaxSubSlicesWhenQueryingTopologyInfoThenCorrectMaxSubSliceCountIsSet) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get();
auto hwInfo = *NEO::defaultHwInfo.get();
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = hwInfo;
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
drm.disableSomeTopology = true;
DrmQueryTopologyData topologyData = {};
drm.storedSVal = 4;
drm.storedSSVal = drm.storedSVal * 7;
drm.storedEUVal = drm.storedSSVal * 4;
drm.storedSVal = hwInfo.gtSystemInfo.MaxSlicesSupported;
drm.storedSSVal = hwInfo.gtSystemInfo.MaxSubSlicesSupported;
drm.storedEUVal = hwInfo.gtSystemInfo.MaxSubSlicesSupported * hwInfo.gtSystemInfo.MaxEuPerSubSlice;
drm.engineInfoQueried = true;
drm.systemInfoQueried = true;
EXPECT_TRUE(drm.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData));
const auto ret = drm.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData);
EXPECT_EQ(2, topologyData.sliceCount);
EXPECT_EQ(6, topologyData.subSliceCount);
EXPECT_EQ(12, topologyData.euCount);
const uint8_t topologyBitMask = 0b11000110;
EXPECT_EQ(drm.storedSVal, topologyData.maxSlices);
EXPECT_EQ(7, topologyData.maxSubSlicesPerSlice);
int actualSliceCount = 0;
for (int i = 0; i < drm.storedSVal; i++) {
const uint8_t mask = 0b1 << (i % 8);
if ((topologyBitMask & mask) != 0) {
actualSliceCount++;
}
}
int actualSubSliceCount = 0;
for (int i = 0; i < actualSliceCount; i++) {
for (int j = 0; j < drm.storedSSVal / drm.storedSVal; j++) {
const uint8_t mask = 0b1 << (j % 8);
if ((topologyBitMask & mask) != 0) {
actualSubSliceCount++;
}
}
}
int actualEUCount = 0;
for (int i = 0; i < actualSubSliceCount; i++) {
for (int j = 0; j < drm.storedEUVal / drm.storedSSVal; j++) {
const uint8_t mask = 0b1 << (j % 8);
if ((topologyBitMask & mask) != 0) {
actualEUCount++;
}
}
}
EXPECT_GT(drm.storedSVal, actualSliceCount);
EXPECT_GT(drm.storedSSVal, actualSubSliceCount);
EXPECT_GT(drm.storedEUVal, actualEUCount);
if (drm.storedSVal > 1) {
EXPECT_TRUE(ret);
EXPECT_LE(topologyData.maxSlices, static_cast<int>(hwInfo.gtSystemInfo.MaxSubSlicesSupported));
EXPECT_LE(topologyData.maxSubSlicesPerSlice, static_cast<int>(hwInfo.gtSystemInfo.MaxSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported));
} else {
EXPECT_FALSE(ret);
EXPECT_EQ(topologyData.maxSlices, 0);
EXPECT_EQ(topologyData.maxSubSlicesPerSlice, 0);
}
EXPECT_EQ(topologyData.sliceCount, actualSliceCount);
EXPECT_EQ(topologyData.subSliceCount, actualSubSliceCount);
EXPECT_EQ(topologyData.euCount, actualEUCount);
EXPECT_EQ(topologyData.maxEusPerSubSlice, static_cast<int>(hwInfo.gtSystemInfo.MaxEuPerSubSlice));
}
TEST(DrmQueryTest, givenDrmWhenGettingTopologyMapThenCorrectMapIsReturned) {
@@ -1018,31 +1061,37 @@ TEST(DrmQueryTest, givenDrmWhenGettingTopologyMapThenCorrectMapIsReturned) {
TEST(DrmQueryTest, GivenSingleSliceConfigWhenQueryingTopologyInfoThenSubsliceIndicesAreStored) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get();
auto hwInfo = *NEO::defaultHwInfo.get();
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = hwInfo;
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
DrmQueryTopologyData topologyData = {};
drm.storedSVal = 1;
drm.storedSSVal = drm.storedSVal * 7;
drm.storedEUVal = drm.storedSSVal * 4;
drm.storedSVal = hwInfo.gtSystemInfo.MaxSlicesSupported;
drm.storedSSVal = hwInfo.gtSystemInfo.MaxSubSlicesSupported;
drm.storedEUVal = hwInfo.gtSystemInfo.MaxSubSlicesSupported * hwInfo.gtSystemInfo.MaxEuPerSubSlice;
drm.engineInfoQueried = true;
drm.systemInfoQueried = true;
EXPECT_TRUE(drm.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData));
EXPECT_EQ(1, topologyData.sliceCount);
EXPECT_EQ(7, topologyData.subSliceCount);
EXPECT_EQ(28, topologyData.euCount);
EXPECT_EQ(topologyData.sliceCount, static_cast<int>(hwInfo.gtSystemInfo.MaxSlicesSupported));
EXPECT_EQ(topologyData.subSliceCount, static_cast<int>(hwInfo.gtSystemInfo.MaxSubSlicesSupported));
EXPECT_EQ(topologyData.euCount, static_cast<int>(hwInfo.gtSystemInfo.MaxSubSlicesSupported * hwInfo.gtSystemInfo.MaxEuPerSubSlice));
EXPECT_EQ(drm.storedSVal, topologyData.maxSlices);
EXPECT_EQ(7, topologyData.maxSubSlicesPerSlice);
EXPECT_EQ(topologyData.maxSlices, drm.storedSVal);
EXPECT_EQ(topologyData.maxSubSlicesPerSlice, static_cast<int>(hwInfo.gtSystemInfo.MaxSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported));
auto topologyMap = drm.getTopologyMap();
for (uint32_t i = 0; i < topologyMap.size(); i++) {
EXPECT_EQ(drm.storedSVal, static_cast<int>(topologyMap.at(i).sliceIndices.size()));
EXPECT_EQ(7u, topologyMap.at(i).subsliceIndices.size());
if (drm.storedSVal == 1) {
EXPECT_EQ(static_cast<size_t>(hwInfo.gtSystemInfo.MaxSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported), topologyMap.at(i).subsliceIndices.size());
} else {
EXPECT_EQ(0u, topologyMap.at(i).subsliceIndices.size());
}
for (int subsliceId = 0; subsliceId < static_cast<int>(topologyMap.at(i).subsliceIndices.size()); subsliceId++) {
EXPECT_EQ(subsliceId, topologyMap.at(i).subsliceIndices[subsliceId]);
}
@@ -1052,31 +1101,36 @@ TEST(DrmQueryTest, GivenSingleSliceConfigWhenQueryingTopologyInfoThenSubsliceInd
TEST(DrmQueryTest, GivenMultiSliceConfigWhenQueryingTopologyInfoThenSubsliceIndicesAreNotStored) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get();
auto hwInfo = *NEO::defaultHwInfo.get();
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = hwInfo;
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
DrmQueryTopologyData topologyData = {};
drm.storedSVal = 2;
drm.storedSSVal = drm.storedSVal * 7;
drm.storedEUVal = drm.storedSSVal * 4;
drm.storedSVal = hwInfo.gtSystemInfo.MaxSlicesSupported;
drm.storedSSVal = hwInfo.gtSystemInfo.MaxSubSlicesSupported;
drm.storedEUVal = hwInfo.gtSystemInfo.MaxSubSlicesSupported * hwInfo.gtSystemInfo.MaxEuPerSubSlice;
drm.engineInfoQueried = true;
drm.systemInfoQueried = true;
EXPECT_TRUE(drm.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData));
EXPECT_EQ(2, topologyData.sliceCount);
EXPECT_EQ(14, topologyData.subSliceCount);
EXPECT_EQ(56, topologyData.euCount);
EXPECT_EQ(topologyData.sliceCount, static_cast<int>(hwInfo.gtSystemInfo.MaxSlicesSupported));
EXPECT_EQ(topologyData.subSliceCount, static_cast<int>(hwInfo.gtSystemInfo.MaxSubSlicesSupported));
EXPECT_EQ(topologyData.euCount, static_cast<int>(hwInfo.gtSystemInfo.MaxSubSlicesSupported * hwInfo.gtSystemInfo.MaxEuPerSubSlice));
EXPECT_EQ(drm.storedSVal, topologyData.maxSlices);
EXPECT_EQ(7, topologyData.maxSubSlicesPerSlice);
EXPECT_EQ(topologyData.maxSlices, static_cast<int>(drm.storedSVal));
EXPECT_EQ(topologyData.maxSubSlicesPerSlice, static_cast<int>(hwInfo.gtSystemInfo.MaxSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported));
auto topologyMap = drm.getTopologyMap();
for (uint32_t i = 0; i < topologyMap.size(); i++) {
EXPECT_EQ(drm.storedSVal, static_cast<int>(topologyMap.at(i).sliceIndices.size()));
EXPECT_EQ(0u, topologyMap.at(i).subsliceIndices.size());
if (drm.storedSVal > 1) {
EXPECT_EQ(0u, topologyMap.at(i).subsliceIndices.size());
} else {
EXPECT_EQ(static_cast<size_t>(topologyData.maxSubSlicesPerSlice), topologyMap.at(i).subsliceIndices.size());
}
}
}