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

Improve ftr/wa flags packing

Browse Source 
Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>
This commit is contained in:
Bartosz Dunajski
2021-11-25 09:31:14 +00:00
committed by Compute-Runtime-Automation
parent 1da896bee0
commit 995cb88bfa
160 changed files with 1777 additions and 1765 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
shared/source/command_stream/command_stream_receiver.cpp
View File

@@ -623,7 +623,7 @@ bool CommandStreamReceiver::createPreemptionAllocation() {
preemptionSurfaceSize = DebugManager.flags.OverrideCsrAllocationSize.get();
}
AllocationProperties properties{rootDeviceIndex, true, preemptionSurfaceSize, GraphicsAllocation::AllocationType::PREEMPTION, isMultiOsContextCapable(), false, deviceBitfield};
properties.flags.uncacheable = hwInfo->workaroundTable.waCSRUncachable;
properties.flags.uncacheable = hwInfo->workaroundTable.flags.waCSRUncachable;
properties.alignment = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getPreemptionAllocationAlignment();
this->preemptionAllocation = getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
return this->preemptionAllocation != nullptr;

4
shared/source/command_stream/command_stream_receiver_hw_base.inl
View File

@@ -446,7 +446,7 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
DBG_LOG(LogTaskCounts, __FUNCTION__, "Line: ", __LINE__, "this->taskLevel", (uint32_t)this->taskLevel);
if (executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->workaroundTable.waSamplerCacheFlushBetweenRedescribedSurfaceReads) {
if (executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->workaroundTable.flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads) {
if (this->samplerCacheFlushRequired != SamplerCacheFlushState::samplerCacheFlushNotRequired) {
PipeControlArgs args;
args.textureCacheInvalidationEnable = true;
@@ -811,7 +811,7 @@ size_t CommandStreamReceiverHw<GfxFamily>::getRequiredCmdStreamSize(const Dispat
size += getCmdSizeForActivePartitionConfig();
}
if (executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->workaroundTable.waSamplerCacheFlushBetweenRedescribedSurfaceReads) {
if (executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->workaroundTable.flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads) {
if (this->samplerCacheFlushRequired != SamplerCacheFlushState::samplerCacheFlushNotRequired) {
size += sizeof(typename GfxFamily::PIPE_CONTROL);
}

4
shared/source/command_stream/preemption.cpp
View File

@@ -86,8 +86,8 @@ PreemptionFlags PreemptionHelper::createPreemptionLevelFlags(Device &device, con
flags.flags.schedulerKernel = schedulerKernel;
}
flags.flags.deviceSupportsVmePreemption = device.getDeviceInfo().vmeAvcSupportsPreemption;
flags.flags.disablePerCtxtPreemptionGranularityControl = device.getHardwareInfo().workaroundTable.waDisablePerCtxtPreemptionGranularityControl;
flags.flags.disableLSQCROPERFforOCL = device.getHardwareInfo().workaroundTable.waDisableLSQCROPERFforOCL;
flags.flags.disablePerCtxtPreemptionGranularityControl = device.getHardwareInfo().workaroundTable.flags.waDisablePerCtxtPreemptionGranularityControl;
flags.flags.disableLSQCROPERFforOCL = device.getHardwareInfo().workaroundTable.flags.waDisableLSQCROPERFforOCL;
return flags;
}

46
shared/source/compiler_interface/compiler_interface.cpp
View File

@@ -429,36 +429,36 @@ IGC::IgcOclDeviceCtxTagOCL *CompilerInterface::getIgcDeviceCtx(const Device &dev
IGC::PlatformHelper::PopulateInterfaceWith(*igcPlatform, hwInfo->platform);
IGC::GtSysInfoHelper::PopulateInterfaceWith(*igcGtSystemInfo, hwInfo->gtSystemInfo);
igcFeWa.get()->SetFtrDesktop(device.getHardwareInfo().featureTable.ftrDesktop);
igcFeWa.get()->SetFtrChannelSwizzlingXOREnabled(device.getHardwareInfo().featureTable.ftrChannelSwizzlingXOREnabled);
igcFeWa.get()->SetFtrDesktop(device.getHardwareInfo().featureTable.flags.ftrDesktop);
igcFeWa.get()->SetFtrChannelSwizzlingXOREnabled(device.getHardwareInfo().featureTable.flags.ftrChannelSwizzlingXOREnabled);
igcFeWa.get()->SetFtrGtBigDie(device.getHardwareInfo().featureTable.ftrGtBigDie);
igcFeWa.get()->SetFtrGtMediumDie(device.getHardwareInfo().featureTable.ftrGtMediumDie);
igcFeWa.get()->SetFtrGtSmallDie(device.getHardwareInfo().featureTable.ftrGtSmallDie);
igcFeWa.get()->SetFtrGtBigDie(device.getHardwareInfo().featureTable.flags.ftrGtBigDie);
igcFeWa.get()->SetFtrGtMediumDie(device.getHardwareInfo().featureTable.flags.ftrGtMediumDie);
igcFeWa.get()->SetFtrGtSmallDie(device.getHardwareInfo().featureTable.flags.ftrGtSmallDie);
igcFeWa.get()->SetFtrGT1(device.getHardwareInfo().featureTable.ftrGT1);
igcFeWa.get()->SetFtrGT1_5(device.getHardwareInfo().featureTable.ftrGT1_5);
igcFeWa.get()->SetFtrGT2(device.getHardwareInfo().featureTable.ftrGT2);
igcFeWa.get()->SetFtrGT3(device.getHardwareInfo().featureTable.ftrGT3);
igcFeWa.get()->SetFtrGT4(device.getHardwareInfo().featureTable.ftrGT4);
igcFeWa.get()->SetFtrGT1(device.getHardwareInfo().featureTable.flags.ftrGT1);
igcFeWa.get()->SetFtrGT1_5(device.getHardwareInfo().featureTable.flags.ftrGT1_5);
igcFeWa.get()->SetFtrGT2(device.getHardwareInfo().featureTable.flags.ftrGT2);
igcFeWa.get()->SetFtrGT3(device.getHardwareInfo().featureTable.flags.ftrGT3);
igcFeWa.get()->SetFtrGT4(device.getHardwareInfo().featureTable.flags.ftrGT4);
igcFeWa.get()->SetFtrIVBM0M1Platform(device.getHardwareInfo().featureTable.ftrIVBM0M1Platform);
igcFeWa.get()->SetFtrGTL(device.getHardwareInfo().featureTable.ftrGT1);
igcFeWa.get()->SetFtrGTM(device.getHardwareInfo().featureTable.ftrGT2);
igcFeWa.get()->SetFtrGTH(device.getHardwareInfo().featureTable.ftrGT3);
igcFeWa.get()->SetFtrIVBM0M1Platform(device.getHardwareInfo().featureTable.flags.ftrIVBM0M1Platform);
igcFeWa.get()->SetFtrGTL(device.getHardwareInfo().featureTable.flags.ftrGT1);
igcFeWa.get()->SetFtrGTM(device.getHardwareInfo().featureTable.flags.ftrGT2);
igcFeWa.get()->SetFtrGTH(device.getHardwareInfo().featureTable.flags.ftrGT3);
igcFeWa.get()->SetFtrSGTPVSKUStrapPresent(device.getHardwareInfo().featureTable.ftrSGTPVSKUStrapPresent);
igcFeWa.get()->SetFtrGTA(device.getHardwareInfo().featureTable.ftrGTA);
igcFeWa.get()->SetFtrGTC(device.getHardwareInfo().featureTable.ftrGTC);
igcFeWa.get()->SetFtrGTX(device.getHardwareInfo().featureTable.ftrGTX);
igcFeWa.get()->SetFtr5Slice(device.getHardwareInfo().featureTable.ftr5Slice);
igcFeWa.get()->SetFtrSGTPVSKUStrapPresent(device.getHardwareInfo().featureTable.flags.ftrSGTPVSKUStrapPresent);
igcFeWa.get()->SetFtrGTA(device.getHardwareInfo().featureTable.flags.ftrGTA);
igcFeWa.get()->SetFtrGTC(device.getHardwareInfo().featureTable.flags.ftrGTC);
igcFeWa.get()->SetFtrGTX(device.getHardwareInfo().featureTable.flags.ftrGTX);
igcFeWa.get()->SetFtr5Slice(device.getHardwareInfo().featureTable.flags.ftr5Slice);
igcFeWa.get()->SetFtrGpGpuMidThreadLevelPreempt(CompilerHwInfoConfig::get(hwInfo->platform.eProductFamily)->isMidThreadPreemptionSupported(*hwInfo));
igcFeWa.get()->SetFtrIoMmuPageFaulting(device.getHardwareInfo().featureTable.ftrIoMmuPageFaulting);
igcFeWa.get()->SetFtrWddm2Svm(device.getHardwareInfo().featureTable.ftrWddm2Svm);
igcFeWa.get()->SetFtrPooledEuEnabled(device.getHardwareInfo().featureTable.ftrPooledEuEnabled);
igcFeWa.get()->SetFtrIoMmuPageFaulting(device.getHardwareInfo().featureTable.flags.ftrIoMmuPageFaulting);
igcFeWa.get()->SetFtrWddm2Svm(device.getHardwareInfo().featureTable.flags.ftrWddm2Svm);
igcFeWa.get()->SetFtrPooledEuEnabled(device.getHardwareInfo().featureTable.flags.ftrPooledEuEnabled);
igcFeWa.get()->SetFtrResourceStreamer(device.getHardwareInfo().featureTable.ftrResourceStreamer);
igcFeWa.get()->SetFtrResourceStreamer(device.getHardwareInfo().featureTable.flags.ftrResourceStreamer);
igcDeviceContexts[&device] = std::move(newDeviceCtx);
return igcDeviceContexts[&device].get();

2
shared/source/device/device.cpp
View File

@@ -390,7 +390,7 @@ bool Device::isSimulation() const {
}
}
if (hwInfo.featureTable.ftrSimulationMode) {
if (hwInfo.featureTable.flags.ftrSimulationMode) {
simulation = true;
}
return simulation;

4
shared/source/device/device_caps.cpp
View File

@@ -98,11 +98,11 @@ void Device::initializeCaps() {
? CommonConstants::maximalSimdSize
: hwHelper.getMinimalSIMDSize();
deviceInfo.maxNumEUsPerSubSlice = (systemInfo.EuCountPerPoolMin == 0 || hwInfo.featureTable.ftrPooledEuEnabled == 0)
deviceInfo.maxNumEUsPerSubSlice = (systemInfo.EuCountPerPoolMin == 0 || hwInfo.featureTable.flags.ftrPooledEuEnabled == 0)
? (systemInfo.EUCount / systemInfo.SubSliceCount)
: systemInfo.EuCountPerPoolMin;
if (systemInfo.DualSubSliceCount != 0) {
deviceInfo.maxNumEUsPerDualSubSlice = (systemInfo.EuCountPerPoolMin == 0 || hwInfo.featureTable.ftrPooledEuEnabled == 0)
deviceInfo.maxNumEUsPerDualSubSlice = (systemInfo.EuCountPerPoolMin == 0 || hwInfo.featureTable.flags.ftrPooledEuEnabled == 0)
? (systemInfo.EUCount / systemInfo.DualSubSliceCount)
: systemInfo.EuCountPerPoolMin;

2
shared/source/dll/get_devices.cpp
View File

@@ -29,7 +29,7 @@ bool prepareDeviceEnvironments(ExecutionEnvironment &executionEnvironment, std::
bool unsupportedDeviceDetected = false;
auto &featureTable = executionEnvironment.rootDeviceEnvironments[i]->getHardwareInfo()->featureTable;
if (!featureTable.ftrRcsNode && !featureTable.ftrCCSNode) {
if (!featureTable.flags.ftrRcsNode && !featureTable.flags.ftrCCSNode) {
unsupportedDeviceDetected = true;
}

48
shared/source/gen11/hw_info_ehl.cpp
View File

@@ -90,35 +90,35 @@ void EHL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->ftrDisplayYTiling = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->flags.ftrDisplayYTiling = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuMidThreadLevelPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
};
const HardwareInfo EHL_HW_CONFIG::hwInfo = {

48
shared/source/gen11/hw_info_icllp.cpp
View File

@@ -91,35 +91,35 @@ void ICLLP::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->ftrDisplayYTiling = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->flags.ftrDisplayYTiling = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuMidThreadLevelPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
};
const HardwareInfo ICLLP_1x8x8::hwInfo = {

48
shared/source/gen11/hw_info_lkf.cpp
View File

@@ -90,35 +90,35 @@ void LKF::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->ftrDisplayYTiling = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->flags.ftrDisplayYTiling = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuMidThreadLevelPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
};
const HardwareInfo LKF_1x8x8::hwInfo = {

2
shared/source/gen11/preamble_gen11.cpp
View File

@@ -55,7 +55,7 @@ void PreambleHelper<ICLFamily>::addPipeControlBeforeVfeCmd(LinearStream *pComman
PIPE_CONTROL cmd = ICLFamily::cmdInitPipeControl;
cmd.setCommandStreamerStallEnable(true);
if (hwInfo->workaroundTable.waSendMIFLUSHBeforeVFE) {
if (hwInfo->workaroundTable.flags.waSendMIFLUSHBeforeVFE) {
cmd.setRenderTargetCacheFlushEnable(true);
cmd.setDepthCacheFlushEnable(true);
cmd.setDcFlushEnable(true);

6
shared/source/gen12lp/hw_helper_gen12lp.cpp
View File

@@ -37,7 +37,7 @@ bool HwHelperHw<Family>::isWaDisableRccRhwoOptimizationRequired() const {
template <>
bool HwHelperHw<Family>::isAdditionalFeatureFlagRequired(const FeatureTable *featureTable) const {
return featureTable->ftrGpGpuMidThreadLevelPreempt;
return featureTable->flags.ftrGpGpuMidThreadLevelPreempt;
}
template <>
@@ -50,7 +50,7 @@ uint32_t HwHelperHw<Family>::getComputeUnitsUsedForScratch(const HardwareInfo *p
template <>
bool HwHelperHw<Family>::isLocalMemoryEnabled(const HardwareInfo &hwInfo) const {
return hwInfo.featureTable.ftrLocalMemory;
return hwInfo.featureTable.flags.ftrLocalMemory;
}
template <>
@@ -92,7 +92,7 @@ const EngineInstancesContainer HwHelperHw<Family>::getGpgpuEngineInstances(const
{defaultEngine, EngineUsage::Internal}, // internal usage
};
if (defaultEngine == aub_stream::EngineType::ENGINE_CCS && hwInfo.featureTable.ftrCCSNode && !hwInfo.featureTable.ftrGpGpuMidThreadLevelPreempt) {
if (defaultEngine == aub_stream::EngineType::ENGINE_CCS && hwInfo.featureTable.flags.ftrCCSNode && !hwInfo.featureTable.flags.ftrGpGpuMidThreadLevelPreempt) {
engines.push_back({aub_stream::ENGINE_CCS, EngineUsage::Regular});
}

46
shared/source/gen12lp/hw_info_adlp.cpp
View File

@@ -88,34 +88,34 @@ void ADLP::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = false;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = false;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->waUntypedBufferCompression = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waUntypedBufferCompression = true;
};
const HardwareInfo ADLP_CONFIG::hwInfo = {
&ADLP::platform,

46
shared/source/gen12lp/hw_info_adls.cpp
View File

@@ -88,34 +88,34 @@ void ADLS::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->waUntypedBufferCompression = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waUntypedBufferCompression = true;
};
const HardwareInfo ADLS_HW_CONFIG::hwInfo = {

2
shared/source/gen12lp/hw_info_config_adls.inl
View File

@@ -18,7 +18,7 @@ int HwInfoConfigHw<IGFX_ALDERLAKE_S>::configureHardwareCustom(HardwareInfo *hwIn
GT_SYSTEM_INFO *gtSystemInfo = &hwInfo->gtSystemInfo;
gtSystemInfo->SliceCount = 1;
HwHelper &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
hwInfo->featureTable.ftrGpGpuMidThreadLevelPreempt = (hwInfo->platform.usRevId >= hwHelper.getHwRevIdFromStepping(REVISION_C, *hwInfo));
hwInfo->featureTable.flags.ftrGpGpuMidThreadLevelPreempt = (hwInfo->platform.usRevId >= hwHelper.getHwRevIdFromStepping(REVISION_C, *hwInfo));
return 0;
}

46
shared/source/gen12lp/hw_info_dg1.cpp
View File

@@ -96,35 +96,35 @@ void DG1::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->ftrLocalMemory = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->flags.ftrLocalMemory = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->ftrBcsInfo = maxNBitValue(1);
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
};
const HardwareInfo DG1_CONFIG::hwInfo = {

44
shared/source/gen12lp/hw_info_rkl.cpp
View File

@@ -88,33 +88,33 @@ void RKL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
};
const HardwareInfo RKL_HW_CONFIG::hwInfo = {

46
shared/source/gen12lp/hw_info_tgllp.cpp
View File

@@ -92,34 +92,34 @@ void TGLLP::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->waUntypedBufferCompression = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waUntypedBufferCompression = true;
};
const HardwareInfo TGLLP_1x6x16::hwInfo = {

2
shared/source/gen12lp/linux/hw_info_config_adlp.cpp
View File

@@ -22,7 +22,7 @@ int HwInfoConfigHw<gfxProduct>::configureHardwareCustom(HardwareInfo *hwInfo, OS
GT_SYSTEM_INFO *gtSystemInfo = &hwInfo->gtSystemInfo;
gtSystemInfo->SliceCount = 1;
const auto &hwInfoConfig = *HwInfoConfig::get(hwInfo->platform.eProductFamily);
hwInfo->featureTable.ftrGpGpuMidThreadLevelPreempt = (hwInfo->platform.usRevId >= hwInfoConfig.getHwRevIdFromStepping(REVISION_B, *hwInfo));
hwInfo->featureTable.flags.ftrGpGpuMidThreadLevelPreempt = (hwInfo->platform.usRevId >= hwInfoConfig.getHwRevIdFromStepping(REVISION_B, *hwInfo));
enableBlitterOperationsSupport(hwInfo);

2
shared/source/gen12lp/linux/hw_info_config_dg1.cpp
View File

@@ -23,7 +23,7 @@ int HwInfoConfigHw<gfxProduct>::configureHardwareCustom(HardwareInfo *hwInfo, OS
enableBlitterOperationsSupport(hwInfo);
hwInfo->featureTable.ftrGpGpuMidThreadLevelPreempt = false;
hwInfo->featureTable.flags.ftrGpGpuMidThreadLevelPreempt = false;
auto &kmdNotifyProperties = hwInfo->capabilityTable.kmdNotifyProperties;
kmdNotifyProperties.enableKmdNotify = true;
kmdNotifyProperties.delayKmdNotifyMicroseconds = 300;

2
shared/source/gen12lp/linux/hw_info_config_rkl.cpp
View File

@@ -20,7 +20,7 @@ template <>
int HwInfoConfigHw<gfxProduct>::configureHardwareCustom(HardwareInfo *hwInfo, OSInterface *osIface) {
GT_SYSTEM_INFO *gtSystemInfo = &hwInfo->gtSystemInfo;
gtSystemInfo->SliceCount = 1;
hwInfo->featureTable.ftrGpGpuMidThreadLevelPreempt = false;
hwInfo->featureTable.flags.ftrGpGpuMidThreadLevelPreempt = false;
enableBlitterOperationsSupport(hwInfo);

2
shared/source/gen12lp/linux/hw_info_config_tgllp.cpp
View File

@@ -20,7 +20,7 @@ template <>
int HwInfoConfigHw<gfxProduct>::configureHardwareCustom(HardwareInfo *hwInfo, OSInterface *osIface) {
GT_SYSTEM_INFO *gtSystemInfo = &hwInfo->gtSystemInfo;
gtSystemInfo->SliceCount = 1;
hwInfo->featureTable.ftrGpGpuMidThreadLevelPreempt = false;
hwInfo->featureTable.flags.ftrGpGpuMidThreadLevelPreempt = false;
enableBlitterOperationsSupport(hwInfo);
return 0;

2
shared/source/gen12lp/preamble_gen12lp.cpp
View File

@@ -62,7 +62,7 @@ void PreambleHelper<TGLLPFamily>::addPipeControlBeforeVfeCmd(LinearStream *pComm
auto pipeControl = pCommandStream->getSpaceForCmd<PIPE_CONTROL>();
PIPE_CONTROL cmd = TGLLPFamily::cmdInitPipeControl;
cmd.setCommandStreamerStallEnable(true);
if (hwInfo->workaroundTable.waSendMIFLUSHBeforeVFE) {
if (hwInfo->workaroundTable.flags.waSendMIFLUSHBeforeVFE) {
if (engineGroupType != EngineGroupType::Compute) {
cmd.setRenderTargetCacheFlushEnable(true);
cmd.setDepthCacheFlushEnable(true);

28
shared/source/gen8/hw_info_bdw.cpp
View File

@@ -95,21 +95,21 @@ void BDW::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
workaroundTable->waDisableLSQCROPERFforOCL = true;
workaroundTable->waReportPerfCountUseGlobalContextID = true;
workaroundTable->waUseVAlign16OnTileXYBpp816 = true;
workaroundTable->waModifyVFEStateAfterGPGPUPreemption = true;
workaroundTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
workaroundTable->flags.waDisableLSQCROPERFforOCL = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.waUseVAlign16OnTileXYBpp816 = true;
workaroundTable->flags.waModifyVFEStateAfterGPGPUPreemption = true;
workaroundTable->flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
}
const HardwareInfo BDW_1x2x6::hwInfo = {

6
shared/source/gen8/preemption_gen8.cpp
View File

@@ -66,7 +66,7 @@ size_t PreemptionHelper::getPreemptionWaCsSize<GfxFamily>(const Device &device)
PreemptionMode preemptionMode = device.getPreemptionMode();
if (preemptionMode == PreemptionMode::ThreadGroup ||
preemptionMode == PreemptionMode::MidThread) {
if (device.getHardwareInfo().workaroundTable.waModifyVFEStateAfterGPGPUPreemption) {
if (device.getHardwareInfo().workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption) {
size += 2 * sizeof(MI_LOAD_REGISTER_IMM);
}
}
@@ -79,7 +79,7 @@ void PreemptionHelper::applyPreemptionWaCmdsBegin<GfxFamily>(LinearStream *pComm
PreemptionMode preemptionMode = device.getPreemptionMode();
if (preemptionMode == PreemptionMode::ThreadGroup ||
preemptionMode == PreemptionMode::MidThread) {
if (device.getHardwareInfo().workaroundTable.waModifyVFEStateAfterGPGPUPreemption) {
if (device.getHardwareInfo().workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption) {
LriHelper<GfxFamily>::program(pCommandStream,
CS_GPR_R0,
GPGPU_WALKER_COOKIE_VALUE_BEFORE_WALKER,
@@ -94,7 +94,7 @@ void PreemptionHelper::applyPreemptionWaCmdsEnd<GfxFamily>(LinearStream *pComman
PreemptionMode preemptionMode = device.getPreemptionMode();
if (preemptionMode == PreemptionMode::ThreadGroup ||
preemptionMode == PreemptionMode::MidThread) {
if (device.getHardwareInfo().workaroundTable.waModifyVFEStateAfterGPGPUPreemption) {
if (device.getHardwareInfo().workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption) {
LriHelper<GfxFamily>::program(pCommandStream,
CS_GPR_R0,
GPGPU_WALKER_COOKIE_VALUE_AFTER_WALKER,

62
shared/source/gen9/hw_info_bxt.cpp
View File

@@ -93,41 +93,41 @@ void BXT::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrL3IACoherency = true;
featureTable->ftrVEBOX = true;
featureTable->ftrULT = true;
featureTable->ftrGpGpuMidThreadLevelPreempt = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftr3dObjectLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->ftrLCIA = true;
featureTable->ftrPPGTT = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrDisplayYTiling = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrVEBOX = true;
featureTable->flags.ftrULT = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftr3dObjectLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftrLCIA = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrDisplayYTiling = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
if (platform->usRevId >= 3) {
featureTable->ftrGttCacheInvalidation = true;
featureTable->flags.ftrGttCacheInvalidation = true;
}
workaroundTable->waLLCCachingUnsupported = true;
workaroundTable->waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->waFbcLinearSurfaceStride = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->waSendMIFLUSHBeforeVFE = true;
workaroundTable->waForcePcBbFullCfgRestore = true;
workaroundTable->waReportPerfCountUseGlobalContextID = true;
workaroundTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
workaroundTable->flags.waLLCCachingUnsupported = true;
workaroundTable->flags.waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->flags.waFbcLinearSurfaceStride = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waSendMIFLUSHBeforeVFE = true;
workaroundTable->flags.waForcePcBbFullCfgRestore = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
}
const HardwareInfo BXT_1x2x6::hwInfo = {

56
shared/source/gen9/hw_info_cfl.cpp
View File

@@ -87,35 +87,35 @@ void CFL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrL3IACoherency = true;
featureTable->ftrVEBOX = true;
featureTable->ftrGpGpuMidThreadLevelPreempt = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftr3dObjectLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrDisplayYTiling = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrVEBOX = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftr3dObjectLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrDisplayYTiling = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->waSendMIFLUSHBeforeVFE = true;
workaroundTable->waReportPerfCountUseGlobalContextID = true;
workaroundTable->waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->waLosslessCompressionSurfaceStride = true;
workaroundTable->waFbcLinearSurfaceStride = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waSendMIFLUSHBeforeVFE = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->flags.waLosslessCompressionSurfaceStride = true;
workaroundTable->flags.waFbcLinearSurfaceStride = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
}
const HardwareInfo CFL_1x2x6::hwInfo = {

54
shared/source/gen9/hw_info_glk.cpp
View File

@@ -87,34 +87,34 @@ void GLK::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrL3IACoherency = true;
featureTable->ftrGpGpuMidThreadLevelPreempt = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftr3dObjectLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->ftrLCIA = true;
featureTable->ftrPPGTT = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrEnableGuC = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrULT = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftr3dObjectLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftrLCIA = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrULT = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftrTileY = true;
workaroundTable->waLLCCachingUnsupported = true;
workaroundTable->waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->waFbcLinearSurfaceStride = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->waSendMIFLUSHBeforeVFE = true;
workaroundTable->waForcePcBbFullCfgRestore = true;
workaroundTable->waReportPerfCountUseGlobalContextID = true;
workaroundTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
workaroundTable->flags.waLLCCachingUnsupported = true;
workaroundTable->flags.waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->flags.waFbcLinearSurfaceStride = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waSendMIFLUSHBeforeVFE = true;
workaroundTable->flags.waForcePcBbFullCfgRestore = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
}
const HardwareInfo GLK_1x3x6::hwInfo = {

62
shared/source/gen9/hw_info_kbl.cpp
View File

@@ -88,42 +88,42 @@ void KBL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrL3IACoherency = true;
featureTable->ftrVEBOX = true;
featureTable->ftrGpGpuMidThreadLevelPreempt = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftr3dObjectLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrDisplayYTiling = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrTileY = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrVEBOX = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftr3dObjectLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrDisplayYTiling = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->waSendMIFLUSHBeforeVFE = true;
workaroundTable->waReportPerfCountUseGlobalContextID = true;
workaroundTable->waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->waLosslessCompressionSurfaceStride = true;
workaroundTable->waFbcLinearSurfaceStride = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waSendMIFLUSHBeforeVFE = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->flags.waLosslessCompressionSurfaceStride = true;
workaroundTable->flags.waFbcLinearSurfaceStride = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
if (platform->usRevId <= 0x6) {
workaroundTable->waDisableLSQCROPERFforOCL = true;
workaroundTable->waEncryptedEdramOnlyPartials = true;
workaroundTable->flags.waDisableLSQCROPERFforOCL = true;
workaroundTable->flags.waEncryptedEdramOnlyPartials = true;
}
if (platform->usRevId <= 0x8) {
workaroundTable->waForcePcBbFullCfgRestore = true;
workaroundTable->flags.waForcePcBbFullCfgRestore = true;
}
}

76
shared/source/gen9/hw_info_skl.cpp
View File

@@ -94,51 +94,51 @@ void SKL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrL3IACoherency = true;
featureTable->ftrGpGpuMidThreadLevelPreempt = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftr3dObjectLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrDisplayYTiling = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrFbcCpuTracking = true;
featureTable->ftrVcs2 = featureTable->ftrGT3 || featureTable->ftrGT4;
featureTable->ftrVEBOX = true;
featureTable->ftrSingleVeboxSlice = featureTable->ftrGT1 || featureTable->ftrGT2;
featureTable->ftrTileY = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftr3dObjectLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrDisplayYTiling = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrFbcCpuTracking = true;
featureTable->flags.ftrVcs2 = featureTable->flags.ftrGT3 || featureTable->flags.ftrGT4;
featureTable->flags.ftrVEBOX = true;
featureTable->flags.ftrSingleVeboxSlice = featureTable->flags.ftrGT1 || featureTable->flags.ftrGT2;
featureTable->flags.ftrTileY = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->waSendMIFLUSHBeforeVFE = true;
workaroundTable->waReportPerfCountUseGlobalContextID = true;
workaroundTable->waDisableLSQCROPERFforOCL = true;
workaroundTable->waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->waLosslessCompressionSurfaceStride = true;
workaroundTable->waFbcLinearSurfaceStride = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEncryptedEdramOnlyPartials = true;
workaroundTable->waDisableEdramForDisplayRT = true;
workaroundTable->waForcePcBbFullCfgRestore = true;
workaroundTable->waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waSendMIFLUSHBeforeVFE = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.waDisableLSQCROPERFforOCL = true;
workaroundTable->flags.waMsaa8xTileYDepthPitchAlignment = true;
workaroundTable->flags.waLosslessCompressionSurfaceStride = true;
workaroundTable->flags.waFbcLinearSurfaceStride = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEncryptedEdramOnlyPartials = true;
workaroundTable->flags.waDisableEdramForDisplayRT = true;
workaroundTable->flags.waForcePcBbFullCfgRestore = true;
workaroundTable->flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;
if ((1 << hwInfo->platform.usRevId) & 0x0eu) {
workaroundTable->waCompressedResourceRequiresConstVA21 = true;
workaroundTable->flags.waCompressedResourceRequiresConstVA21 = true;
}
if ((1 << hwInfo->platform.usRevId) & 0x0fu) {
workaroundTable->waDisablePerCtxtPreemptionGranularityControl = true;
workaroundTable->waModifyVFEStateAfterGPGPUPreemption = true;
workaroundTable->flags.waDisablePerCtxtPreemptionGranularityControl = true;
workaroundTable->flags.waModifyVFEStateAfterGPGPUPreemption = true;
}
if ((1 << hwInfo->platform.usRevId) & 0x3f) {
workaroundTable->waCSRUncachable = true;
workaroundTable->flags.waCSRUncachable = true;
}
}
const HardwareInfo SKL_1x2x6::hwInfo = {

2
shared/source/gen9/linux/hw_info_config_bxt.cpp
View File

@@ -32,7 +32,7 @@ int HwInfoConfigHw<IGFX_BROXTON>::configureHardwareCustom(HardwareInfo *hwInfo,
int enabled = 0;
int retVal = drm->getEnabledPooledEu(enabled);
if (retVal == 0) {
featureTable->ftrPooledEuEnabled = (enabled != 0);
featureTable->flags.ftrPooledEuEnabled = (enabled != 0);
}
if (enabled) {
int num = 0;

2
shared/source/gen9/linux/hw_info_config_glk.cpp
View File

@@ -30,7 +30,7 @@ int HwInfoConfigHw<IGFX_GEMINILAKE>::configureHardwareCustom(HardwareInfo *hwInf
int enabled = 0;
int retVal = drm->getEnabledPooledEu(enabled);
if (retVal == 0) {
featureTable->ftrPooledEuEnabled = (enabled != 0);
featureTable->flags.ftrPooledEuEnabled = (enabled != 0);
}
if (enabled) {
int num = 0;

2
shared/source/gen9/preamble_gen9.cpp
View File

@@ -55,7 +55,7 @@ void PreambleHelper<SKLFamily>::addPipeControlBeforeVfeCmd(LinearStream *pComman
auto pipeControl = pCommandStream->getSpaceForCmd<PIPE_CONTROL>();
PIPE_CONTROL cmd = SKLFamily::cmdInitPipeControl;
cmd.setCommandStreamerStallEnable(true);
if (hwInfo->workaroundTable.waSendMIFLUSHBeforeVFE) {
if (hwInfo->workaroundTable.flags.waSendMIFLUSHBeforeVFE) {
cmd.setRenderTargetCacheFlushEnable(true);
cmd.setDepthCacheFlushEnable(true);
cmd.setDcFlushEnable(true);

6
shared/source/gen9/preemption_gen9.cpp
View File

@@ -23,7 +23,7 @@ size_t PreemptionHelper::getPreemptionWaCsSize<GfxFamily>(const Device &device)
PreemptionMode preemptionMode = device.getPreemptionMode();
if (preemptionMode == PreemptionMode::ThreadGroup ||
preemptionMode == PreemptionMode::MidThread) {
if (device.getHardwareInfo().workaroundTable.waModifyVFEStateAfterGPGPUPreemption) {
if (device.getHardwareInfo().workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption) {
size += 2 * sizeof(MI_LOAD_REGISTER_IMM);
}
}
@@ -36,7 +36,7 @@ void PreemptionHelper::applyPreemptionWaCmdsBegin<GfxFamily>(LinearStream *pComm
PreemptionMode preemptionMode = device.getPreemptionMode();
if (preemptionMode == PreemptionMode::ThreadGroup ||
preemptionMode == PreemptionMode::MidThread) {
if (device.getHardwareInfo().workaroundTable.waModifyVFEStateAfterGPGPUPreemption) {
if (device.getHardwareInfo().workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption) {
LriHelper<GfxFamily>::program(pCommandStream,
CS_GPR_R0,
GPGPU_WALKER_COOKIE_VALUE_BEFORE_WALKER,
@@ -51,7 +51,7 @@ void PreemptionHelper::applyPreemptionWaCmdsEnd<GfxFamily>(LinearStream *pComman
PreemptionMode preemptionMode = device.getPreemptionMode();
if (preemptionMode == PreemptionMode::ThreadGroup ||
preemptionMode == PreemptionMode::MidThread) {
if (device.getHardwareInfo().workaroundTable.waModifyVFEStateAfterGPGPUPreemption) {
if (device.getHardwareInfo().workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption) {
LriHelper<GfxFamily>::program(pCommandStream,
CS_GPR_R0,
GPGPU_WALKER_COOKIE_VALUE_AFTER_WALKER,

8
shared/source/gmm_helper/gmm.cpp
View File

@@ -165,7 +165,7 @@ void Gmm::applyAuxFlagsForImage(ImageInfo &imgInfo) {
}
bool compressionFormatSupported = false;
if (clientContext->getHardwareInfo()->featureTable.ftrFlatPhysCCS) {
if (clientContext->getHardwareInfo()->featureTable.flags.ftrFlatPhysCCS) {
compressionFormatSupported = compressionFormat != GMM_FLATCCS_FORMAT::GMM_FLATCCS_FORMAT_INVALID;
} else {
compressionFormatSupported = compressionFormat != GMM_E2ECOMP_FORMAT::GMM_E2ECOMP_FORMAT_INVALID;
@@ -186,7 +186,7 @@ void Gmm::applyAuxFlagsForImage(ImageInfo &imgInfo) {
!isPackedYuv;
auto &hwHelper = HwHelper::get(hwInfo->platform.eRenderCoreFamily);
if (imgInfo.useLocalMemory || !hwInfo->featureTable.ftrLocalMemory) {
if (imgInfo.useLocalMemory || !hwInfo->featureTable.flags.ftrLocalMemory) {
if (allowRenderCompression) {
hwHelper.applyRenderCompressionFlag(*this, 1);
this->resourceParams.Flags.Gpu.CCS = 1;
@@ -341,7 +341,7 @@ void Gmm::applyMemoryFlags(bool systemMemoryPool, StorageInfo &storageInfo) {
this->useSystemMemoryPool = systemMemoryPool;
auto hardwareInfo = clientContext->getHardwareInfo();
if (hardwareInfo->featureTable.ftrLocalMemory) {
if (hardwareInfo->featureTable.flags.ftrLocalMemory) {
if (systemMemoryPool) {
resourceParams.Flags.Info.NonLocalOnly = 1;
} else {
@@ -356,7 +356,7 @@ void Gmm::applyMemoryFlags(bool systemMemoryPool, StorageInfo &storageInfo) {
}
}
if (hardwareInfo->featureTable.ftrMultiTileArch) {
if (hardwareInfo->featureTable.flags.ftrMultiTileArch) {
resourceParams.MultiTileArch.Enable = 1;
if (systemMemoryPool) {
resourceParams.MultiTileArch.GpuVaMappingSet = hardwareInfo->gtSystemInfo.MultiTileArchInfo.TileMask;

2
shared/source/helpers/compiler_hw_info_config_bdw_and_later.inl
View File

@@ -13,7 +13,7 @@
namespace NEO {
template <PRODUCT_FAMILY gfxProduct>
bool CompilerHwInfoConfigHw<gfxProduct>::isMidThreadPreemptionSupported(const HardwareInfo &hwInfo) const {
return hwInfo.featureTable.ftrGpGpuMidThreadLevelPreempt;
return hwInfo.featureTable.flags.ftrGpGpuMidThreadLevelPreempt;
}
} // namespace NEO

2
shared/source/helpers/hw_helper_dg2_and_later.inl
View File

@@ -34,7 +34,7 @@ inline void MemorySynchronizationCommands<GfxFamily>::setPipeControlExtraPropert
template <typename GfxFamily>
inline void MemorySynchronizationCommands<GfxFamily>::setPostSyncExtraProperties(PipeControlArgs &args, const HardwareInfo &hwInfo) {
if (hwInfo.featureTable.ftrLocalMemory) {
if (hwInfo.featureTable.flags.ftrLocalMemory) {
args.hdcPipelineFlush = true;
args.unTypedDataPortCacheFlush = true;
}

2
shared/source/helpers/hw_helper_tgllp_and_later.inl
View File

@@ -12,7 +12,7 @@ namespace NEO {
template <typename GfxFamily>
inline bool HwHelperHw<GfxFamily>::isFusedEuDispatchEnabled(const HardwareInfo &hwInfo) const {
auto fusedEuDispatchEnabled = !hwInfo.workaroundTable.waDisableFusedThreadScheduling;
auto fusedEuDispatchEnabled = !hwInfo.workaroundTable.flags.waDisableFusedThreadScheduling;
fusedEuDispatchEnabled &= hwInfo.capabilityTable.fusedEuEnabled;
if (DebugManager.flags.CFEFusedEUDispatch.get() != -1) {

10
shared/source/helpers/hw_helper_xehp_and_later.inl
View File

@@ -19,7 +19,7 @@ namespace NEO {
template <typename GfxFamily>
void HwHelperHw<GfxFamily>::adjustDefaultEngineType(HardwareInfo *pHwInfo) {
if (!pHwInfo->featureTable.ftrCCSNode) {
if (!pHwInfo->featureTable.flags.ftrCCSNode) {
pHwInfo->capabilityTable.defaultEngineType = aub_stream::ENGINE_RCS;
}
}
@@ -41,7 +41,7 @@ inline uint32_t HwHelperHw<GfxFamily>::getGlobalTimeStampBits() const {
template <typename GfxFamily>
bool HwHelperHw<GfxFamily>::isLocalMemoryEnabled(const HardwareInfo &hwInfo) const {
return hwInfo.featureTable.ftrLocalMemory;
return hwInfo.featureTable.flags.ftrLocalMemory;
}
template <typename GfxFamily>
@@ -61,14 +61,14 @@ const EngineInstancesContainer HwHelperHw<GfxFamily>::getGpgpuEngineInstances(co
EngineInstancesContainer engines;
if ((DebugManager.flags.NodeOrdinal.get() == static_cast<int32_t>(aub_stream::EngineType::ENGINE_RCS)) ||
hwInfo.featureTable.ftrRcsNode) {
hwInfo.featureTable.flags.ftrRcsNode) {
engines.push_back({aub_stream::ENGINE_RCS, EngineUsage::Regular});
}
engines.push_back({defaultEngine, EngineUsage::LowPriority});
engines.push_back({defaultEngine, EngineUsage::Internal});
if (hwInfo.featureTable.ftrCCSNode) {
if (hwInfo.featureTable.flags.ftrCCSNode) {
for (uint32_t i = 0; i < hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled; i++) {
engines.push_back({static_cast<aub_stream::EngineType>(i + aub_stream::ENGINE_CCS), EngineUsage::Regular});
}
@@ -161,7 +161,7 @@ aub_stream::MMIOList HwHelperHw<GfxFamily>::getExtraMmioList(const HardwareInfo
template <typename GfxFamily>
bool MemorySynchronizationCommands<GfxFamily>::isPipeControlWArequired(const HardwareInfo &hwInfo) {
if (DebugManager.flags.DisablePipeControlPrecedingPostSyncCommand.get() == 1) {
return hwInfo.featureTable.ftrLocalMemory;
return hwInfo.featureTable.flags.ftrLocalMemory;
}
return false;
}

4
shared/source/os_interface/hw_info_config_bdw_and_later.inl
View File

@@ -21,8 +21,8 @@ uint64_t HwInfoConfigHw<gfxProduct>::getCrossDeviceSharedMemCapabilities() {
template <PRODUCT_FAMILY gfxProduct>
void HwInfoConfigHw<gfxProduct>::enableRenderCompression(HardwareInfo *hwInfo) {
hwInfo->capabilityTable.ftrRenderCompressedImages = hwInfo->featureTable.ftrE2ECompression;
hwInfo->capabilityTable.ftrRenderCompressedBuffers = hwInfo->featureTable.ftrE2ECompression;
hwInfo->capabilityTable.ftrRenderCompressedImages = hwInfo->featureTable.flags.ftrE2ECompression;
hwInfo->capabilityTable.ftrRenderCompressedBuffers = hwInfo->featureTable.flags.ftrE2ECompression;
}
template <PRODUCT_FAMILY gfxProduct>

4
shared/source/os_interface/hw_info_config_xehp_and_later.inl
View File

@@ -20,8 +20,8 @@ uint64_t HwInfoConfigHw<gfxProduct>::getCrossDeviceSharedMemCapabilities() {
template <PRODUCT_FAMILY gfxProduct>
void HwInfoConfigHw<gfxProduct>::enableRenderCompression(HardwareInfo *hwInfo) {
hwInfo->capabilityTable.ftrRenderCompressedImages = hwInfo->featureTable.ftrE2ECompression;
hwInfo->capabilityTable.ftrRenderCompressedBuffers = hwInfo->featureTable.ftrE2ECompression;
hwInfo->capabilityTable.ftrRenderCompressedImages = hwInfo->featureTable.flags.ftrE2ECompression;
hwInfo->capabilityTable.ftrRenderCompressedBuffers = hwInfo->featureTable.flags.ftrE2ECompression;
}
template <PRODUCT_FAMILY gfxProduct>

30
shared/source/os_interface/linux/hw_info_config_drm.cpp
View File

@@ -127,12 +127,12 @@ int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo
gtSystemInfo->MaxSlicesSupported = topologyData.maxSliceCount;
uint64_t gttSizeQuery = 0;
featureTable->ftrSVM = true;
featureTable->flags.ftrSVM = true;
ret = drm->queryGttSize(gttSizeQuery);
if (ret == 0) {
featureTable->ftrSVM = (gttSizeQuery > MemoryConstants::max64BitAppAddress);
featureTable->flags.ftrSVM = (gttSizeQuery > MemoryConstants::max64BitAppAddress);
outHwInfo->capabilityTable.gpuAddressSpace = gttSizeQuery - 1; // gttSizeQuery = (1 << bits)
}
@@ -145,15 +145,15 @@ int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo
return -1;
}
platform->eGTType = gtType;
featureTable->ftrGTA = (gtType == GTTYPE_GTA) ? 1 : 0;
featureTable->ftrGTC = (gtType == GTTYPE_GTC) ? 1 : 0;
featureTable->ftrGTX = (gtType == GTTYPE_GTX) ? 1 : 0;
featureTable->ftrGT1 = (gtType == GTTYPE_GT1) ? 1 : 0;
featureTable->ftrGT1_5 = (gtType == GTTYPE_GT1_5) ? 1 : 0;
featureTable->ftrGT2 = (gtType == GTTYPE_GT2) ? 1 : 0;
featureTable->ftrGT2_5 = (gtType == GTTYPE_GT2_5) ? 1 : 0;
featureTable->ftrGT3 = (gtType == GTTYPE_GT3) ? 1 : 0;
featureTable->ftrGT4 = (gtType == GTTYPE_GT4) ? 1 : 0;
featureTable->flags.ftrGTA = (gtType == GTTYPE_GTA) ? 1 : 0;
featureTable->flags.ftrGTC = (gtType == GTTYPE_GTC) ? 1 : 0;
featureTable->flags.ftrGTX = (gtType == GTTYPE_GTX) ? 1 : 0;
featureTable->flags.ftrGT1 = (gtType == GTTYPE_GT1) ? 1 : 0;
featureTable->flags.ftrGT1_5 = (gtType == GTTYPE_GT1_5) ? 1 : 0;
featureTable->flags.ftrGT2 = (gtType == GTTYPE_GT2) ? 1 : 0;
featureTable->flags.ftrGT2_5 = (gtType == GTTYPE_GT2_5) ? 1 : 0;
featureTable->flags.ftrGT3 = (gtType == GTTYPE_GT3) ? 1 : 0;
featureTable->flags.ftrGT4 = (gtType == GTTYPE_GT4) ? 1 : 0;
ret = configureHardwareCustom(outHwInfo, osIface);
if (ret != 0) {
@@ -161,10 +161,10 @@ int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo
return ret;
}
configureCacheInfo(outHwInfo);
featureTable->ftrEDram = (gtSystemInfo->EdramSizeInKb != 0) ? 1 : 0;
featureTable->flags.ftrEDram = (gtSystemInfo->EdramSizeInKb != 0) ? 1 : 0;
outHwInfo->capabilityTable.maxRenderFrequency = maxGpuFreq;
outHwInfo->capabilityTable.ftrSvm = featureTable->ftrSVM;
outHwInfo->capabilityTable.ftrSvm = featureTable->flags.ftrSVM;
HwHelper &hwHelper = HwHelper::get(platform->eRenderCoreFamily);
outHwInfo->capabilityTable.ftrSupportsCoherency = false;
@@ -179,8 +179,8 @@ int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo
auto compilerHwInfoConfig = CompilerHwInfoConfig::get(outHwInfo->platform.eProductFamily);
PreemptionHelper::adjustDefaultPreemptionMode(outHwInfo->capabilityTable,
compilerHwInfoConfig->isMidThreadPreemptionSupported(*outHwInfo) && preemption,
static_cast<bool>(outHwInfo->featureTable.ftrGpGpuThreadGroupLevelPreempt) && preemption,
static_cast<bool>(outHwInfo->featureTable.ftrGpGpuMidBatchPreempt) && preemption);
static_cast<bool>(outHwInfo->featureTable.flags.ftrGpGpuThreadGroupLevelPreempt) && preemption,
static_cast<bool>(outHwInfo->featureTable.flags.ftrGpGpuMidBatchPreempt) && preemption);
outHwInfo->capabilityTable.requiredPreemptionSurfaceSize = outHwInfo->gtSystemInfo.CsrSizeInMb * MemoryConstants::megaByte;
hwHelper.adjustPreemptionSurfaceSize(outHwInfo->capabilityTable.requiredPreemptionSurfaceSize);

8
shared/source/os_interface/windows/hw_info_config_wddm.cpp
View File

@@ -21,18 +21,18 @@ int HwInfoConfig::configureHwInfoWddm(const HardwareInfo *inHwInfo, HardwareInfo
auto &hwHelper = HwHelper::get(outHwInfo->platform.eRenderCoreFamily);
auto &hwInfoConfig = *HwInfoConfig::get(outHwInfo->platform.eProductFamily);
auto compilerHwInfoConfig = CompilerHwInfoConfig::get(outHwInfo->platform.eProductFamily);
outHwInfo->capabilityTable.ftrSvm = outHwInfo->featureTable.ftrSVM;
outHwInfo->capabilityTable.ftrSvm = outHwInfo->featureTable.flags.ftrSVM;
hwHelper.adjustDefaultEngineType(outHwInfo);
outHwInfo->capabilityTable.defaultEngineType = getChosenEngineType(*outHwInfo);
hwInfoConfig.setCapabilityCoherencyFlag(*outHwInfo, outHwInfo->capabilityTable.ftrSupportsCoherency);
outHwInfo->capabilityTable.ftrSupportsCoherency &= inHwInfo->featureTable.ftrL3IACoherency;
outHwInfo->capabilityTable.ftrSupportsCoherency &= inHwInfo->featureTable.flags.ftrL3IACoherency;
PreemptionHelper::adjustDefaultPreemptionMode(outHwInfo->capabilityTable,
compilerHwInfoConfig->isMidThreadPreemptionSupported(*outHwInfo),
static_cast<bool>(outHwInfo->featureTable.ftrGpGpuThreadGroupLevelPreempt),
static_cast<bool>(outHwInfo->featureTable.ftrGpGpuMidBatchPreempt));
static_cast<bool>(outHwInfo->featureTable.flags.ftrGpGpuThreadGroupLevelPreempt),
static_cast<bool>(outHwInfo->featureTable.flags.ftrGpGpuMidBatchPreempt));
if (DebugManager.flags.OverridePreemptionSurfaceSizeInMb.get() >= 0) {
outHwInfo->gtSystemInfo.CsrSizeInMb = static_cast<uint32_t>(DebugManager.flags.OverridePreemptionSurfaceSizeInMb.get());

4
shared/source/os_interface/windows/wddm/configure_device_address_space_drm_or_wddm.cpp
View File

@@ -83,7 +83,7 @@ bool tryWritePartitionLayoutWithinProcess(Wddm &wddm, GMM_GFX_PARTITIONING &part
}
bool adjustGfxPartitionLayout(GMM_GFX_PARTITIONING &partitionLayout, uint64_t gpuAddressSpace, uintptr_t minAllowedAddress, Wddm &wddm) {
bool requiresRepartitioning = (gpuAddressSpace == maxNBitValue(47)) && wddm.getFeatureTable().ftrCCSRing;
bool requiresRepartitioning = (gpuAddressSpace == maxNBitValue(47)) && wddm.getFeatureTable().flags.ftrCCSRing;
if (false == requiresRepartitioning) {
return true;
}
@@ -221,7 +221,7 @@ bool Wddm::configureDeviceAddressSpace() {
}
uintptr_t addr = 0;
auto ret = gmmMemory->configureDevice(getAdapter(), device, getGdi()->escape, maxUsmSize, featureTable->ftrL3IACoherency, addr, false);
auto ret = gmmMemory->configureDevice(getAdapter(), device, getGdi()->escape, maxUsmSize, featureTable->flags.ftrL3IACoherency, addr, false);
return ret;
}

2
shared/source/os_interface/windows/wddm/configure_device_address_space_wddm.cpp
View File

@@ -65,7 +65,7 @@ bool Wddm::configureDeviceAddressSpace() {
: 0u;
bool obtainMinAddress = rootDeviceEnvironment.getHardwareInfo()->platform.eRenderCoreFamily == IGFX_GEN12LP_CORE;
return gmmMemory->configureDevice(getAdapter(), device, getGdi()->escape, svmSize, featureTable->ftrL3IACoherency, minAddress, obtainMinAddress);
return gmmMemory->configureDevice(getAdapter(), device, getGdi()->escape, svmSize, featureTable->flags.ftrL3IACoherency, minAddress, obtainMinAddress);
}
} // namespace NEO

18
shared/source/os_interface/windows/wddm/wddm.cpp
View File

@@ -370,7 +370,7 @@ bool Wddm::evict(const D3DKMT_HANDLE *handleList, uint32_t numOfHandles, uint64_
sizeToTrim = Evict.NumBytesToTrim;
kmDafListener->notifyEvict(featureTable->ftrKmdDaf, getAdapter(), device, handleList, numOfHandles, getGdi()->escape);
kmDafListener->notifyEvict(featureTable->flags.ftrKmdDaf, getAdapter(), device, handleList, numOfHandles, getGdi()->escape);
return status == STATUS_SUCCESS;
}
@@ -406,7 +406,7 @@ bool Wddm::makeResident(const D3DKMT_HANDLE *handles, uint32_t count, bool cantT
UNRECOVERABLE_IF(cantTrimFurther);
}
kmDafListener->notifyMakeResident(featureTable->ftrKmdDaf, getAdapter(), device, handles, count, getGdi()->escape);
kmDafListener->notifyMakeResident(featureTable->flags.ftrKmdDaf, getAdapter(), device, handles, count, getGdi()->escape);
return success;
}
@@ -452,7 +452,7 @@ bool Wddm::mapGpuVirtualAddress(Gmm *gmm, D3DKMT_HANDLE handle, D3DGPU_VIRTUAL_A
return false;
}
kmDafListener->notifyMapGpuVA(featureTable->ftrKmdDaf, getAdapter(), device, handle, MapGPUVA.VirtualAddress, getGdi()->escape);
kmDafListener->notifyMapGpuVA(featureTable->flags.ftrKmdDaf, getAdapter(), device, handle, MapGPUVA.VirtualAddress, getGdi()->escape);
bool ret = true;
if (gmm->isCompressionEnabled && HwInfoConfig::get(gfxPlatform->eProductFamily)->isPageTableManagerSupported(*rootDeviceEnvironment.getHardwareInfo())) {
for (auto engine : rootDeviceEnvironment.executionEnvironment.memoryManager.get()->getRegisteredEngines()) {
@@ -490,7 +490,7 @@ bool Wddm::freeGpuVirtualAddress(D3DGPU_VIRTUAL_ADDRESS &gpuPtr, uint64_t size)
status = getGdi()->freeGpuVirtualAddress(&FreeGPUVA);
gpuPtr = static_cast<D3DGPU_VIRTUAL_ADDRESS>(0);
kmDafListener->notifyUnmapGpuVA(featureTable->ftrKmdDaf, getAdapter(), device, FreeGPUVA.BaseAddress, getGdi()->escape);
kmDafListener->notifyUnmapGpuVA(featureTable->flags.ftrKmdDaf, getAdapter(), device, FreeGPUVA.BaseAddress, getGdi()->escape);
return status == STATUS_SUCCESS;
}
@@ -534,7 +534,7 @@ NTSTATUS Wddm::createAllocation(const void *alignedCpuPtr, const Gmm *gmm, D3DKM
}
*outSharedHandle = castToUint64(ntSharedHandle);
}
kmDafListener->notifyWriteTarget(featureTable->ftrKmdDaf, getAdapter(), device, outHandle, getGdi()->escape);
kmDafListener->notifyWriteTarget(featureTable->flags.ftrKmdDaf, getAdapter(), device, outHandle, getGdi()->escape);
return status;
}
@@ -634,7 +634,7 @@ NTSTATUS Wddm::createAllocationsAndMapGpuVa(OsHandleStorage &osHandles) {
allocationIndex++;
kmDafListener->notifyWriteTarget(featureTable->ftrKmdDaf, getAdapter(), device, AllocationInfo[i].hAllocation, getGdi()->escape);
kmDafListener->notifyWriteTarget(featureTable->flags.ftrKmdDaf, getAdapter(), device, AllocationInfo[i].hAllocation, getGdi()->escape);
}
status = STATUS_SUCCESS;
@@ -782,11 +782,11 @@ void Wddm::unlockResource(const D3DKMT_HANDLE &handle) {
[[maybe_unused]] NTSTATUS status = getGdi()->unlock2(&unlock2);
DEBUG_BREAK_IF(status != STATUS_SUCCESS);
kmDafListener->notifyUnlock(featureTable->ftrKmdDaf, getAdapter(), device, &handle, 1, getGdi()->escape);
kmDafListener->notifyUnlock(featureTable->flags.ftrKmdDaf, getAdapter(), device, &handle, 1, getGdi()->escape);
}
void Wddm::kmDafLock(D3DKMT_HANDLE handle) {
kmDafListener->notifyLock(featureTable->ftrKmdDaf, getAdapter(), device, handle, 0, getGdi()->escape);
kmDafListener->notifyLock(featureTable->flags.ftrKmdDaf, getAdapter(), device, handle, 0, getGdi()->escape);
}
bool Wddm::createContext(OsContextWin &osContext) {
@@ -1039,7 +1039,7 @@ void Wddm::updatePagingFenceValue(uint64_t newPagingFenceValue) {
}
WddmVersion Wddm::getWddmVersion() {
if (featureTable->ftrWddmHwQueues) {
if (featureTable->flags.ftrWddmHwQueues) {
return WddmVersion::WDDM_2_3;
} else {
return WddmVersion::WDDM_2_0;

2
shared/source/os_interface/windows/wddm/wddm.h
View File

@@ -86,7 +86,7 @@ class Wddm : public DriverModel {
MOCKABLE_VIRTUAL void *lockResource(const D3DKMT_HANDLE &handle, bool applyMakeResidentPriorToLock, size_t size);
MOCKABLE_VIRTUAL void unlockResource(const D3DKMT_HANDLE &handle);
MOCKABLE_VIRTUAL void kmDafLock(D3DKMT_HANDLE handle);
MOCKABLE_VIRTUAL bool isKmDafEnabled() const { return featureTable->ftrKmdDaf; }
MOCKABLE_VIRTUAL bool isKmDafEnabled() const { return featureTable->flags.ftrKmdDaf; }
MOCKABLE_VIRTUAL bool setAllocationPriority(const D3DKMT_HANDLE *handles, uint32_t allocationCount, uint32_t priority);

4
shared/source/sku_info/operations/sku_info_transfer.h
View File

@@ -18,7 +18,7 @@ class SkuInfoTransfer {
protected:
static void transferFtrTableForGmmBase(_SKU_FEATURE_TABLE *dstFtrTable, const NEO::FeatureTable *srcFtrTable) {
#define TRANSFER_FTR_TO_GMM(VAL_NAME) dstFtrTable->Ftr##VAL_NAME = srcFtrTable->ftr##VAL_NAME
#define TRANSFER_FTR_TO_GMM(VAL_NAME) dstFtrTable->Ftr##VAL_NAME = srcFtrTable->flags.ftr##VAL_NAME
TRANSFER_FTR_TO_GMM(StandardMipTailFormat);
TRANSFER_FTR_TO_GMM(ULT);
TRANSFER_FTR_TO_GMM(EDram);
@@ -55,7 +55,7 @@ class SkuInfoTransfer {
}
static void transferWaTableForGmmBase(_WA_TABLE *dstWaTable, const NEO::WorkaroundTable *srcWaTable) {
#define TRANSFER_WA_TO_GMM(VAL_NAME) dstWaTable->Wa##VAL_NAME = srcWaTable->wa##VAL_NAME
#define TRANSFER_WA_TO_GMM(VAL_NAME) dstWaTable->Wa##VAL_NAME = srcWaTable->flags.wa##VAL_NAME
TRANSFER_WA_TO_GMM(FbcLinearSurfaceStride);
TRANSFER_WA_TO_GMM(DisableEdramForDisplayRT);
TRANSFER_WA_TO_GMM(EncryptedEdramOnlyPartials);

4
shared/source/sku_info/operations/windows/sku_info_receiver.h
View File

@@ -19,7 +19,7 @@ class SkuInfoReceiver {
protected:
static void receiveFtrTableFromAdapterInfoBase(FeatureTable *ftrTable, ADAPTER_INFO_KMD *adapterInfo) {
#define RECEIVE_FTR(VAL_NAME) ftrTable->ftr##VAL_NAME = adapterInfo->SkuTable.Ftr##VAL_NAME
#define RECEIVE_FTR(VAL_NAME) ftrTable->flags.ftr##VAL_NAME = adapterInfo->SkuTable.Ftr##VAL_NAME
RECEIVE_FTR(Desktop);
RECEIVE_FTR(ChannelSwizzlingXOREnabled);
@@ -111,7 +111,7 @@ class SkuInfoReceiver {
}
static void receiveWaTableFromAdapterInfoBase(WorkaroundTable *workaroundTable, ADAPTER_INFO_KMD *adapterInfo) {
#define RECEIVE_WA(VAL_NAME) workaroundTable->wa##VAL_NAME = adapterInfo->WaTable.Wa##VAL_NAME
#define RECEIVE_WA(VAL_NAME) workaroundTable->flags.wa##VAL_NAME = adapterInfo->WaTable.Wa##VAL_NAME
RECEIVE_WA(DoNotUseMIReportPerfCount);
RECEIVE_WA(EnablePreemptionGranularityControlByUMD);

248
shared/source/sku_info/sku_info_base.h
View File

@@ -7,137 +7,143 @@
#pragma once
#include <array>
#include <cstdint>
namespace NEO {
struct FeatureTableBase {
public:
FeatureTableBase() : packed{} {
ftrRcsNode = 1;
FeatureTableBase() {
flags.ftrRcsNode = 1;
}
struct Flags {
// DW0
uint32_t ftrDesktop : 1;
uint32_t ftrChannelSwizzlingXOREnabled : 1;
uint32_t ftrGtBigDie : 1;
uint32_t ftrGtMediumDie : 1;
uint32_t ftrGtSmallDie : 1;
uint32_t ftrGT1 : 1;
uint32_t ftrGT1_5 : 1;
uint32_t ftrGT2 : 1;
uint32_t ftrGT2_5 : 1;
uint32_t ftrGT3 : 1;
uint32_t ftrGT4 : 1;
uint32_t ftrIVBM0M1Platform : 1;
uint32_t ftrSGTPVSKUStrapPresent : 1;
uint32_t ftrGTA : 1;
uint32_t ftrGTC : 1;
uint32_t ftrGTX : 1;
uint32_t ftr5Slice : 1;
uint32_t ftrGpGpuMidBatchPreempt : 1;
uint32_t ftrGpGpuThreadGroupLevelPreempt : 1;
uint32_t ftrGpGpuMidThreadLevelPreempt : 1;
uint32_t ftrIoMmuPageFaulting : 1;
uint32_t ftrWddm2Svm : 1;
uint32_t ftrPooledEuEnabled : 1;
uint32_t ftrResourceStreamer : 1;
uint32_t ftrPPGTT : 1;
uint32_t ftrSVM : 1;
uint32_t ftrEDram : 1;
uint32_t ftrL3IACoherency : 1;
uint32_t ftrIA32eGfxPTEs : 1;
uint32_t ftr3dMidBatchPreempt : 1;
uint32_t ftr3dObjectLevelPreempt : 1;
uint32_t ftrPerCtxtPreemptionGranularityControl : 1;
// DW1
uint32_t ftrTileY : 1;
uint32_t ftrDisplayYTiling : 1;
uint32_t ftrTranslationTable : 1;
uint32_t ftrUserModeTranslationTable : 1;
uint32_t ftrEnableGuC : 1;
uint32_t ftrFbc : 1;
uint32_t ftrFbc2AddressTranslation : 1;
uint32_t ftrFbcBlitterTracking : 1;
uint32_t ftrFbcCpuTracking : 1;
uint32_t ftrVcs2 : 1;
uint32_t ftrVEBOX : 1;
uint32_t ftrSingleVeboxSlice : 1;
uint32_t ftrULT : 1;
uint32_t ftrLCIA : 1;
uint32_t ftrGttCacheInvalidation : 1;
uint32_t ftrTileMappedResource : 1;
uint32_t ftrAstcHdr2D : 1;
uint32_t ftrAstcLdr2D : 1;
uint32_t ftrStandardMipTailFormat : 1;
uint32_t ftrFrameBufferLLC : 1;
uint32_t ftrCrystalwell : 1;
uint32_t ftrLLCBypass : 1;
uint32_t ftrDisplayEngineS3d : 1;
uint32_t ftrVERing : 1;
uint32_t ftrWddm2GpuMmu : 1;
uint32_t ftrWddm2_1_64kbPages : 1;
uint32_t ftrWddmHwQueues : 1;
uint32_t ftrMemTypeMocsDeferPAT : 1;
uint32_t ftrKmdDaf : 1;
uint32_t ftrSimulationMode : 1;
uint32_t ftrE2ECompression : 1;
uint32_t ftrLinearCCS : 1;
//DW2
uint32_t ftrCCSRing : 1;
uint32_t ftrCCSNode : 1;
uint32_t ftrRcsNode : 1;
uint32_t ftrLocalMemory : 1;
uint32_t ftrLocalMemoryAllows4KB : 1;
uint32_t ftrFlatPhysCCS : 1;
uint32_t ftrMultiTileArch : 1;
uint32_t ftrCCSMultiInstance : 1;
uint32_t ftrPpgtt64KBWalkOptimization : 1;
uint32_t ftrUnified3DMediaCompressionFormats : 1;
uint32_t reserved : 22;
};
union {
struct {
bool ftrDesktop : 1;
bool ftrChannelSwizzlingXOREnabled : 1;
bool ftrGtBigDie : 1;
bool ftrGtMediumDie : 1;
bool ftrGtSmallDie : 1;
bool ftrGT1 : 1;
bool ftrGT1_5 : 1;
bool ftrGT2 : 1;
bool ftrGT2_5 : 1;
bool ftrGT3 : 1;
bool ftrGT4 : 1;
bool ftrIVBM0M1Platform : 1;
bool ftrSGTPVSKUStrapPresent : 1;
bool ftrGTA : 1;
bool ftrGTC : 1;
bool ftrGTX : 1;
bool ftr5Slice : 1;
bool ftrGpGpuMidBatchPreempt : 1;
bool ftrGpGpuThreadGroupLevelPreempt : 1;
bool ftrGpGpuMidThreadLevelPreempt : 1;
bool ftrIoMmuPageFaulting : 1;
bool ftrWddm2Svm : 1;
bool ftrPooledEuEnabled : 1;
bool ftrResourceStreamer : 1;
bool ftrPPGTT : 1;
bool ftrSVM : 1;
bool ftrEDram : 1;
bool ftrL3IACoherency : 1;
bool ftrIA32eGfxPTEs : 1;
bool ftr3dMidBatchPreempt : 1;
bool ftr3dObjectLevelPreempt : 1;
bool ftrPerCtxtPreemptionGranularityControl : 1;
bool ftrTileY : 1;
bool ftrDisplayYTiling : 1;
bool ftrTranslationTable : 1;
bool ftrUserModeTranslationTable : 1;
bool ftrEnableGuC : 1;
bool ftrFbc : 1;
bool ftrFbc2AddressTranslation : 1;
bool ftrFbcBlitterTracking : 1;
bool ftrFbcCpuTracking : 1;
bool ftrVcs2 : 1;
bool ftrVEBOX : 1;
bool ftrSingleVeboxSlice : 1;
bool ftrULT : 1;
bool ftrLCIA : 1;
bool ftrGttCacheInvalidation : 1;
bool ftrTileMappedResource : 1;
bool ftrAstcHdr2D : 1;
bool ftrAstcLdr2D : 1;
bool ftrStandardMipTailFormat : 1;
bool ftrFrameBufferLLC : 1;
bool ftrCrystalwell : 1;
bool ftrLLCBypass : 1;
bool ftrDisplayEngineS3d : 1;
bool ftrVERing : 1;
bool ftrWddm2GpuMmu : 1;
bool ftrWddm2_1_64kbPages : 1;
bool ftrWddmHwQueues : 1;
bool ftrMemTypeMocsDeferPAT : 1;
bool ftrKmdDaf : 1;
bool ftrSimulationMode : 1;
bool ftrE2ECompression : 1;
bool ftrLinearCCS : 1;
bool ftrCCSRing : 1;
bool ftrCCSNode : 1;
bool ftrRcsNode : 1;
bool ftrLocalMemory : 1;
bool ftrLocalMemoryAllows4KB : 1;
bool ftrFlatPhysCCS : 1;
bool ftrMultiTileArch : 1;
bool ftrCCSMultiInstance : 1;
bool ftrPpgtt64KBWalkOptimization : 1;
bool ftrUnified3DMediaCompressionFormats : 1;
};
uint64_t packed[2];
Flags flags;
std::array<uint32_t, 3> packed = {};
};
};
struct WorkaroundTableBase {
bool waDoNotUseMIReportPerfCount = false;
static_assert(sizeof(FeatureTableBase::flags) == sizeof(FeatureTableBase::packed));
bool waEnablePreemptionGranularityControlByUMD = false;
bool waSendMIFLUSHBeforeVFE = false;
bool waReportPerfCountUseGlobalContextID = false;
bool waDisableLSQCROPERFforOCL = false;
bool waMsaa8xTileYDepthPitchAlignment = false;
bool waLosslessCompressionSurfaceStride = false;
bool waFbcLinearSurfaceStride = false;
bool wa4kAlignUVOffsetNV12LinearSurface = false;
bool waEncryptedEdramOnlyPartials = false;
bool waDisableEdramForDisplayRT = false;
bool waForcePcBbFullCfgRestore = false;
bool waCompressedResourceRequiresConstVA21 = false;
bool waDisablePerCtxtPreemptionGranularityControl = false;
bool waLLCCachingUnsupported = false;
bool waUseVAlign16OnTileXYBpp816 = false;
bool waModifyVFEStateAfterGPGPUPreemption = false;
bool waCSRUncachable = false;
bool waSamplerCacheFlushBetweenRedescribedSurfaceReads = false;
bool waRestrictPitch128KB = false;
bool waLimit128BMediaCompr = false;
bool waUntypedBufferCompression = false;
bool waAuxTable16KGranular = false;
bool waDisableFusedThreadScheduling = false;
bool waDefaultTile4 = false;
bool waAuxTable64KGranular = false;
struct WorkaroundTableBase {
struct Flags {
// DW0
uint32_t waDoNotUseMIReportPerfCount : 1;
uint32_t waEnablePreemptionGranularityControlByUMD : 1;
uint32_t waSendMIFLUSHBeforeVFE : 1;
uint32_t waReportPerfCountUseGlobalContextID : 1;
uint32_t waDisableLSQCROPERFforOCL : 1;
uint32_t waMsaa8xTileYDepthPitchAlignment : 1;
uint32_t waLosslessCompressionSurfaceStride : 1;
uint32_t waFbcLinearSurfaceStride : 1;
uint32_t wa4kAlignUVOffsetNV12LinearSurface : 1;
uint32_t waEncryptedEdramOnlyPartials : 1;
uint32_t waDisableEdramForDisplayRT : 1;
uint32_t waForcePcBbFullCfgRestore : 1;
uint32_t waCompressedResourceRequiresConstVA21 : 1;
uint32_t waDisablePerCtxtPreemptionGranularityControl : 1;
uint32_t waLLCCachingUnsupported : 1;
uint32_t waUseVAlign16OnTileXYBpp816 : 1;
uint32_t waModifyVFEStateAfterGPGPUPreemption : 1;
uint32_t waCSRUncachable : 1;
uint32_t waSamplerCacheFlushBetweenRedescribedSurfaceReads : 1;
uint32_t waRestrictPitch128KB : 1;
uint32_t waLimit128BMediaCompr : 1;
uint32_t waUntypedBufferCompression : 1;
uint32_t waAuxTable16KGranular : 1;
uint32_t waDisableFusedThreadScheduling : 1;
uint32_t waDefaultTile4 : 1;
uint32_t waAuxTable64KGranular : 1;
uint32_t reserved : 6;
};
union {
Flags flags;
std::array<uint32_t, 1> packed = {};
};
};
static_assert(sizeof(WorkaroundTableBase::flags) == sizeof(WorkaroundTableBase::packed));
} // namespace NEO

2
shared/source/xe_hp_core/hw_helper_xe_hp_core.cpp
View File

@@ -134,7 +134,7 @@ void MemorySynchronizationCommands<Family>::setPipeControlExtraProperties(PIPE_C
template <>
void MemorySynchronizationCommands<Family>::setPostSyncExtraProperties(PipeControlArgs &args, const HardwareInfo &hwInfo) {
if (hwInfo.featureTable.ftrLocalMemory) {
if (hwInfo.featureTable.flags.ftrLocalMemory) {
args.hdcPipelineFlush = true;
}
}

58
shared/source/xe_hp_core/hw_info_xe_hp_sdv.cpp
View File

@@ -92,38 +92,38 @@ void XE_HP_SDV::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrFlatPhysCCS = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrFlatPhysCCS = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->ftrTileY = false;
featureTable->ftrLocalMemory = true;
featureTable->ftrLinearCCS = true;
featureTable->ftrE2ECompression = true;
featureTable->ftrCCSNode = true;
featureTable->ftrCCSRing = true;
featureTable->ftrMultiTileArch = true;
featureTable->ftrCCSMultiInstance = true;
featureTable->flags.ftrTileY = false;
featureTable->flags.ftrLocalMemory = true;
featureTable->flags.ftrLinearCCS = true;
featureTable->flags.ftrE2ECompression = true;
featureTable->flags.ftrCCSNode = true;
featureTable->flags.ftrCCSRing = true;
featureTable->flags.ftrMultiTileArch = true;
featureTable->flags.ftrCCSMultiInstance = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
};
const HardwareInfo XE_HP_SDV_CONFIG::hwInfo = {

4
shared/source/xe_hp_core/linux/hw_info_config_xe_hp_sdv.cpp
View File

@@ -23,9 +23,9 @@ int HwInfoConfigHw<gfxProduct>::configureHardwareCustom(HardwareInfo *hwInfo, OS
enableRenderCompression(hwInfo);
}
hwInfo->featureTable.ftrRcsNode = false;
hwInfo->featureTable.flags.ftrRcsNode = false;
if (DebugManager.flags.NodeOrdinal.get() == static_cast<int32_t>(aub_stream::EngineType::ENGINE_RCS)) {
hwInfo->featureTable.ftrRcsNode = true;
hwInfo->featureTable.flags.ftrRcsNode = true;
}
enableBlitterOperationsSupport(hwInfo);

4
shared/source/xe_hp_core/windows/hw_info_config_xe_hp_sdv.cpp
View File

@@ -24,9 +24,9 @@ int HwInfoConfigHw<gfxProduct>::configureHardwareCustom(HardwareInfo *hwInfo, OS
enableRenderCompression(hwInfo);
}
hwInfo->featureTable.ftrRcsNode = false;
hwInfo->featureTable.flags.ftrRcsNode = false;
if (DebugManager.flags.NodeOrdinal.get() == static_cast<int32_t>(aub_stream::EngineType::ENGINE_RCS)) {
hwInfo->featureTable.ftrRcsNode = true;
hwInfo->featureTable.flags.ftrRcsNode = true;
}
enableBlitterOperationsSupport(hwInfo);

4
shared/source/xe_hpg_core/hw_helper_xe_hpg_core.cpp
View File

@@ -29,7 +29,7 @@ uint32_t HwHelperHw<Family>::getMetricsLibraryGenId() const {
template <>
void HwHelperHw<Family>::adjustDefaultEngineType(HardwareInfo *pHwInfo) {
if (!pHwInfo->featureTable.ftrCCSNode) {
if (!pHwInfo->featureTable.flags.ftrCCSNode) {
pHwInfo->capabilityTable.defaultEngineType = aub_stream::ENGINE_RCS;
}
if (HwInfoConfig::get(pHwInfo->platform.eProductFamily)->isDefaultEngineTypeAdjustmentRequired(*pHwInfo)) {
@@ -48,7 +48,7 @@ inline bool HwHelperHw<Family>::isSpecialWorkgroupSizeRequired(const HardwareInf
template <>
bool HwHelperHw<Family>::is1MbAlignmentSupported(const HardwareInfo &hwInfo, bool isCompressionEnabled) const {
return !hwInfo.workaroundTable.waAuxTable64KGranular && isCompressionEnabled;
return !hwInfo.workaroundTable.flags.waAuxTable64KGranular && isCompressionEnabled;
}
template <>

58
shared/source/xe_hpg_core/hw_info_dg2.cpp
View File

@@ -92,39 +92,39 @@ void DG2::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
featureTable->ftrL3IACoherency = true;
featureTable->ftrFlatPhysCCS = true;
featureTable->ftrPPGTT = true;
featureTable->ftrSVM = true;
featureTable->ftrIA32eGfxPTEs = true;
featureTable->ftrStandardMipTailFormat = true;
featureTable->ftrTranslationTable = true;
featureTable->ftrUserModeTranslationTable = true;
featureTable->ftrTileMappedResource = true;
featureTable->ftrEnableGuC = true;
featureTable->ftrFbc = true;
featureTable->ftrFbc2AddressTranslation = true;
featureTable->ftrFbcBlitterTracking = true;
featureTable->ftrAstcHdr2D = true;
featureTable->ftrAstcLdr2D = true;
featureTable->flags.ftrL3IACoherency = true;
featureTable->flags.ftrFlatPhysCCS = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
featureTable->flags.ftrIA32eGfxPTEs = true;
featureTable->flags.ftrStandardMipTailFormat = true;
featureTable->flags.ftrTranslationTable = true;
featureTable->flags.ftrUserModeTranslationTable = true;
featureTable->flags.ftrTileMappedResource = true;
featureTable->flags.ftrEnableGuC = true;
featureTable->flags.ftrFbc = true;
featureTable->flags.ftrFbc2AddressTranslation = true;
featureTable->flags.ftrFbcBlitterTracking = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->ftr3dMidBatchPreempt = true;
featureTable->ftrGpGpuMidBatchPreempt = true;
featureTable->ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->ftrTileY = false;
featureTable->ftrLocalMemory = true;
featureTable->ftrLinearCCS = true;
featureTable->ftrE2ECompression = true;
featureTable->ftrCCSNode = true;
featureTable->ftrCCSRing = true;
featureTable->ftrCCSMultiInstance = true;
featureTable->flags.ftrTileY = false;
featureTable->flags.ftrLocalMemory = true;
featureTable->flags.ftrLinearCCS = true;
featureTable->flags.ftrE2ECompression = true;
featureTable->flags.ftrCCSNode = true;
featureTable->flags.ftrCCSRing = true;
featureTable->flags.ftrCCSMultiInstance = true;
featureTable->ftrUnified3DMediaCompressionFormats = true;
featureTable->flags.ftrUnified3DMediaCompressionFormats = true;
workaroundTable->wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
};
const HardwareInfo DG2_CONFIG::hwInfo = {