1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
/*
* Copyright (C) 2018-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/os_interface/product_helper.h"
#include <algorithm>
namespace NEO {
GfxCoreHelperCreateFunctionType gfxCoreHelperFactory[IGFX_MAX_CORE] = {};
std::unique_ptr<GfxCoreHelper> GfxCoreHelper::create(const GFXCORE_FAMILY gfxCoreFamily) {
auto createFunction = gfxCoreHelperFactory[gfxCoreFamily];
if (createFunction == nullptr) {
return nullptr;
}
auto gfxCoreHelper = createFunction();
return gfxCoreHelper;
}
bool GfxCoreHelper::compressedBuffersSupported(const HardwareInfo &hwInfo) {
if (debugManager.flags.RenderCompressedBuffersEnabled.get() != -1) {
return !!debugManager.flags.RenderCompressedBuffersEnabled.get();
}
return hwInfo.capabilityTable.ftrRenderCompressedBuffers;
}
bool GfxCoreHelper::compressedImagesSupported(const HardwareInfo &hwInfo) {
if (debugManager.flags.RenderCompressedImagesEnabled.get() != -1) {
return !!debugManager.flags.RenderCompressedImagesEnabled.get();
}
return hwInfo.capabilityTable.ftrRenderCompressedImages;
}
bool GfxCoreHelper::cacheFlushAfterWalkerSupported(const HardwareInfo &hwInfo) {
int32_t dbgFlag = debugManager.flags.EnableCacheFlushAfterWalker.get();
if (dbgFlag == 1) {
return true;
} else if (dbgFlag == 0) {
return false;
}
return hwInfo.capabilityTable.supportCacheFlushAfterWalker;
}
uint32_t GfxCoreHelper::getMaxThreadsForVfe(const HardwareInfo &hwInfo) {
uint32_t threadsPerEU = hwInfo.gtSystemInfo.NumThreadsPerEu + hwInfo.capabilityTable.extraQuantityThreadsPerEU;
auto maxHwThreadsCapable = hwInfo.gtSystemInfo.EUCount * threadsPerEU;
auto maxHwThreadsReturned = maxHwThreadsCapable;
if (debugManager.flags.MaxHwThreadsPercent.get() != 0) {
maxHwThreadsReturned = int(maxHwThreadsCapable * (debugManager.flags.MaxHwThreadsPercent.get() / 100.0f));
}
if (debugManager.flags.MinHwThreadsUnoccupied.get() != 0) {
maxHwThreadsReturned = std::min(maxHwThreadsReturned, maxHwThreadsCapable - debugManager.flags.MinHwThreadsUnoccupied.get());
}
return maxHwThreadsReturned;
}
uint32_t GfxCoreHelper::getSubDevicesCount(const HardwareInfo *pHwInfo) {
if (debugManager.flags.CreateMultipleSubDevices.get() > 0) {
return debugManager.flags.CreateMultipleSubDevices.get();
} else if (pHwInfo->gtSystemInfo.MultiTileArchInfo.IsValid && pHwInfo->gtSystemInfo.MultiTileArchInfo.TileCount > 0u) {
return pHwInfo->gtSystemInfo.MultiTileArchInfo.TileCount;
} else {
return 1u;
}
}
uint32_t GfxCoreHelper::getHighestEnabledSlice(const HardwareInfo &hwInfo) {
uint32_t highestEnabledSlice = 1;
if (!hwInfo.gtSystemInfo.IsDynamicallyPopulated) {
return hwInfo.gtSystemInfo.MaxSlicesSupported;
}
for (int highestSlice = GT_MAX_SLICE - 1; highestSlice >= 0; highestSlice--) {
if (hwInfo.gtSystemInfo.SliceInfo[highestSlice].Enabled) {
highestEnabledSlice = highestSlice + 1;
break;
}
}
return highestEnabledSlice;
}
uint32_t GfxCoreHelper::getHighestEnabledSubSliceOnAnySlice(const HardwareInfo &hwInfo) {
if (!hwInfo.gtSystemInfo.IsDynamicallyPopulated) {
return 0;
}
uint32_t highestSubSlice = 0;
for (uint32_t sliceId = 0; sliceId < GT_MAX_SLICE; sliceId++) {
for (uint32_t subSliceId = 0; subSliceId < GT_MAX_SUBSLICE_PER_SLICE; subSliceId++) {
if (hwInfo.gtSystemInfo.SliceInfo[sliceId].SubSliceInfo[subSliceId].Enabled) {
highestSubSlice = std::max(highestSubSlice, subSliceId);
}
}
}
return highestSubSlice;
}
uint32_t getHighestEnabledSubSlice(const HardwareInfo &hwInfo) {
uint32_t numSubSlicesPerSlice = hwInfo.gtSystemInfo.MaxSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported;
uint32_t highestEnabledSliceIdx = GfxCoreHelper::getHighestEnabledSlice(hwInfo) - 1;
uint32_t highestSubSlice = (highestEnabledSliceIdx + 1) * numSubSlicesPerSlice;
for (int32_t subSliceId = GT_MAX_SUBSLICE_PER_SLICE - 1; subSliceId >= 0; subSliceId--) {
if (hwInfo.gtSystemInfo.SliceInfo[highestEnabledSliceIdx].SubSliceInfo[subSliceId].Enabled) {
return highestEnabledSliceIdx * numSubSlicesPerSlice + subSliceId + 1;
}
}
return highestSubSlice;
}
uint32_t GfxCoreHelper::getHighestEnabledDualSubSlice(const HardwareInfo &hwInfo) {
uint32_t maxDualSubSlicesSupported = hwInfo.gtSystemInfo.MaxDualSubSlicesSupported;
if (!hwInfo.gtSystemInfo.IsDynamicallyPopulated) {
return maxDualSubSlicesSupported;
}
if (maxDualSubSlicesSupported == 0) {
return getHighestEnabledSubSlice(hwInfo);
}
uint32_t numDssPerSlice = maxDualSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported;
uint32_t highestEnabledSliceIdx = getHighestEnabledSlice(hwInfo) - 1;
uint32_t highestDualSubSlice = (highestEnabledSliceIdx + 1) * numDssPerSlice;
for (int32_t dssID = GT_MAX_DUALSUBSLICE_PER_SLICE - 1; dssID >= 0; dssID--) {
if (hwInfo.gtSystemInfo.SliceInfo[highestEnabledSliceIdx].DSSInfo[dssID].Enabled) {
return (highestEnabledSliceIdx * numDssPerSlice) + dssID + 1;
}
}
return highestDualSubSlice;
}
bool GfxCoreHelper::isWorkaroundRequired(uint32_t lowestSteppingWithBug, uint32_t steppingWithFix, const HardwareInfo &hwInfo, const ProductHelper &productHelper) {
auto lowestHwRevIdWithBug = productHelper.getHwRevIdFromStepping(lowestSteppingWithBug, hwInfo);
auto hwRevIdWithFix = productHelper.getHwRevIdFromStepping(steppingWithFix, hwInfo);
if ((lowestHwRevIdWithBug == CommonConstants::invalidStepping) || (hwRevIdWithFix == CommonConstants::invalidStepping)) {
return false;
}
return (lowestHwRevIdWithBug <= hwInfo.platform.usRevId && hwInfo.platform.usRevId < hwRevIdWithFix);
}
} // namespace NEO
|
