Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Ftr/WA flags cleanup 

Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>
This commit is contained in:
Dunajski, Bartosz 2022-10-25 15:41:07 +00:00 committed by Compute-Runtime-Automation
parent 2b5705ddfd
commit 7ff37cd5fd
51 changed files with 64 additions and 692 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
manifests/manifest.yml
View File

@ -38,7 +38,7 @@ components:
dest_dir: kernels_bin
type: git
branch: kernels_bin
revision: 1982-405
revision: 1982-406
kmdaf:
branch: kmdaf
dest_dir: kmdaf

7
opencl/test/unit_test/gen12lp/tgllp/test_hw_info_config_tgllp.cpp
View File

@ -105,21 +105,14 @@ TGLLPTEST_F(TgllpHwInfo, givenBoolWhenCallTgllpHardwareInfoSetupThenFeatureTable
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcLdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_EQ(setParamBool, workaroundTable.flags.waUntypedBufferCompression);
}
}

3
opencl/test/unit_test/xe_hp_core/xehp/hw_info_tests_xehp.inl
View File

@ -27,7 +27,6 @@ XEHPTEST_F(XeHPHwInfoTest, whenSetupHardwareInfoWithSetupFeatureTableFlagTrueOrF
EXPECT_FALSE(featureTable.flags.ftrCCSNode);
EXPECT_FALSE(featureTable.flags.ftrCCSRing);
EXPECT_FALSE(featureTable.flags.ftrMultiTileArch);
EXPECT_FALSE(featureTable.flags.ftrCCSMultiInstance);
EXPECT_FALSE(featureTable.flags.ftrLinearCCS);
EXPECT_FALSE(gtSystemInfo.IsL3HashModeEnabled);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
@ -41,7 +40,6 @@ XEHPTEST_F(XeHPHwInfoTest, whenSetupHardwareInfoWithSetupFeatureTableFlagTrueOrF
EXPECT_FALSE(featureTable.flags.ftrCCSNode);
EXPECT_FALSE(featureTable.flags.ftrCCSRing);
EXPECT_FALSE(featureTable.flags.ftrMultiTileArch);
EXPECT_FALSE(featureTable.flags.ftrCCSMultiInstance);
EXPECT_FALSE(featureTable.flags.ftrLinearCCS);
EXPECT_FALSE(gtSystemInfo.IsL3HashModeEnabled);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
@ -55,7 +53,6 @@ XEHPTEST_F(XeHPHwInfoTest, whenSetupHardwareInfoWithSetupFeatureTableFlagTrueOrF
EXPECT_TRUE(featureTable.flags.ftrCCSNode);
EXPECT_TRUE(featureTable.flags.ftrCCSRing);
EXPECT_TRUE(featureTable.flags.ftrMultiTileArch);
EXPECT_TRUE(featureTable.flags.ftrCCSMultiInstance);
EXPECT_TRUE(featureTable.flags.ftrLinearCCS);
EXPECT_FALSE(gtSystemInfo.IsL3HashModeEnabled);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);

9
shared/offline_compiler/source/ocloc_igc_facade.cpp
View File

@ -132,21 +132,12 @@ CIF::RAII::UPtr_t<IGC::IgcFeaturesAndWorkaroundsTagOCL> OclocIgcFacade::getIgcFe
}
void OclocIgcFacade::populateWithFeatures(IGC::IgcFeaturesAndWorkaroundsTagOCL *handle, const HardwareInfo &hwInfo, const CompilerHwInfoConfig *compilerHwInfoConfig) const {
handle->SetFtrDesktop(hwInfo.featureTable.flags.ftrDesktop);
handle->SetFtrChannelSwizzlingXOREnabled(hwInfo.featureTable.flags.ftrChannelSwizzlingXOREnabled);
handle->SetFtrIVBM0M1Platform(hwInfo.featureTable.flags.ftrIVBM0M1Platform);
handle->SetFtrSGTPVSKUStrapPresent(hwInfo.featureTable.flags.ftrSGTPVSKUStrapPresent);
handle->SetFtr5Slice(hwInfo.featureTable.flags.ftr5Slice);
if (compilerHwInfoConfig) {
handle->SetFtrGpGpuMidThreadLevelPreempt(compilerHwInfoConfig->isMidThreadPreemptionSupported(hwInfo));
}
handle->SetFtrIoMmuPageFaulting(hwInfo.featureTable.flags.ftrIoMmuPageFaulting);
handle->SetFtrWddm2Svm(hwInfo.featureTable.flags.ftrWddm2Svm);
handle->SetFtrPooledEuEnabled(hwInfo.featureTable.flags.ftrPooledEuEnabled);
handle->SetFtrResourceStreamer(hwInfo.featureTable.flags.ftrResourceStreamer);
}
CIF::RAII::UPtr_t<CIF::Builtins::BufferLatest> OclocIgcFacade::createConstBuffer(const void *data, size_t size) {

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

@ -439,18 +439,10 @@ IGC::IgcOclDeviceCtxTagOCL *CompilerInterface::getIgcDeviceCtx(const Device &dev
IGC::PlatformHelper::PopulateInterfaceWith(*igcPlatform, hwInfo->platform);
IGC::GtSysInfoHelper::PopulateInterfaceWith(*igcGtSystemInfo, hwInfo->gtSystemInfo);
igcFtrWa->SetFtrDesktop(device.getHardwareInfo().featureTable.flags.ftrDesktop);
igcFtrWa->SetFtrChannelSwizzlingXOREnabled(device.getHardwareInfo().featureTable.flags.ftrChannelSwizzlingXOREnabled);
igcFtrWa->SetFtrIVBM0M1Platform(device.getHardwareInfo().featureTable.flags.ftrIVBM0M1Platform);
igcFtrWa->SetFtrSGTPVSKUStrapPresent(device.getHardwareInfo().featureTable.flags.ftrSGTPVSKUStrapPresent);
igcFtrWa->SetFtr5Slice(device.getHardwareInfo().featureTable.flags.ftr5Slice);
igcFtrWa->SetFtrGpGpuMidThreadLevelPreempt(CompilerHwInfoConfig::get(hwInfo->platform.eProductFamily)->isMidThreadPreemptionSupported(*hwInfo));
igcFtrWa->SetFtrIoMmuPageFaulting(device.getHardwareInfo().featureTable.flags.ftrIoMmuPageFaulting);
igcFtrWa->SetFtrWddm2Svm(device.getHardwareInfo().featureTable.flags.ftrWddm2Svm);
igcFtrWa->SetFtrPooledEuEnabled(device.getHardwareInfo().featureTable.flags.ftrPooledEuEnabled);
igcFtrWa->SetFtrResourceStreamer(device.getHardwareInfo().featureTable.flags.ftrResourceStreamer);
igcDeviceContexts[&device] = std::move(newDeviceCtx);
return igcDeviceContexts[&device].get();
}

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

@ -95,25 +95,18 @@ void EHL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
};
void EHL::setupHardwareInfoBase(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {

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

@ -95,25 +95,18 @@ void ICLLP::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
};
void ICLLP::setupHardwareInfoBase(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {

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

@ -95,25 +95,18 @@ void LKF::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidThreadLevelPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
};
void LKF::setupHardwareInfoBase(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {

7
shared/source/gen12lp/hw_info_adln.cpp
View File

@ -94,24 +94,17 @@ void ADLN::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waUntypedBufferCompression = true;
};

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

@ -95,24 +95,17 @@ void ADLP::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = false;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waUntypedBufferCompression = true;
};

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

@ -95,24 +95,17 @@ void ADLS::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waUntypedBufferCompression = true;
};

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

@ -97,25 +97,18 @@ void DG1::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->ftrBcsInfo = maxNBitValue(1);
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
};
void DG1::setupHardwareInfoBase(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {

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

@ -95,24 +95,17 @@ void RKL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
};
void RKL::setupHardwareInfoBase(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {

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

@ -95,24 +95,17 @@ void TGLLP::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrFbcCpuTracking = true;
featureTable->flags.ftrTileY = true;
featureTable->flags.ftrAstcHdr2D = true;
featureTable->flags.ftrAstcLdr2D = true;
featureTable->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
workaroundTable->flags.waUntypedBufferCompression = true;
};

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

@ -90,13 +90,9 @@ void BDW::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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->flags.waDisableLSQCROPERFforOCL = true;
workaroundTable->flags.waReportPerfCountUseGlobalContextID = true;
workaroundTable->flags.waUseVAlign16OnTileXYBpp816 = true;
workaroundTable->flags.waModifyVFEStateAfterGPGPUPreemption = true;
workaroundTable->flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads = true;

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

@ -82,7 +82,6 @@ WorkaroundTable BXT::workaroundTable = {};
FeatureTable BXT::featureTable = {};
void BXT::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
PLATFORM *platform = &hwInfo->platform;
FeatureTable *featureTable = &hwInfo->featureTable;
WorkaroundTable *workaroundTable = &hwInfo->workaroundTable;
@ -91,34 +90,20 @@ void BXT::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
featureTable->flags.ftrL3IACoherency = 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->flags.ftrGttCacheInvalidation = 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;
}

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

@ -89,25 +89,16 @@ void CFL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrTileY = 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;

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

@ -89,15 +89,11 @@ void GLK::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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;
@ -108,10 +104,7 @@ void GLK::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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;
}

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

@ -90,25 +90,16 @@ void KBL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrTileY = 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;
@ -119,9 +110,6 @@ void KBL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
workaroundTable->flags.waDisableLSQCROPERFforOCL = true;
workaroundTable->flags.waEncryptedEdramOnlyPartials = true;
}
if (platform->usRevId <= 0x8) {
workaroundTable->flags.waForcePcBbFullCfgRestore = true;
}
}
void KBL::setupHardwareInfoBase(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {

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

@ -88,25 +88,16 @@ void SKL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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.ftrTileY = 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;
@ -114,7 +105,6 @@ void SKL::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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) {

26
shared/source/os_interface/windows/sharedata_wrapper.h
View File

@ -48,55 +48,34 @@ static constexpr COMMAND_BUFFER_HEADER initCommandBufferHeader(uint32_t umdConte
#else
struct SKU_FEATURE_TABLE_KMD : SKU_FEATURE_TABLE_GMM {
bool FtrDesktop : 1;
bool FtrChannelSwizzlingXOREnabled : 1;
bool FtrIVBM0M1Platform : 1;
bool FtrSGTPVSKUStrapPresent : 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 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 FtrWddm2GpuMmu : 1;
@ -105,7 +84,6 @@ struct SKU_FEATURE_TABLE_KMD : SKU_FEATURE_TABLE_GMM {
bool FtrMemTypeMocsDeferPAT : 1;
bool FtrKmdDaf : 1;
bool FtrSimulationMode : 1;
bool FtrE2ECompression : 1;
bool FtrLinearCCS : 1;
@ -117,11 +95,8 @@ struct SKU_FEATURE_TABLE_KMD : SKU_FEATURE_TABLE_GMM {
};
struct WA_TABLE_KMD : WA_TABLE_GMM {
bool WaDoNotUseMIReportPerfCount = false;
bool WaEnablePreemptionGranularityControlByUMD = false;
bool WaSendMIFLUSHBeforeVFE = false;
bool WaReportPerfCountUseGlobalContextID = false;
bool WaDisableLSQCROPERFforOCL = false;
bool WaMsaa8xTileYDepthPitchAlignment = false;
bool WaLosslessCompressionSurfaceStride = false;
@ -129,7 +104,6 @@ struct WA_TABLE_KMD : WA_TABLE_GMM {
bool Wa4kAlignUVOffsetNV12LinearSurface = false;
bool WaEncryptedEdramOnlyPartials = false;
bool WaDisableEdramForDisplayRT = false;
bool WaForcePcBbFullCfgRestore = false;
bool WaCompressedResourceRequiresConstVA21 = false;
bool WaDisablePerCtxtPreemptionGranularityControl = false;
bool WaLLCCachingUnsupported = false;

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

@ -23,7 +23,6 @@ class SkuInfoTransfer {
TRANSFER_FTR_TO_GMM(ULT);
TRANSFER_FTR_TO_GMM(EDram);
TRANSFER_FTR_TO_GMM(FrameBufferLLC);
TRANSFER_FTR_TO_GMM(Crystalwell);
TRANSFER_FTR_TO_GMM(DisplayEngineS3d);
TRANSFER_FTR_TO_GMM(TileY);
TRANSFER_FTR_TO_GMM(DisplayYTiling);
@ -46,7 +45,6 @@ class SkuInfoTransfer {
TRANSFER_FTR_TO_GMM(SVM);
TRANSFER_FTR_TO_GMM(FlatPhysCCS);
TRANSFER_FTR_TO_GMM(MultiTileArch);
TRANSFER_FTR_TO_GMM(CCSMultiInstance);
TRANSFER_FTR_TO_GMM(Ppgtt64KBWalkOptimization);
TRANSFER_FTR_TO_GMM(Unified3DMediaCompressionFormats);
TRANSFER_FTR_TO_GMM(57bGPUAddressing);

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

@ -20,62 +20,40 @@ class SkuInfoReceiver {
protected:
static void receiveFtrTableFromAdapterInfoBase(FeatureTable *ftrTable, ADAPTER_INFO_KMD *adapterInfo) {
#define RECEIVE_FTR(VAL_NAME) ftrTable->flags.ftr##VAL_NAME = adapterInfo->SkuTable.Ftr##VAL_NAME
RECEIVE_FTR(Desktop);
RECEIVE_FTR(ChannelSwizzlingXOREnabled);
RECEIVE_FTR(IVBM0M1Platform);
RECEIVE_FTR(SGTPVSKUStrapPresent);
RECEIVE_FTR(5Slice);
RECEIVE_FTR(GpGpuMidBatchPreempt);
RECEIVE_FTR(GpGpuThreadGroupLevelPreempt);
RECEIVE_FTR(GpGpuMidThreadLevelPreempt);
RECEIVE_FTR(IoMmuPageFaulting);
RECEIVE_FTR(Wddm2Svm);
RECEIVE_FTR(PooledEuEnabled);
RECEIVE_FTR(ResourceStreamer);
RECEIVE_FTR(PPGTT);
RECEIVE_FTR(SVM);
RECEIVE_FTR(EDram);
RECEIVE_FTR(L3IACoherency);
RECEIVE_FTR(IA32eGfxPTEs);
RECEIVE_FTR(3dMidBatchPreempt);
RECEIVE_FTR(3dObjectLevelPreempt);
RECEIVE_FTR(PerCtxtPreemptionGranularityControl);
RECEIVE_FTR(TileY);
RECEIVE_FTR(DisplayYTiling);
RECEIVE_FTR(TranslationTable);
RECEIVE_FTR(UserModeTranslationTable);
RECEIVE_FTR(EnableGuC);
RECEIVE_FTR(Fbc);
RECEIVE_FTR(Fbc2AddressTranslation);
RECEIVE_FTR(FbcBlitterTracking);
RECEIVE_FTR(FbcCpuTracking);
RECEIVE_FTR(ULT);
RECEIVE_FTR(LCIA);
RECEIVE_FTR(GttCacheInvalidation);
RECEIVE_FTR(TileMappedResource);
RECEIVE_FTR(AstcHdr2D);
RECEIVE_FTR(AstcLdr2D);
RECEIVE_FTR(StandardMipTailFormat);
RECEIVE_FTR(FrameBufferLLC);
RECEIVE_FTR(Crystalwell);
RECEIVE_FTR(LLCBypass);
RECEIVE_FTR(DisplayEngineS3d);
RECEIVE_FTR(Wddm2GpuMmu);
RECEIVE_FTR(Wddm2_1_64kbPages);
RECEIVE_FTR(KmdDaf);
RECEIVE_FTR(SimulationMode);
RECEIVE_FTR(E2ECompression);
RECEIVE_FTR(LinearCCS);
@ -86,7 +64,6 @@ class SkuInfoReceiver {
RECEIVE_FTR(LocalMemoryAllows4KB);
RECEIVE_FTR(FlatPhysCCS);
RECEIVE_FTR(MultiTileArch);
RECEIVE_FTR(CCSMultiInstance);
RECEIVE_FTR(Ppgtt64KBWalkOptimization);
RECEIVE_FTR(Unified3DMediaCompressionFormats);
RECEIVE_FTR(57bGPUAddressing);
@ -96,11 +73,8 @@ class SkuInfoReceiver {
static void receiveWaTableFromAdapterInfoBase(WorkaroundTable *workaroundTable, ADAPTER_INFO_KMD *adapterInfo) {
#define RECEIVE_WA(VAL_NAME) workaroundTable->flags.wa##VAL_NAME = adapterInfo->WaTable.Wa##VAL_NAME
RECEIVE_WA(DoNotUseMIReportPerfCount);
RECEIVE_WA(EnablePreemptionGranularityControlByUMD);
RECEIVE_WA(SendMIFLUSHBeforeVFE);
RECEIVE_WA(ReportPerfCountUseGlobalContextID);
RECEIVE_WA(DisableLSQCROPERFforOCL);
RECEIVE_WA(Msaa8xTileYDepthPitchAlignment);
RECEIVE_WA(LosslessCompressionSurfaceStride);
@ -108,7 +82,6 @@ class SkuInfoReceiver {
RECEIVE_WA(4kAlignUVOffsetNV12LinearSurface);
RECEIVE_WA(EncryptedEdramOnlyPartials);
RECEIVE_WA(DisableEdramForDisplayRT);
RECEIVE_WA(ForcePcBbFullCfgRestore);
RECEIVE_WA(CompressedResourceRequiresConstVA21);
RECEIVE_WA(DisablePerCtxtPreemptionGranularityControl);
RECEIVE_WA(LLCCachingUnsupported);

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

@ -23,45 +23,28 @@ struct FeatureTableBase {
struct Flags {
// DW0
uint32_t ftrDesktop : 1;
uint32_t ftrChannelSwizzlingXOREnabled : 1;
uint32_t ftrIVBM0M1Platform : 1;
uint32_t ftrSGTPVSKUStrapPresent : 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;
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 ftrULT : 1;
uint32_t ftrLCIA : 1;
uint32_t ftrGttCacheInvalidation : 1;
// DW1
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 ftrWddm2GpuMmu : 1;
@ -69,21 +52,20 @@ struct FeatureTableBase {
uint32_t ftrWddmHwQueues : 1;
uint32_t ftrMemTypeMocsDeferPAT : 1;
uint32_t ftrKmdDaf : 1;
uint32_t ftrSimulationMode : 1;
uint32_t ftrE2ECompression : 1;
uint32_t ftrLinearCCS : 1;
uint32_t ftrCCSRing : 1;
// DW1
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 ftr57bGPUAddressing : 1;
uint32_t reserved : 5;
uint32_t reserved : 23;
};
BcsInfoMask ftrBcsInfo = 1;
@ -100,10 +82,7 @@ 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;
@ -111,7 +90,6 @@ struct WorkaroundTableBase {
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;
@ -125,7 +103,7 @@ struct WorkaroundTableBase {
uint32_t waAuxTable16KGranular : 1;
uint32_t waDisableFusedThreadScheduling : 1;
uint32_t waAuxTable64KGranular : 1;
uint32_t reserved : 7;
uint32_t reserved : 11;
};
union {

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

@ -99,17 +99,12 @@ void XE_HP_SDV::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftrTileY = false;
featureTable->flags.ftrLocalMemory = true;
@ -118,10 +113,8 @@ void XE_HP_SDV::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
featureTable->flags.ftrCCSNode = true;
featureTable->flags.ftrCCSRing = true;
featureTable->flags.ftrMultiTileArch = true;
featureTable->flags.ftrCCSMultiInstance = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
};
void XE_HP_SDV::setupHardwareInfoBase(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {

7
shared/source/xe_hpc_core/hw_info_pvc.cpp
View File

@ -104,7 +104,6 @@ void PVC::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
featureTable->flags.ftrCCSNode = true;
featureTable->flags.ftrCCSRing = true;
featureTable->flags.ftrMultiTileArch = true;
featureTable->flags.ftrCCSMultiInstance = true;
featureTable->flags.ftrPPGTT = true;
featureTable->flags.ftrSVM = true;
@ -114,22 +113,16 @@ void PVC::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftrTileY = false;
featureTable->ftrBcsInfo = maxNBitValue(9);
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
}
void PVC::adjustHardwareInfo(HardwareInfo *hwInfo) {

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

@ -99,17 +99,12 @@ void DG2::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
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->flags.ftr3dMidBatchPreempt = true;
featureTable->flags.ftrGpGpuMidBatchPreempt = true;
featureTable->flags.ftrGpGpuThreadGroupLevelPreempt = true;
featureTable->flags.ftrPerCtxtPreemptionGranularityControl = true;
featureTable->flags.ftrTileY = false;
featureTable->flags.ftrLocalMemory = true;
@ -117,12 +112,10 @@ void DG2::setupFeatureAndWorkaroundTable(HardwareInfo *hwInfo) {
featureTable->flags.ftrE2ECompression = true;
featureTable->flags.ftrCCSNode = true;
featureTable->flags.ftrCCSRing = true;
featureTable->flags.ftrCCSMultiInstance = true;
featureTable->flags.ftrUnified3DMediaCompressionFormats = true;
workaroundTable->flags.wa4kAlignUVOffsetNV12LinearSurface = true;
workaroundTable->flags.waEnablePreemptionGranularityControlByUMD = true;
};
void DG2::setupHardwareInfoBase(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable) {

4
shared/test/unit_test/compiler_interface/compiler_cache_tests.cpp
View File

@ -140,8 +140,8 @@ TEST(CompilerCacheHashTests, GivenCompilingOptionsWhenGettingCacheThenCorrectCac
const FeatureTable *skus[] = {&s1, &s2};
WorkaroundTable w1;
WorkaroundTable w2;
w1.flags.waDoNotUseMIReportPerfCount = true;
w2.flags.waDoNotUseMIReportPerfCount = false;
w1.flags.wa4kAlignUVOffsetNV12LinearSurface = true;
w2.flags.wa4kAlignUVOffsetNV12LinearSurface = false;
const WorkaroundTable *was[] = {&w1, &w2};
std::array<std::string, 4> inputArray = {{std::string(""),

7
shared/test/unit_test/gen11/ehl/test_hw_info_config_ehl.cpp
View File

@ -50,22 +50,15 @@ EHLTEST_F(EhlHwInfo, givenBoolWhenCallEhlHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcLdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waReportPerfCountUseGlobalContextID);
}
}

7
shared/test/unit_test/gen11/icllp/test_hw_info_config_icllp.cpp
View File

@ -77,22 +77,15 @@ ICLLPTEST_F(IcllpHwInfo, givenBoolWhenCallIcllpHardwareInfoSetupThenFeatureTable
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcLdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waReportPerfCountUseGlobalContextID);
}
}
}

7
shared/test/unit_test/gen11/lkf/test_hw_info_config_lkf.cpp
View File

@ -69,22 +69,15 @@ LKFTEST_F(LkfHwInfo, givenBoolWhenCallLkfHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcLdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waReportPerfCountUseGlobalContextID);
}
}

8
shared/test/unit_test/gen12lp/adln/test_hw_info_config_adln.cpp
View File

@ -42,21 +42,15 @@ ADLNTEST_F(AdlnHwInfo, givenBoolWhenCallAdlnHardwareInfoSetupThenFeatureTableAnd
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcLdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_EQ(setParamBool, workaroundTable.flags.waUntypedBufferCompression);
}
}

16
shared/test/unit_test/gen12lp/adlp/linux/hw_info_config_tests_adlp.cpp
View File

@ -90,21 +90,15 @@ TYPED_TEST(AdlpConfigHwInfoTests, givenAdlpConfigWhenSetupHardwareInfoThenGtSyst
EXPECT_FALSE(featureTable.flags.ftrTranslationTable);
EXPECT_FALSE(featureTable.flags.ftrUserModeTranslationTable);
EXPECT_FALSE(featureTable.flags.ftrTileMappedResource);
EXPECT_FALSE(featureTable.flags.ftrEnableGuC);
EXPECT_FALSE(featureTable.flags.ftrFbc);
EXPECT_FALSE(featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_FALSE(featureTable.flags.ftrFbcBlitterTracking);
EXPECT_FALSE(featureTable.flags.ftrFbcCpuTracking);
EXPECT_FALSE(featureTable.flags.ftrTileY);
EXPECT_FALSE(featureTable.flags.ftrAstcHdr2D);
EXPECT_FALSE(featureTable.flags.ftrAstcLdr2D);
EXPECT_FALSE(featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_FALSE(featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_FALSE(featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_FALSE(featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_FALSE(workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_FALSE(workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_FALSE(workaroundTable.flags.waUntypedBufferCompression);
}
ret = drm.setupHardwareInfo(&device, true);
@ -126,21 +120,15 @@ TYPED_TEST(AdlpConfigHwInfoTests, givenAdlpConfigWhenSetupHardwareInfoThenGtSyst
EXPECT_TRUE(featureTable.flags.ftrTranslationTable);
EXPECT_TRUE(featureTable.flags.ftrUserModeTranslationTable);
EXPECT_TRUE(featureTable.flags.ftrTileMappedResource);
EXPECT_TRUE(featureTable.flags.ftrEnableGuC);
EXPECT_TRUE(featureTable.flags.ftrFbc);
EXPECT_TRUE(featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_TRUE(featureTable.flags.ftrFbcBlitterTracking);
EXPECT_TRUE(featureTable.flags.ftrFbcCpuTracking);
EXPECT_FALSE(featureTable.flags.ftrTileY);
EXPECT_TRUE(featureTable.flags.ftrAstcHdr2D);
EXPECT_TRUE(featureTable.flags.ftrAstcLdr2D);
EXPECT_TRUE(featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_TRUE(featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_TRUE(featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_TRUE(featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_TRUE(workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_TRUE(workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_TRUE(workaroundTable.flags.waUntypedBufferCompression);
}
}

7
shared/test/unit_test/gen12lp/adlp/test_hw_info_config_adlp.cpp
View File

@ -42,21 +42,14 @@ ADLPTEST_F(AdlpHwInfo, givenBoolWhenCallAdlpHardwareInfoSetupThenFeatureTableAnd
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_FALSE(featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcLdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_EQ(setParamBool, workaroundTable.flags.waUntypedBufferCompression);
}
}

7
shared/test/unit_test/gen12lp/adls/test_hw_info_config_adls.cpp
View File

@ -42,21 +42,14 @@ ADLSTEST_F(AdlsHwInfo, givenBoolWhenCallAdlsHardwareInfoSetupThenFeatureTableAnd
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcLdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_EQ(setParamBool, workaroundTable.flags.waUntypedBufferCompression);
}
}

7
shared/test/unit_test/gen12lp/dg1/test_hw_info_config_dg1.cpp
View File

@ -86,21 +86,14 @@ DG1TEST_F(Dg1HwInfo, givenBoolWhenCallDg1HardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcLdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
}
}

7
shared/test/unit_test/gen12lp/rkl/test_hw_info_config_rkl.cpp
View File

@ -45,23 +45,16 @@ RKLTEST_F(RklHwInfo, givenBoolWhenCallRklHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcLdr2D);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
}
}
}

4
shared/test/unit_test/gen8/bdw/test_hw_info_config_bdw.cpp
View File

@ -60,13 +60,9 @@ BDWTEST_F(BdwHwInfo, givenBoolWhenCallBdwHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrSVM);
EXPECT_EQ(setParamBool, featureTable.flags.ftrIA32eGfxPTEs);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, workaroundTable.flags.waDisableLSQCROPERFforOCL);
EXPECT_EQ(setParamBool, workaroundTable.flags.waReportPerfCountUseGlobalContextID);
EXPECT_EQ(setParamBool, workaroundTable.flags.waUseVAlign16OnTileXYBpp816);
EXPECT_EQ(setParamBool, workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption);
EXPECT_EQ(setParamBool, workaroundTable.flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads);

1
shared/test/unit_test/gen9/bxt/linux/hw_info_config_tests.cpp
View File

@ -30,7 +30,6 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, WhenConfiguringHwInfoThenConfigIsCorrect) {
EXPECT_EQ((unsigned int)drm->storedHasPooledEU, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->storedMinEUinPool, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrGttCacheInvalidation);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
//constant sysInfo/ftr flags

17
shared/test/unit_test/gen9/bxt/test_hw_info_config_bxt.cpp
View File

@ -59,38 +59,21 @@ BXTTEST_F(BxtHwInfo, givenBoolWhenCallBxtHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrL3IACoherency);
EXPECT_EQ(setParamBool, featureTable.flags.ftrULT);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dObjectLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, featureTable.flags.ftrLCIA);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPPGTT);
EXPECT_EQ(setParamBool, featureTable.flags.ftrIA32eGfxPTEs);
EXPECT_EQ(setParamBool, featureTable.flags.ftrDisplayYTiling);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGttCacheInvalidation);
EXPECT_EQ(setParamBool, workaroundTable.flags.waLLCCachingUnsupported);
EXPECT_EQ(setParamBool, workaroundTable.flags.waMsaa8xTileYDepthPitchAlignment);
EXPECT_EQ(setParamBool, workaroundTable.flags.waFbcLinearSurfaceStride);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_EQ(setParamBool, workaroundTable.flags.waSendMIFLUSHBeforeVFE);
EXPECT_EQ(setParamBool, workaroundTable.flags.waForcePcBbFullCfgRestore);
EXPECT_EQ(setParamBool, workaroundTable.flags.waReportPerfCountUseGlobalContextID);
EXPECT_EQ(setParamBool, workaroundTable.flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
platform.usRevId = 1;
featureTable = {};
hardwareInfoSetup[productFamily](&hwInfo, true, config);
EXPECT_EQ(false, featureTable.flags.ftrGttCacheInvalidation);
}
}
}

9
shared/test/unit_test/gen9/cfl/test_hw_info_config_cfl.cpp
View File

@ -60,25 +60,16 @@ CFLTEST_F(CflHwInfo, givenBoolWhenCallCflHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrL3IACoherency);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dObjectLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPPGTT);
EXPECT_EQ(setParamBool, featureTable.flags.ftrSVM);
EXPECT_EQ(setParamBool, featureTable.flags.ftrIA32eGfxPTEs);
EXPECT_EQ(setParamBool, featureTable.flags.ftrDisplayYTiling);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_EQ(setParamBool, workaroundTable.flags.waSendMIFLUSHBeforeVFE);
EXPECT_EQ(setParamBool, workaroundTable.flags.waReportPerfCountUseGlobalContextID);
EXPECT_EQ(setParamBool, workaroundTable.flags.waMsaa8xTileYDepthPitchAlignment);
EXPECT_EQ(setParamBool, workaroundTable.flags.waLosslessCompressionSurfaceStride);
EXPECT_EQ(setParamBool, workaroundTable.flags.waFbcLinearSurfaceStride);

7
shared/test/unit_test/gen9/glk/test_hw_info_config_glk.cpp
View File

@ -57,15 +57,11 @@ GLKTEST_F(GlkHwInfo, givenBoolWhenCallGlkHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrL3IACoherency);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dObjectLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, featureTable.flags.ftrLCIA);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPPGTT);
EXPECT_EQ(setParamBool, featureTable.flags.ftrIA32eGfxPTEs);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileMappedResource);
EXPECT_EQ(setParamBool, featureTable.flags.ftrULT);
EXPECT_EQ(setParamBool, featureTable.flags.ftrAstcHdr2D);
@ -76,10 +72,7 @@ GLKTEST_F(GlkHwInfo, givenBoolWhenCallGlkHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, workaroundTable.flags.waMsaa8xTileYDepthPitchAlignment);
EXPECT_EQ(setParamBool, workaroundTable.flags.waFbcLinearSurfaceStride);
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_EQ(setParamBool, workaroundTable.flags.waSendMIFLUSHBeforeVFE);
EXPECT_EQ(setParamBool, workaroundTable.flags.waForcePcBbFullCfgRestore);
EXPECT_EQ(setParamBool, workaroundTable.flags.waReportPerfCountUseGlobalContextID);
EXPECT_EQ(setParamBool, workaroundTable.flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
}
}

1
shared/test/unit_test/gen9/kbl/linux/hw_info_config_tests_kbl.cpp
View File

@ -107,7 +107,6 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, GivenWaFlagsWhenConfiguringHwInfoThenInforma
EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waDisableLSQCROPERFforOCL);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waEncryptedEdramOnlyPartials);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waForcePcBbFullCfgRestore);
}
KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenEdramInformationIsCorrect) {

11
shared/test/unit_test/gen9/kbl/test_hw_info_config_kbl.cpp
View File

@ -60,25 +60,16 @@ KBLTEST_F(KblHwInfo, givenBoolWhenCallKblHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrL3IACoherency);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dObjectLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPPGTT);
EXPECT_EQ(setParamBool, featureTable.flags.ftrSVM);
EXPECT_EQ(setParamBool, featureTable.flags.ftrIA32eGfxPTEs);
EXPECT_EQ(setParamBool, featureTable.flags.ftrDisplayYTiling);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_EQ(setParamBool, workaroundTable.flags.waSendMIFLUSHBeforeVFE);
EXPECT_EQ(setParamBool, workaroundTable.flags.waReportPerfCountUseGlobalContextID);
EXPECT_EQ(setParamBool, workaroundTable.flags.waMsaa8xTileYDepthPitchAlignment);
EXPECT_EQ(setParamBool, workaroundTable.flags.waLosslessCompressionSurfaceStride);
EXPECT_EQ(setParamBool, workaroundTable.flags.waFbcLinearSurfaceStride);
@ -86,7 +77,6 @@ KBLTEST_F(KblHwInfo, givenBoolWhenCallKblHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, workaroundTable.flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
EXPECT_EQ(false, workaroundTable.flags.waDisableLSQCROPERFforOCL);
EXPECT_EQ(false, workaroundTable.flags.waEncryptedEdramOnlyPartials);
EXPECT_EQ(false, workaroundTable.flags.waForcePcBbFullCfgRestore);
platform.usRevId = 1;
workaroundTable = {};
@ -94,7 +84,6 @@ KBLTEST_F(KblHwInfo, givenBoolWhenCallKblHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(true, workaroundTable.flags.waDisableLSQCROPERFforOCL);
EXPECT_EQ(true, workaroundTable.flags.waEncryptedEdramOnlyPartials);
EXPECT_EQ(true, workaroundTable.flags.waForcePcBbFullCfgRestore);
}
}
}

10
shared/test/unit_test/gen9/skl/test_hw_info_config_skl.cpp
View File

@ -62,25 +62,16 @@ SKLTEST_F(SklHwInfo, givenBoolWhenCallSklHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuThreadGroupLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrL3IACoherency);
EXPECT_EQ(setParamBool, featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dMidBatchPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftr3dObjectLevelPreempt);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPerCtxtPreemptionGranularityControl);
EXPECT_EQ(setParamBool, featureTable.flags.ftrPPGTT);
EXPECT_EQ(setParamBool, featureTable.flags.ftrSVM);
EXPECT_EQ(setParamBool, featureTable.flags.ftrIA32eGfxPTEs);
EXPECT_EQ(setParamBool, featureTable.flags.ftrDisplayYTiling);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrUserModeTranslationTable);
EXPECT_EQ(setParamBool, featureTable.flags.ftrEnableGuC);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbc2AddressTranslation);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcBlitterTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrFbcCpuTracking);
EXPECT_EQ(setParamBool, featureTable.flags.ftrTileY);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEnablePreemptionGranularityControlByUMD);
EXPECT_EQ(setParamBool, workaroundTable.flags.waSendMIFLUSHBeforeVFE);
EXPECT_EQ(setParamBool, workaroundTable.flags.waReportPerfCountUseGlobalContextID);
EXPECT_EQ(setParamBool, workaroundTable.flags.waDisableLSQCROPERFforOCL);
EXPECT_EQ(setParamBool, workaroundTable.flags.waMsaa8xTileYDepthPitchAlignment);
EXPECT_EQ(setParamBool, workaroundTable.flags.waLosslessCompressionSurfaceStride);
@ -88,7 +79,6 @@ SKLTEST_F(SklHwInfo, givenBoolWhenCallSklHardwareInfoSetupThenFeatureTableAndWor
EXPECT_EQ(setParamBool, workaroundTable.flags.wa4kAlignUVOffsetNV12LinearSurface);
EXPECT_EQ(setParamBool, workaroundTable.flags.waEncryptedEdramOnlyPartials);
EXPECT_EQ(setParamBool, workaroundTable.flags.waDisableEdramForDisplayRT);
EXPECT_EQ(setParamBool, workaroundTable.flags.waForcePcBbFullCfgRestore);
EXPECT_EQ(setParamBool, workaroundTable.flags.waSamplerCacheFlushBetweenRedescribedSurfaceReads);
EXPECT_EQ(false, workaroundTable.flags.waCompressedResourceRequiresConstVA21);
EXPECT_EQ(false, workaroundTable.flags.waDisablePerCtxtPreemptionGranularityControl);

29
shared/test/unit_test/sku_info/sku_info_base_reference.h
View File

@ -19,7 +19,6 @@ struct SkuInfoBaseReference {
refFtrTable.FtrULT = 1;
refFtrTable.FtrEDram = 1;
refFtrTable.FtrFrameBufferLLC = 1;
refFtrTable.FtrCrystalwell = 1;
refFtrTable.FtrDisplayEngineS3d = 1;
refFtrTable.FtrTileY = 1;
refFtrTable.FtrDisplayYTiling = 1;
@ -44,7 +43,6 @@ struct SkuInfoBaseReference {
refFtrTable.FtrSVM = 1;
refFtrTable.FtrFlatPhysCCS = 1;
refFtrTable.FtrMultiTileArch = 1;
refFtrTable.FtrCCSMultiInstance = 1;
refFtrTable.FtrPpgtt64KBWalkOptimization = 1;
refFtrTable.FtrUnified3DMediaCompressionFormats = 1;
refFtrTable.Ftr57bGPUAddressing = 1;
@ -65,62 +63,40 @@ struct SkuInfoBaseReference {
static void fillReferenceFtrToReceive(FeatureTable &refFtrTable) {
refFtrTable = {};
refFtrTable.flags.ftrDesktop = true;
refFtrTable.flags.ftrChannelSwizzlingXOREnabled = true;
refFtrTable.flags.ftrIVBM0M1Platform = true;
refFtrTable.flags.ftrSGTPVSKUStrapPresent = true;
refFtrTable.flags.ftr5Slice = true;
refFtrTable.flags.ftrGpGpuMidBatchPreempt = true;
refFtrTable.flags.ftrGpGpuThreadGroupLevelPreempt = true;
refFtrTable.flags.ftrGpGpuMidThreadLevelPreempt = true;
refFtrTable.flags.ftrIoMmuPageFaulting = true;
refFtrTable.flags.ftrWddm2Svm = true;
refFtrTable.flags.ftrPooledEuEnabled = true;
refFtrTable.flags.ftrResourceStreamer = true;
refFtrTable.flags.ftrPPGTT = true;
refFtrTable.flags.ftrSVM = true;
refFtrTable.flags.ftrEDram = true;
refFtrTable.flags.ftrL3IACoherency = true;
refFtrTable.flags.ftrIA32eGfxPTEs = true;
refFtrTable.flags.ftr3dMidBatchPreempt = true;
refFtrTable.flags.ftr3dObjectLevelPreempt = true;
refFtrTable.flags.ftrPerCtxtPreemptionGranularityControl = true;
refFtrTable.flags.ftrTileY = true;
refFtrTable.flags.ftrDisplayYTiling = true;
refFtrTable.flags.ftrTranslationTable = true;
refFtrTable.flags.ftrUserModeTranslationTable = true;
refFtrTable.flags.ftrEnableGuC = true;
refFtrTable.flags.ftrFbc = true;
refFtrTable.flags.ftrFbc2AddressTranslation = true;
refFtrTable.flags.ftrFbcBlitterTracking = true;
refFtrTable.flags.ftrFbcCpuTracking = true;
refFtrTable.flags.ftrULT = true;
refFtrTable.flags.ftrLCIA = true;
refFtrTable.flags.ftrGttCacheInvalidation = true;
refFtrTable.flags.ftrTileMappedResource = true;
refFtrTable.flags.ftrAstcHdr2D = true;
refFtrTable.flags.ftrAstcLdr2D = true;
refFtrTable.flags.ftrStandardMipTailFormat = true;
refFtrTable.flags.ftrFrameBufferLLC = true;
refFtrTable.flags.ftrCrystalwell = true;
refFtrTable.flags.ftrLLCBypass = true;
refFtrTable.flags.ftrDisplayEngineS3d = true;
refFtrTable.flags.ftrWddm2GpuMmu = true;
refFtrTable.flags.ftrWddm2_1_64kbPages = true;
refFtrTable.flags.ftrKmdDaf = true;
refFtrTable.flags.ftrSimulationMode = true;
refFtrTable.flags.ftrE2ECompression = true;
refFtrTable.flags.ftrLinearCCS = true;
@ -133,7 +109,6 @@ struct SkuInfoBaseReference {
refFtrTable.flags.ftrFlatPhysCCS = true;
refFtrTable.flags.ftrMultiTileArch = true;
refFtrTable.flags.ftrCCSMultiInstance = true;
refFtrTable.flags.ftrPpgtt64KBWalkOptimization = true;
refFtrTable.flags.ftrUnified3DMediaCompressionFormats = true;
refFtrTable.flags.ftr57bGPUAddressing = true;
@ -141,11 +116,8 @@ struct SkuInfoBaseReference {
static void fillReferenceWaToReceive(WorkaroundTable &refWaTable) {
refWaTable = {};
refWaTable.flags.waDoNotUseMIReportPerfCount = true;
refWaTable.flags.waEnablePreemptionGranularityControlByUMD = true;
refWaTable.flags.waSendMIFLUSHBeforeVFE = true;
refWaTable.flags.waReportPerfCountUseGlobalContextID = true;
refWaTable.flags.waDisableLSQCROPERFforOCL = true;
refWaTable.flags.waMsaa8xTileYDepthPitchAlignment = true;
refWaTable.flags.waLosslessCompressionSurfaceStride = true;
@ -153,7 +125,6 @@ struct SkuInfoBaseReference {
refWaTable.flags.wa4kAlignUVOffsetNV12LinearSurface = true;
refWaTable.flags.waEncryptedEdramOnlyPartials = true;
refWaTable.flags.waDisableEdramForDisplayRT = true;
refWaTable.flags.waForcePcBbFullCfgRestore = true;
refWaTable.flags.waCompressedResourceRequiresConstVA21 = true;
refWaTable.flags.waDisablePerCtxtPreemptionGranularityControl = true;
refWaTable.flags.waLLCCachingUnsupported = true;

5
shared/test/unit_test/sku_info/sku_info_receiver_tests.cpp
View File

@ -31,11 +31,6 @@ TEST(SkuInfoReceiverTest, givenAdapterInfoWhenReceivingThenUpdateFtrTable) {
EXPECT_EQ(1lu, requestedFeatureTable.ftrBcsInfo.to_ulong());
EXPECT_TRUE(refFeatureTable == requestedFeatureTable);
refFeatureTable.flags.ftr3dMidBatchPreempt = false;
requestedFeatureTable.flags.ftr3dMidBatchPreempt = true;
EXPECT_FALSE(refFeatureTable == requestedFeatureTable);
}
TEST(SkuInfoReceiverTest, givenFeatureTableWhenDifferentDataThenEqualityOperatorReturnsCorrectScore) {

126
shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h
View File

@ -1730,27 +1730,12 @@ struct Demarshaller<TOK_S_SKU_FEATURE_TABLE> {
return false;
}
break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP: {
dst.FtrDesktop = readTokValue<decltype(dst.FtrDesktop)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT: {
dst.FtrULT = readTokValue<decltype(dst.FtrULT)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM: {
dst.FtrIVBM0M1Platform = readTokValue<decltype(dst.FtrIVBM0M1Platform)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED: {
dst.FtrChannelSwizzlingXOREnabled = readTokValue<decltype(dst.FtrChannelSwizzlingXOREnabled)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE: {
dst.Ftr5Slice = readTokValue<decltype(dst.Ftr5Slice)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA: {
dst.FtrLCIA = readTokValue<decltype(dst.FtrLCIA)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER: {
dst.FtrResourceStreamer = readTokValue<decltype(dst.FtrResourceStreamer)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING: {
dst.FtrCCSRing = readTokValue<decltype(dst.FtrCCSRing)>(*tok);
} break;
@ -1763,9 +1748,6 @@ struct Demarshaller<TOK_S_SKU_FEATURE_TABLE> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED: {
dst.FtrDisplayDisabled = readTokValue<decltype(dst.FtrDisplayDisabled)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT: {
dst.FtrSGTPVSKUStrapPresent = readTokValue<decltype(dst.FtrSGTPVSKUStrapPresent)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED: {
dst.FtrPooledEuEnabled = readTokValue<decltype(dst.FtrPooledEuEnabled)>(*tok);
} break;
@ -1778,15 +1760,6 @@ struct Demarshaller<TOK_S_SKU_FEATURE_TABLE> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT: {
dst.FtrGpGpuMidThreadLevelPreempt = readTokValue<decltype(dst.FtrGpGpuMidThreadLevelPreempt)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT: {
dst.Ftr3dMidBatchPreempt = readTokValue<decltype(dst.Ftr3dMidBatchPreempt)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT: {
dst.Ftr3dObjectLevelPreempt = readTokValue<decltype(dst.Ftr3dObjectLevelPreempt)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: {
dst.FtrPerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.FtrPerCtxtPreemptionGranularityControl)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT: {
dst.FtrPPGTT = readTokValue<decltype(dst.FtrPPGTT)>(*tok);
} break;
@ -1823,15 +1796,9 @@ struct Demarshaller<TOK_S_SKU_FEATURE_TABLE> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS: {
dst.FtrLLCBypass = readTokValue<decltype(dst.FtrLLCBypass)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL: {
dst.FtrCrystalwell = readTokValue<decltype(dst.FtrCrystalwell)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY: {
dst.FtrCentralCachePolicy = readTokValue<decltype(dst.FtrCentralCachePolicy)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING: {
dst.FtrIoMmuPageFaulting = readTokValue<decltype(dst.FtrIoMmuPageFaulting)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU: {
dst.FtrWddm2GpuMmu = readTokValue<decltype(dst.FtrWddm2GpuMmu)>(*tok);
} break;
@ -1844,9 +1811,6 @@ struct Demarshaller<TOK_S_SKU_FEATURE_TABLE> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES: {
dst.FtrWddm2_1_64kbPages = readTokValue<decltype(dst.FtrWddm2_1_64kbPages)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION: {
dst.FtrGttCacheInvalidation = readTokValue<decltype(dst.FtrGttCacheInvalidation)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION: {
dst.FtrE2ECompression = readTokValue<decltype(dst.FtrE2ECompression)>(*tok);
} break;
@ -1898,15 +1862,6 @@ struct Demarshaller<TOK_S_SKU_FEATURE_TABLE> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC: {
dst.FtrFbc = readTokValue<decltype(dst.FtrFbc)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION: {
dst.FtrFbc2AddressTranslation = readTokValue<decltype(dst.FtrFbc2AddressTranslation)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING: {
dst.FtrFbcBlitterTracking = readTokValue<decltype(dst.FtrFbcBlitterTracking)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING: {
dst.FtrFbcCpuTracking = readTokValue<decltype(dst.FtrFbcCpuTracking)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP: {
dst.FtrRendComp = readTokValue<decltype(dst.FtrRendComp)>(*tok);
} break;
@ -1919,12 +1874,6 @@ struct Demarshaller<TOK_S_SKU_FEATURE_TABLE> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D: {
dst.FtrDisplayEngineS3d = readTokValue<decltype(dst.FtrDisplayEngineS3d)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE: {
dst.FtrSimulationMode = readTokValue<decltype(dst.FtrSimulationMode)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C: {
dst.FtrEnableGuC = readTokValue<decltype(dst.FtrEnableGuC)>(*tok);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT: {
dst.FtrVgt = readTokValue<decltype(dst.FtrVgt)>(*tok);
} break;
@ -1968,9 +1917,6 @@ struct Demarshaller<TOK_S_WA_TABLE> {
return false;
}
break;
case TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT: {
dst.WaDoNotUseMIReportPerfCount = readTokValue<decltype(dst.WaDoNotUseMIReportPerfCount)>(*tok);
} break;
case TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER: {
dst.WaAlignIndexBuffer = readTokValue<decltype(dst.WaAlignIndexBuffer)>(*tok);
} break;
@ -1980,9 +1926,6 @@ struct Demarshaller<TOK_S_WA_TABLE> {
case TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: {
dst.WaDisablePerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.WaDisablePerCtxtPreemptionGranularityControl)>(*tok);
} break;
case TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD: {
dst.WaEnablePreemptionGranularityControlByUMD = readTokValue<decltype(dst.WaEnablePreemptionGranularityControlByUMD)>(*tok);
} break;
case TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL: {
dst.WaDisableLSQCROPERFforOCL = readTokValue<decltype(dst.WaDisableLSQCROPERFforOCL)>(*tok);
} break;
@ -1992,12 +1935,6 @@ struct Demarshaller<TOK_S_WA_TABLE> {
case TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT: {
dst.WaValign2ForR8G8B8UINTFormat = readTokValue<decltype(dst.WaValign2ForR8G8B8UINTFormat)>(*tok);
} break;
case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID: {
dst.WaReportPerfCountUseGlobalContextID = readTokValue<decltype(dst.WaReportPerfCountUseGlobalContextID)>(*tok);
} break;
case TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE: {
dst.WaForcePcBbFullCfgRestore = readTokValue<decltype(dst.WaForcePcBbFullCfgRestore)>(*tok);
} break;
case TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE: {
dst.WaCSRUncachable = readTokValue<decltype(dst.WaCSRUncachable)>(*tok);
} break;
@ -2966,27 +2903,12 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
return false;
}
break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP: {
dst.SkuTable.FtrDesktop = readTokValue<decltype(dst.SkuTable.FtrDesktop)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT: {
dst.SkuTable.FtrULT = readTokValue<decltype(dst.SkuTable.FtrULT)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM: {
dst.SkuTable.FtrIVBM0M1Platform = readTokValue<decltype(dst.SkuTable.FtrIVBM0M1Platform)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED: {
dst.SkuTable.FtrChannelSwizzlingXOREnabled = readTokValue<decltype(dst.SkuTable.FtrChannelSwizzlingXOREnabled)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE: {
dst.SkuTable.Ftr5Slice = readTokValue<decltype(dst.SkuTable.Ftr5Slice)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA: {
dst.SkuTable.FtrLCIA = readTokValue<decltype(dst.SkuTable.FtrLCIA)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER: {
dst.SkuTable.FtrResourceStreamer = readTokValue<decltype(dst.SkuTable.FtrResourceStreamer)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING: {
dst.SkuTable.FtrCCSRing = readTokValue<decltype(dst.SkuTable.FtrCCSRing)>(*tokSkuTable);
} break;
@ -2999,9 +2921,6 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED: {
dst.SkuTable.FtrDisplayDisabled = readTokValue<decltype(dst.SkuTable.FtrDisplayDisabled)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT: {
dst.SkuTable.FtrSGTPVSKUStrapPresent = readTokValue<decltype(dst.SkuTable.FtrSGTPVSKUStrapPresent)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED: {
dst.SkuTable.FtrPooledEuEnabled = readTokValue<decltype(dst.SkuTable.FtrPooledEuEnabled)>(*tokSkuTable);
} break;
@ -3014,15 +2933,6 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT: {
dst.SkuTable.FtrGpGpuMidThreadLevelPreempt = readTokValue<decltype(dst.SkuTable.FtrGpGpuMidThreadLevelPreempt)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT: {
dst.SkuTable.Ftr3dMidBatchPreempt = readTokValue<decltype(dst.SkuTable.Ftr3dMidBatchPreempt)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT: {
dst.SkuTable.Ftr3dObjectLevelPreempt = readTokValue<decltype(dst.SkuTable.Ftr3dObjectLevelPreempt)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: {
dst.SkuTable.FtrPerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.SkuTable.FtrPerCtxtPreemptionGranularityControl)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT: {
dst.SkuTable.FtrPPGTT = readTokValue<decltype(dst.SkuTable.FtrPPGTT)>(*tokSkuTable);
} break;
@ -3059,15 +2969,9 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS: {
dst.SkuTable.FtrLLCBypass = readTokValue<decltype(dst.SkuTable.FtrLLCBypass)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL: {
dst.SkuTable.FtrCrystalwell = readTokValue<decltype(dst.SkuTable.FtrCrystalwell)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY: {
dst.SkuTable.FtrCentralCachePolicy = readTokValue<decltype(dst.SkuTable.FtrCentralCachePolicy)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING: {
dst.SkuTable.FtrIoMmuPageFaulting = readTokValue<decltype(dst.SkuTable.FtrIoMmuPageFaulting)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU: {
dst.SkuTable.FtrWddm2GpuMmu = readTokValue<decltype(dst.SkuTable.FtrWddm2GpuMmu)>(*tokSkuTable);
} break;
@ -3080,9 +2984,6 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES: {
dst.SkuTable.FtrWddm2_1_64kbPages = readTokValue<decltype(dst.SkuTable.FtrWddm2_1_64kbPages)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION: {
dst.SkuTable.FtrGttCacheInvalidation = readTokValue<decltype(dst.SkuTable.FtrGttCacheInvalidation)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION: {
dst.SkuTable.FtrE2ECompression = readTokValue<decltype(dst.SkuTable.FtrE2ECompression)>(*tokSkuTable);
} break;
@ -3134,15 +3035,6 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC: {
dst.SkuTable.FtrFbc = readTokValue<decltype(dst.SkuTable.FtrFbc)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION: {
dst.SkuTable.FtrFbc2AddressTranslation = readTokValue<decltype(dst.SkuTable.FtrFbc2AddressTranslation)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING: {
dst.SkuTable.FtrFbcBlitterTracking = readTokValue<decltype(dst.SkuTable.FtrFbcBlitterTracking)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING: {
dst.SkuTable.FtrFbcCpuTracking = readTokValue<decltype(dst.SkuTable.FtrFbcCpuTracking)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP: {
dst.SkuTable.FtrRendComp = readTokValue<decltype(dst.SkuTable.FtrRendComp)>(*tokSkuTable);
} break;
@ -3155,12 +3047,6 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D: {
dst.SkuTable.FtrDisplayEngineS3d = readTokValue<decltype(dst.SkuTable.FtrDisplayEngineS3d)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE: {
dst.SkuTable.FtrSimulationMode = readTokValue<decltype(dst.SkuTable.FtrSimulationMode)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C: {
dst.SkuTable.FtrEnableGuC = readTokValue<decltype(dst.SkuTable.FtrEnableGuC)>(*tokSkuTable);
} break;
case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT: {
dst.SkuTable.FtrVgt = readTokValue<decltype(dst.SkuTable.FtrVgt)>(*tokSkuTable);
} break;
@ -3190,9 +3076,6 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
return false;
}
break;
case TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT: {
dst.WaTable.WaDoNotUseMIReportPerfCount = readTokValue<decltype(dst.WaTable.WaDoNotUseMIReportPerfCount)>(*tokWaTable);
} break;
case TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER: {
dst.WaTable.WaAlignIndexBuffer = readTokValue<decltype(dst.WaTable.WaAlignIndexBuffer)>(*tokWaTable);
} break;
@ -3202,9 +3085,6 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
case TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: {
dst.WaTable.WaDisablePerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.WaTable.WaDisablePerCtxtPreemptionGranularityControl)>(*tokWaTable);
} break;
case TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD: {
dst.WaTable.WaEnablePreemptionGranularityControlByUMD = readTokValue<decltype(dst.WaTable.WaEnablePreemptionGranularityControlByUMD)>(*tokWaTable);
} break;
case TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL: {
dst.WaTable.WaDisableLSQCROPERFforOCL = readTokValue<decltype(dst.WaTable.WaDisableLSQCROPERFforOCL)>(*tokWaTable);
} break;
@ -3214,12 +3094,6 @@ struct Demarshaller<TOK_S_ADAPTER_INFO> {
case TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT: {
dst.WaTable.WaValign2ForR8G8B8UINTFormat = readTokValue<decltype(dst.WaTable.WaValign2ForR8G8B8UINTFormat)>(*tokWaTable);
} break;
case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID: {
dst.WaTable.WaReportPerfCountUseGlobalContextID = readTokValue<decltype(dst.WaTable.WaReportPerfCountUseGlobalContextID)>(*tokWaTable);
} break;
case TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE: {
dst.WaTable.WaForcePcBbFullCfgRestore = readTokValue<decltype(dst.WaTable.WaForcePcBbFullCfgRestore)>(*tokWaTable);
} break;
case TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE: {
dst.WaTable.WaCSRUncachable = readTokValue<decltype(dst.WaTable.WaCSRUncachable)>(*tokWaTable);
} break;

43
shared/wsl_compute_helper/source/wsl_compute_helper_types_marshall.h
View File

@ -1057,26 +1057,16 @@ struct Marshaller<TOK_S_GT_SYSTEM_INFO> {
template <typename _SKU_FEATURE_TABLET>
inline void marshall(TOKSTR__SKU_FEATURE_TABLE &dst, const _SKU_FEATURE_TABLET &src) {
dst = {};
dst.FtrDesktop.setValue(src.FtrDesktop);
dst.FtrULT.setValue(src.FtrULT);
dst.FtrIVBM0M1Platform.setValue(src.FtrIVBM0M1Platform);
dst.FtrChannelSwizzlingXOREnabled.setValue(src.FtrChannelSwizzlingXOREnabled);
dst.Ftr5Slice.setValue(src.Ftr5Slice);
dst.FtrLCIA.setValue(src.FtrLCIA);
dst.FtrResourceStreamer.setValue(src.FtrResourceStreamer);
dst.FtrCCSRing.setValue(src.FtrCCSRing);
dst.FtrCCSNode.setValue(src.FtrCCSNode);
dst.FtrCCSMultiInstance.setValue(src.FtrCCSMultiInstance);
dst.FtrDisplayDisabled.setValue(src.FtrDisplayDisabled);
dst.FtrSGTPVSKUStrapPresent.setValue(src.FtrSGTPVSKUStrapPresent);
dst.FtrPooledEuEnabled.setValue(src.FtrPooledEuEnabled);
dst.FtrGpGpuMidBatchPreempt.setValue(src.FtrGpGpuMidBatchPreempt);
dst.FtrGpGpuThreadGroupLevelPreempt.setValue(src.FtrGpGpuThreadGroupLevelPreempt);
dst.FtrGpGpuMidThreadLevelPreempt.setValue(src.FtrGpGpuMidThreadLevelPreempt);
dst.Ftr3dMidBatchPreempt.setValue(src.Ftr3dMidBatchPreempt);
dst.Ftr3dObjectLevelPreempt.setValue(src.Ftr3dObjectLevelPreempt);
dst.FtrPerCtxtPreemptionGranularityControl.setValue(src.FtrPerCtxtPreemptionGranularityControl);
dst.FtrPPGTT.setValue(src.FtrPPGTT);
dst.FtrIA32eGfxPTEs.setValue(src.FtrIA32eGfxPTEs);
dst.FtrMemTypeMocsDeferPAT.setValue(src.FtrMemTypeMocsDeferPAT);
@ -1089,14 +1079,11 @@ inline void marshall(TOKSTR__SKU_FEATURE_TABLE &dst, const _SKU_FEATURE_TABLET &
dst.FtrL3IACoherency.setValue(src.FtrL3IACoherency);
dst.FtrEDram.setValue(src.FtrEDram);
dst.FtrLLCBypass.setValue(src.FtrLLCBypass);
dst.FtrCrystalwell.setValue(src.FtrCrystalwell);
dst.FtrCentralCachePolicy.setValue(src.FtrCentralCachePolicy);
dst.FtrIoMmuPageFaulting.setValue(src.FtrIoMmuPageFaulting);
dst.FtrWddm2GpuMmu.setValue(src.FtrWddm2GpuMmu);
dst.FtrWddm2Svm.setValue(src.FtrWddm2Svm);
dst.FtrStandardMipTailFormat.setValue(src.FtrStandardMipTailFormat);
dst.FtrWddm2_1_64kbPages.setValue(src.FtrWddm2_1_64kbPages);
dst.FtrGttCacheInvalidation.setValue(src.FtrGttCacheInvalidation);
dst.FtrE2ECompression.setValue(src.FtrE2ECompression);
dst.FtrLinearCCS.setValue(src.FtrLinearCCS);
dst.FtrLocalMemory.setValue(src.FtrLocalMemory);
@ -1114,15 +1101,10 @@ inline void marshall(TOKSTR__SKU_FEATURE_TABLE &dst, const _SKU_FEATURE_TABLET &
dst.FtrAstcHdr2D.setValue(src.FtrAstcHdr2D);
dst.FtrAstc3D.setValue(src.FtrAstc3D);
dst.FtrFbc.setValue(src.FtrFbc);
dst.FtrFbc2AddressTranslation.setValue(src.FtrFbc2AddressTranslation);
dst.FtrFbcBlitterTracking.setValue(src.FtrFbcBlitterTracking);
dst.FtrFbcCpuTracking.setValue(src.FtrFbcCpuTracking);
dst.FtrRendComp.setValue(src.FtrRendComp);
dst.FtrDisplayYTiling.setValue(src.FtrDisplayYTiling);
dst.FtrS3D.setValue(src.FtrS3D);
dst.FtrDisplayEngineS3d.setValue(src.FtrDisplayEngineS3d);
dst.FtrSimulationMode.setValue(src.FtrSimulationMode);
dst.FtrEnableGuC.setValue(src.FtrEnableGuC);
dst.FtrVgt.setValue(src.FtrVgt);
dst.FtrAssignedGpuTile.setValue(src.FtrAssignedGpuTile);
}
@ -1139,16 +1121,12 @@ struct Marshaller<TOK_S_SKU_FEATURE_TABLE> {
template <typename _WA_TABLET>
inline void marshall(TOKSTR__WA_TABLE &dst, const _WA_TABLET &src) {
dst = {};
dst.WaDoNotUseMIReportPerfCount.setValue(src.WaDoNotUseMIReportPerfCount);
dst.WaAlignIndexBuffer.setValue(src.WaAlignIndexBuffer);
dst.WaSendMIFLUSHBeforeVFE.setValue(src.WaSendMIFLUSHBeforeVFE);
dst.WaDisablePerCtxtPreemptionGranularityControl.setValue(src.WaDisablePerCtxtPreemptionGranularityControl);
dst.WaEnablePreemptionGranularityControlByUMD.setValue(src.WaEnablePreemptionGranularityControlByUMD);
dst.WaDisableLSQCROPERFforOCL.setValue(src.WaDisableLSQCROPERFforOCL);
dst.WaValign2For96bppFormats.setValue(src.WaValign2For96bppFormats);
dst.WaValign2ForR8G8B8UINTFormat.setValue(src.WaValign2ForR8G8B8UINTFormat);
dst.WaReportPerfCountUseGlobalContextID.setValue(src.WaReportPerfCountUseGlobalContextID);
dst.WaForcePcBbFullCfgRestore.setValue(src.WaForcePcBbFullCfgRestore);
dst.WaCSRUncachable.setValue(src.WaCSRUncachable);
dst.WaDisableFusedThreadScheduling.setValue(src.WaDisableFusedThreadScheduling);
dst.WaModifyVFEStateAfterGPGPUPreemption.setValue(src.WaModifyVFEStateAfterGPGPUPreemption);
@ -1395,25 +1373,16 @@ inline void marshall(TOKSTR__ADAPTER_INFO &dst, const _ADAPTER_INFOT &src) {
dst.GfxPlatform.usDeviceID_PCH.setValue(src.GfxPlatform.usDeviceID_PCH);
dst.GfxPlatform.usRevId_PCH.setValue(src.GfxPlatform.usRevId_PCH);
dst.GfxPlatform.eGTType.setValue(src.GfxPlatform.eGTType);
dst.SkuTable.FtrDesktop.setValue(src.SkuTable.FtrDesktop);
dst.SkuTable.FtrULT.setValue(src.SkuTable.FtrULT);
dst.SkuTable.FtrIVBM0M1Platform.setValue(src.SkuTable.FtrIVBM0M1Platform);
dst.SkuTable.FtrChannelSwizzlingXOREnabled.setValue(src.SkuTable.FtrChannelSwizzlingXOREnabled);
dst.SkuTable.Ftr5Slice.setValue(src.SkuTable.Ftr5Slice);
dst.SkuTable.FtrLCIA.setValue(src.SkuTable.FtrLCIA);
dst.SkuTable.FtrResourceStreamer.setValue(src.SkuTable.FtrResourceStreamer);
dst.SkuTable.FtrCCSRing.setValue(src.SkuTable.FtrCCSRing);
dst.SkuTable.FtrCCSNode.setValue(src.SkuTable.FtrCCSNode);
dst.SkuTable.FtrCCSMultiInstance.setValue(src.SkuTable.FtrCCSMultiInstance);
dst.SkuTable.FtrDisplayDisabled.setValue(src.SkuTable.FtrDisplayDisabled);
dst.SkuTable.FtrSGTPVSKUStrapPresent.setValue(src.SkuTable.FtrSGTPVSKUStrapPresent);
dst.SkuTable.FtrPooledEuEnabled.setValue(src.SkuTable.FtrPooledEuEnabled);
dst.SkuTable.FtrGpGpuMidBatchPreempt.setValue(src.SkuTable.FtrGpGpuMidBatchPreempt);
dst.SkuTable.FtrGpGpuThreadGroupLevelPreempt.setValue(src.SkuTable.FtrGpGpuThreadGroupLevelPreempt);
dst.SkuTable.FtrGpGpuMidThreadLevelPreempt.setValue(src.SkuTable.FtrGpGpuMidThreadLevelPreempt);
dst.SkuTable.Ftr3dMidBatchPreempt.setValue(src.SkuTable.Ftr3dMidBatchPreempt);
dst.SkuTable.Ftr3dObjectLevelPreempt.setValue(src.SkuTable.Ftr3dObjectLevelPreempt);
dst.SkuTable.FtrPerCtxtPreemptionGranularityControl.setValue(src.SkuTable.FtrPerCtxtPreemptionGranularityControl);
dst.SkuTable.FtrPPGTT.setValue(src.SkuTable.FtrPPGTT);
dst.SkuTable.FtrIA32eGfxPTEs.setValue(src.SkuTable.FtrIA32eGfxPTEs);
dst.SkuTable.FtrMemTypeMocsDeferPAT.setValue(src.SkuTable.FtrMemTypeMocsDeferPAT);
@ -1426,14 +1395,11 @@ inline void marshall(TOKSTR__ADAPTER_INFO &dst, const _ADAPTER_INFOT &src) {
dst.SkuTable.FtrL3IACoherency.setValue(src.SkuTable.FtrL3IACoherency);
dst.SkuTable.FtrEDram.setValue(src.SkuTable.FtrEDram);
dst.SkuTable.FtrLLCBypass.setValue(src.SkuTable.FtrLLCBypass);
dst.SkuTable.FtrCrystalwell.setValue(src.SkuTable.FtrCrystalwell);
dst.SkuTable.FtrCentralCachePolicy.setValue(src.SkuTable.FtrCentralCachePolicy);
dst.SkuTable.FtrIoMmuPageFaulting.setValue(src.SkuTable.FtrIoMmuPageFaulting);
dst.SkuTable.FtrWddm2GpuMmu.setValue(src.SkuTable.FtrWddm2GpuMmu);
dst.SkuTable.FtrWddm2Svm.setValue(src.SkuTable.FtrWddm2Svm);
dst.SkuTable.FtrStandardMipTailFormat.setValue(src.SkuTable.FtrStandardMipTailFormat);
dst.SkuTable.FtrWddm2_1_64kbPages.setValue(src.SkuTable.FtrWddm2_1_64kbPages);
dst.SkuTable.FtrGttCacheInvalidation.setValue(src.SkuTable.FtrGttCacheInvalidation);
dst.SkuTable.FtrE2ECompression.setValue(src.SkuTable.FtrE2ECompression);
dst.SkuTable.FtrLinearCCS.setValue(src.SkuTable.FtrLinearCCS);
dst.SkuTable.FtrLocalMemory.setValue(src.SkuTable.FtrLocalMemory);
@ -1451,27 +1417,18 @@ inline void marshall(TOKSTR__ADAPTER_INFO &dst, const _ADAPTER_INFOT &src) {
dst.SkuTable.FtrAstcHdr2D.setValue(src.SkuTable.FtrAstcHdr2D);
dst.SkuTable.FtrAstc3D.setValue(src.SkuTable.FtrAstc3D);
dst.SkuTable.FtrFbc.setValue(src.SkuTable.FtrFbc);
dst.SkuTable.FtrFbc2AddressTranslation.setValue(src.SkuTable.FtrFbc2AddressTranslation);
dst.SkuTable.FtrFbcBlitterTracking.setValue(src.SkuTable.FtrFbcBlitterTracking);
dst.SkuTable.FtrFbcCpuTracking.setValue(src.SkuTable.FtrFbcCpuTracking);
dst.SkuTable.FtrRendComp.setValue(src.SkuTable.FtrRendComp);
dst.SkuTable.FtrDisplayYTiling.setValue(src.SkuTable.FtrDisplayYTiling);
dst.SkuTable.FtrS3D.setValue(src.SkuTable.FtrS3D);
dst.SkuTable.FtrDisplayEngineS3d.setValue(src.SkuTable.FtrDisplayEngineS3d);
dst.SkuTable.FtrSimulationMode.setValue(src.SkuTable.FtrSimulationMode);
dst.SkuTable.FtrEnableGuC.setValue(src.SkuTable.FtrEnableGuC);
dst.SkuTable.FtrVgt.setValue(src.SkuTable.FtrVgt);
dst.SkuTable.FtrAssignedGpuTile.setValue(src.SkuTable.FtrAssignedGpuTile);
dst.WaTable.WaDoNotUseMIReportPerfCount.setValue(src.WaTable.WaDoNotUseMIReportPerfCount);
dst.WaTable.WaAlignIndexBuffer.setValue(src.WaTable.WaAlignIndexBuffer);
dst.WaTable.WaSendMIFLUSHBeforeVFE.setValue(src.WaTable.WaSendMIFLUSHBeforeVFE);
dst.WaTable.WaDisablePerCtxtPreemptionGranularityControl.setValue(src.WaTable.WaDisablePerCtxtPreemptionGranularityControl);
dst.WaTable.WaEnablePreemptionGranularityControlByUMD.setValue(src.WaTable.WaEnablePreemptionGranularityControlByUMD);
dst.WaTable.WaDisableLSQCROPERFforOCL.setValue(src.WaTable.WaDisableLSQCROPERFforOCL);
dst.WaTable.WaValign2For96bppFormats.setValue(src.WaTable.WaValign2For96bppFormats);
dst.WaTable.WaValign2ForR8G8B8UINTFormat.setValue(src.WaTable.WaValign2ForR8G8B8UINTFormat);
dst.WaTable.WaReportPerfCountUseGlobalContextID.setValue(src.WaTable.WaReportPerfCountUseGlobalContextID);
dst.WaTable.WaForcePcBbFullCfgRestore.setValue(src.WaTable.WaForcePcBbFullCfgRestore);
dst.WaTable.WaCSRUncachable.setValue(src.WaTable.WaCSRUncachable);
dst.WaTable.WaDisableFusedThreadScheduling.setValue(src.WaTable.WaDisableFusedThreadScheduling);
dst.WaTable.WaModifyVFEStateAfterGPGPUPreemption.setValue(src.WaTable.WaModifyVFEStateAfterGPGPUPreemption);

5
shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens.h
View File

@ -421,11 +421,7 @@ enum TOK : uint32_t {
TOK_FBD_GT_SYSTEM_INFO__NUM_THREADS_PER_EU = 336,
TOK_FS_GT_SYSTEM_INFO__CACHE_TYPES = 363,
TOK_FBD_GT_SYSTEM_INFO__MAX_VECS = 371,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP = 381,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT = 423,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM = 425,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED = 434,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE = 442,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA = 445,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER = 450,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING = 453,
@ -452,7 +448,6 @@ enum TOK : uint32_t {
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY = 609,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM = 615,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS = 617,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL = 618,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY = 619,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING = 622,
TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU = 626,

158
shared/wsl_compute_helper/source/wsl_compute_helper_types_tokens_structs.h
View File

@ -432,7 +432,7 @@ struct TOKSTR__SKU_FEATURE_TABLE {
TokenVariableLength base;
TOKSTR__SKU_FEATURE_TABLE(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR__SKU_FEATURE_TABLE, FtrAssignedGpuTile) + sizeof(FtrAssignedGpuTile) - offsetof(TOKSTR__SKU_FEATURE_TABLE, FtrDesktop), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
: base(tokenId, elementId, offsetof(TOKSTR__SKU_FEATURE_TABLE, FtrAssignedGpuTile) + sizeof(FtrAssignedGpuTile) - offsetof(TOKSTR__SKU_FEATURE_TABLE, FtrULT), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TOKSTR__SKU_FEATURE_TABLE()
: base(TOK_S_SKU_FEATURE_TABLE, 0, sizeof(*this) - sizeof(base)) {}
@ -441,18 +441,13 @@ struct TOKSTR__SKU_FEATURE_TABLE {
TokenVariableLength base;
TOKSTR_ANONYMOUS3245(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS3245, FtrCCSMultiInstance) + sizeof(FtrCCSMultiInstance) - offsetof(TOKSTR_ANONYMOUS3245, FtrDesktop), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
: base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS3245, FtrCCSMultiInstance) + sizeof(FtrCCSMultiInstance) - offsetof(TOKSTR_ANONYMOUS3245, FtrULT), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TOKSTR_ANONYMOUS3245()
: base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS3245, 0, sizeof(*this) - sizeof(base)) {}
TokenDword FtrDesktop = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP};
TokenDword FtrULT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT};
TokenDword FtrIVBM0M1Platform = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM};
TokenDword FtrChannelSwizzlingXOREnabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED};
TokenDword Ftr5Slice = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE};
TokenDword FtrLCIA = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA};
TokenDword FtrResourceStreamer = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER};
TokenDword FtrCCSRing = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING};
TokenDword FtrCCSNode = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE};
TokenDword FtrCCSMultiInstance = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE};
@ -464,13 +459,12 @@ struct TOKSTR__SKU_FEATURE_TABLE {
TokenVariableLength base;
TOKSTR_ANONYMOUS11155(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS11155, FtrSGTPVSKUStrapPresent) + sizeof(FtrSGTPVSKUStrapPresent) - offsetof(TOKSTR_ANONYMOUS11155, FtrDisplayDisabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
: base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS11155, FtrDisplayDisabled) + sizeof(FtrDisplayDisabled) - offsetof(TOKSTR_ANONYMOUS11155, FtrDisplayDisabled), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TOKSTR_ANONYMOUS11155()
: base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS11155, 0, sizeof(*this) - sizeof(base)) {}
TokenDword FtrDisplayDisabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED};
TokenDword FtrSGTPVSKUStrapPresent = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT};
};
static_assert(std::is_standard_layout_v<TOKSTR_ANONYMOUS11155>, "");
static_assert(sizeof(TOKSTR_ANONYMOUS11155) % sizeof(uint32_t) == 0, "");
@ -501,9 +495,6 @@ struct TOKSTR__SKU_FEATURE_TABLE {
TokenDword FtrGpGpuMidBatchPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT};
TokenDword FtrGpGpuThreadGroupLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT};
TokenDword FtrGpGpuMidThreadLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT};
TokenDword Ftr3dMidBatchPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT};
TokenDword Ftr3dObjectLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT};
TokenDword FtrPerCtxtPreemptionGranularityControl = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL};
TokenDword FtrPPGTT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT};
TokenDword FtrIA32eGfxPTEs = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES};
TokenDword FtrMemTypeMocsDeferPAT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT};
@ -516,14 +507,11 @@ struct TOKSTR__SKU_FEATURE_TABLE {
TokenDword FtrL3IACoherency = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY};
TokenDword FtrEDram = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM};
TokenDword FtrLLCBypass = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS};
TokenDword FtrCrystalwell = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL};
TokenDword FtrCentralCachePolicy = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY};
TokenDword FtrIoMmuPageFaulting = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING};
TokenDword FtrWddm2GpuMmu = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU};
TokenDword FtrWddm2Svm = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM};
TokenDword FtrStandardMipTailFormat = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT};
TokenDword FtrWddm2_1_64kbPages = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES};
TokenDword FtrGttCacheInvalidation = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION};
TokenDword FtrE2ECompression = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION};
TokenDword FtrLinearCCS = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS};
TokenDword FtrLocalMemory = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY};
@ -576,32 +564,17 @@ struct TOKSTR__SKU_FEATURE_TABLE {
TokenVariableLength base;
TOKSTR_ANONYMOUS66219(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS66219, FtrSimulationMode) + sizeof(FtrSimulationMode) - offsetof(TOKSTR_ANONYMOUS66219, FtrS3D), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
: base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS66219, FtrDisplayEngineS3d) + sizeof(FtrDisplayEngineS3d) - offsetof(TOKSTR_ANONYMOUS66219, FtrS3D), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TOKSTR_ANONYMOUS66219()
: base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS66219, 0, sizeof(*this) - sizeof(base)) {}
TokenDword FtrS3D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D};
TokenDword FtrDisplayEngineS3d = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D};
TokenDword FtrSimulationMode = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE};
};
static_assert(std::is_standard_layout_v<TOKSTR_ANONYMOUS66219>, "");
static_assert(sizeof(TOKSTR_ANONYMOUS66219) % sizeof(uint32_t) == 0, "");
struct TOKSTR_ANONYMOUS88095 {
TokenVariableLength base;
TOKSTR_ANONYMOUS88095(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS88095, FtrEnableGuC) + sizeof(FtrEnableGuC) - offsetof(TOKSTR_ANONYMOUS88095, FtrEnableGuC), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TOKSTR_ANONYMOUS88095()
: base(TOK_S_SKU_FEATURE_TABLE__ANONYMOUS88095, 0, sizeof(*this) - sizeof(base)) {}
TokenDword FtrEnableGuC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C};
};
static_assert(std::is_standard_layout_v<TOKSTR_ANONYMOUS88095>, "");
static_assert(sizeof(TOKSTR_ANONYMOUS88095) % sizeof(uint32_t) == 0, "");
struct TOKSTR_ANONYMOUS89755 {
TokenVariableLength base;
@ -630,73 +603,56 @@ struct TOKSTR__SKU_FEATURE_TABLE {
static_assert(std::is_standard_layout_v<TOKSTR_ANONYMOUS91822>, "");
static_assert(sizeof(TOKSTR_ANONYMOUS91822) % sizeof(uint32_t) == 0, "");
TokenDword FtrDesktop = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP}; // Indirect field from anonymous struct
TokenDword FtrULT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT}; // Indirect field from anonymous struct
TokenDword FtrIVBM0M1Platform = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM}; // Indirect field from anonymous struct
TokenDword FtrChannelSwizzlingXOREnabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED}; // Indirect field from anonymous struct
TokenDword Ftr5Slice = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE}; // Indirect field from anonymous struct
TokenDword FtrLCIA = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA}; // Indirect field from anonymous struct
TokenDword FtrResourceStreamer = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER}; // Indirect field from anonymous struct
TokenDword FtrCCSRing = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING}; // Indirect field from anonymous struct
TokenDword FtrCCSNode = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE}; // Indirect field from anonymous struct
TokenDword FtrCCSMultiInstance = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE}; // Indirect field from anonymous struct
TokenDword FtrDisplayDisabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED}; // Indirect field from anonymous struct
TokenDword FtrSGTPVSKUStrapPresent = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT}; // Indirect field from anonymous struct
TokenDword FtrPooledEuEnabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED}; // Indirect field from anonymous struct
TokenDword FtrGpGpuMidBatchPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT}; // Indirect field from anonymous struct
TokenDword FtrGpGpuThreadGroupLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT}; // Indirect field from anonymous struct
TokenDword FtrGpGpuMidThreadLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT}; // Indirect field from anonymous struct
TokenDword Ftr3dMidBatchPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT}; // Indirect field from anonymous struct
TokenDword Ftr3dObjectLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT}; // Indirect field from anonymous struct
TokenDword FtrPerCtxtPreemptionGranularityControl = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL}; // Indirect field from anonymous struct
TokenDword FtrPPGTT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT}; // Indirect field from anonymous struct
TokenDword FtrIA32eGfxPTEs = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES}; // Indirect field from anonymous struct
TokenDword FtrMemTypeMocsDeferPAT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT}; // Indirect field from anonymous struct
TokenDword FtrPml4Support = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT}; // Indirect field from anonymous struct
TokenDword FtrSVM = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM}; // Indirect field from anonymous struct
TokenDword FtrTileMappedResource = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE}; // Indirect field from anonymous struct
TokenDword FtrTranslationTable = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE}; // Indirect field from anonymous struct
TokenDword FtrUserModeTranslationTable = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE}; // Indirect field from anonymous struct
TokenDword FtrNullPages = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES}; // Indirect field from anonymous struct
TokenDword FtrL3IACoherency = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY}; // Indirect field from anonymous struct
TokenDword FtrEDram = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM}; // Indirect field from anonymous struct
TokenDword FtrLLCBypass = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS}; // Indirect field from anonymous struct
TokenDword FtrCrystalwell = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL}; // Indirect field from anonymous struct
TokenDword FtrCentralCachePolicy = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY}; // Indirect field from anonymous struct
TokenDword FtrIoMmuPageFaulting = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING}; // Indirect field from anonymous struct
TokenDword FtrWddm2GpuMmu = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU}; // Indirect field from anonymous struct
TokenDword FtrWddm2Svm = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM}; // Indirect field from anonymous struct
TokenDword FtrStandardMipTailFormat = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT}; // Indirect field from anonymous struct
TokenDword FtrWddm2_1_64kbPages = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES}; // Indirect field from anonymous struct
TokenDword FtrGttCacheInvalidation = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION}; // Indirect field from anonymous struct
TokenDword FtrE2ECompression = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION}; // Indirect field from anonymous struct
TokenDword FtrLinearCCS = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS}; // Indirect field from anonymous struct
TokenDword FtrLocalMemory = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY}; // Indirect field from anonymous struct
TokenDword FtrPpgtt64KBWalkOptimization = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION}; // Indirect field from anonymous struct
TokenDword FtrTileY = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y}; // Indirect field from anonymous struct
TokenDword FtrFlatPhysCCS = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS}; // Indirect field from anonymous struct
TokenDword FtrMultiTileArch = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH}; // Indirect field from anonymous struct
TokenDword FtrLocalMemoryAllows4KB = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB}; // Indirect field from anonymous struct
TokenDword FtrDisplayXTiling = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING}; // Indirect field from anonymous struct
TokenDword FtrCameraCaptureCaching = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING}; // Indirect field from anonymous struct
TokenDword FtrKmdDaf = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF}; // Indirect field from anonymous struct
TokenDword FtrFrameBufferLLC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC}; // Indirect field from anonymous struct
TokenDword FtrDriverFLR = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR}; // Indirect field from anonymous struct
TokenDword FtrAstcLdr2D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D}; // Indirect field from anonymous struct
TokenDword FtrAstcHdr2D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D}; // Indirect field from anonymous struct
TokenDword FtrAstc3D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D}; // Indirect field from anonymous struct
TokenDword FtrFbc = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC}; // Indirect field from anonymous struct
TokenDword FtrFbc2AddressTranslation = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION}; // Indirect field from anonymous struct
TokenDword FtrFbcBlitterTracking = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING}; // Indirect field from anonymous struct
TokenDword FtrFbcCpuTracking = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING}; // Indirect field from anonymous struct
TokenDword FtrRendComp = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP}; // Indirect field from anonymous struct
TokenDword FtrDisplayYTiling = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING}; // Indirect field from anonymous struct
TokenDword FtrS3D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D}; // Indirect field from anonymous struct
TokenDword FtrDisplayEngineS3d = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D}; // Indirect field from anonymous struct
TokenDword FtrSimulationMode = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE}; // Indirect field from anonymous struct
TokenDword FtrEnableGuC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C}; // Indirect field from anonymous struct
TokenDword FtrVgt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT}; // Indirect field from anonymous struct
TokenDword FtrAssignedGpuTile = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE}; // Indirect field from anonymous struct
TokenDword FtrULT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT}; // Indirect field from anonymous struct
TokenDword FtrLCIA = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA}; // Indirect field from anonymous struct
TokenDword FtrCCSRing = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING}; // Indirect field from anonymous struct
TokenDword FtrCCSNode = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE}; // Indirect field from anonymous struct
TokenDword FtrCCSMultiInstance = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE}; // Indirect field from anonymous struct
TokenDword FtrDisplayDisabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED}; // Indirect field from anonymous struct
TokenDword FtrPooledEuEnabled = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED}; // Indirect field from anonymous struct
TokenDword FtrGpGpuMidBatchPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT}; // Indirect field from anonymous struct
TokenDword FtrGpGpuThreadGroupLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT}; // Indirect field from anonymous struct
TokenDword FtrGpGpuMidThreadLevelPreempt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT}; // Indirect field from anonymous struct
TokenDword FtrPPGTT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT}; // Indirect field from anonymous struct
TokenDword FtrIA32eGfxPTEs = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES}; // Indirect field from anonymous struct
TokenDword FtrMemTypeMocsDeferPAT = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT}; // Indirect field from anonymous struct
TokenDword FtrPml4Support = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT}; // Indirect field from anonymous struct
TokenDword FtrSVM = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM}; // Indirect field from anonymous struct
TokenDword FtrTileMappedResource = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE}; // Indirect field from anonymous struct
TokenDword FtrTranslationTable = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE}; // Indirect field from anonymous struct
TokenDword FtrUserModeTranslationTable = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE}; // Indirect field from anonymous struct
TokenDword FtrNullPages = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES}; // Indirect field from anonymous struct
TokenDword FtrL3IACoherency = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY}; // Indirect field from anonymous struct
TokenDword FtrEDram = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM}; // Indirect field from anonymous struct
TokenDword FtrLLCBypass = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS}; // Indirect field from anonymous struct
TokenDword FtrCentralCachePolicy = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY}; // Indirect field from anonymous struct
TokenDword FtrWddm2GpuMmu = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU}; // Indirect field from anonymous struct
TokenDword FtrWddm2Svm = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM}; // Indirect field from anonymous struct
TokenDword FtrStandardMipTailFormat = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT}; // Indirect field from anonymous struct
TokenDword FtrWddm2_1_64kbPages = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES}; // Indirect field from anonymous struct
TokenDword FtrE2ECompression = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION}; // Indirect field from anonymous struct
TokenDword FtrLinearCCS = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS}; // Indirect field from anonymous struct
TokenDword FtrLocalMemory = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY}; // Indirect field from anonymous struct
TokenDword FtrPpgtt64KBWalkOptimization = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION}; // Indirect field from anonymous struct
TokenDword FtrTileY = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y}; // Indirect field from anonymous struct
TokenDword FtrFlatPhysCCS = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS}; // Indirect field from anonymous struct
TokenDword FtrMultiTileArch = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH}; // Indirect field from anonymous struct
TokenDword FtrLocalMemoryAllows4KB = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB}; // Indirect field from anonymous struct
TokenDword FtrDisplayXTiling = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING}; // Indirect field from anonymous struct
TokenDword FtrCameraCaptureCaching = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING}; // Indirect field from anonymous struct
TokenDword FtrKmdDaf = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF}; // Indirect field from anonymous struct
TokenDword FtrFrameBufferLLC = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC}; // Indirect field from anonymous struct
TokenDword FtrDriverFLR = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR}; // Indirect field from anonymous struct
TokenDword FtrAstcLdr2D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D}; // Indirect field from anonymous struct
TokenDword FtrAstcHdr2D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D}; // Indirect field from anonymous struct
TokenDword FtrAstc3D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D}; // Indirect field from anonymous struct
TokenDword FtrFbc = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC}; // Indirect field from anonymous struct
TokenDword FtrRendComp = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP}; // Indirect field from anonymous struct
TokenDword FtrDisplayYTiling = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING}; // Indirect field from anonymous struct
TokenDword FtrS3D = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D}; // Indirect field from anonymous struct
TokenDword FtrDisplayEngineS3d = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D}; // Indirect field from anonymous struct
TokenDword FtrVgt = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT}; // Indirect field from anonymous struct
TokenDword FtrAssignedGpuTile = {TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE}; // Indirect field from anonymous struct
};
static_assert(std::is_standard_layout_v<TOKSTR__SKU_FEATURE_TABLE>, "");
static_assert(sizeof(TOKSTR__SKU_FEATURE_TABLE) % sizeof(uint32_t) == 0, "");
@ -705,21 +661,17 @@ struct TOKSTR__WA_TABLE {
TokenVariableLength base;
TOKSTR__WA_TABLE(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR__WA_TABLE, Wa32bppTileY2DColorNoHAlign4) + sizeof(Wa32bppTileY2DColorNoHAlign4) - offsetof(TOKSTR__WA_TABLE, WaDoNotUseMIReportPerfCount), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
: base(tokenId, elementId, offsetof(TOKSTR__WA_TABLE, Wa32bppTileY2DColorNoHAlign4) + sizeof(Wa32bppTileY2DColorNoHAlign4) - offsetof(TOKSTR__WA_TABLE, WaAlignIndexBuffer), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TOKSTR__WA_TABLE()
: base(TOK_S_WA_TABLE, 0, sizeof(*this) - sizeof(base)) {}
TokenDword WaDoNotUseMIReportPerfCount = {TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT};
TokenDword WaAlignIndexBuffer = {TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER};
TokenDword WaSendMIFLUSHBeforeVFE = {TOK_FBD_WA_TABLE__WA_SEND_MIFLUSHBEFORE_VFE};
TokenDword WaDisablePerCtxtPreemptionGranularityControl = {TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL};
TokenDword WaEnablePreemptionGranularityControlByUMD = {TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD};
TokenDword WaDisableLSQCROPERFforOCL = {TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL};
TokenDword WaValign2For96bppFormats = {TOK_FBD_WA_TABLE__WA_VALIGN2FOR96BPP_FORMATS};
TokenDword WaValign2ForR8G8B8UINTFormat = {TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT};
TokenDword WaReportPerfCountUseGlobalContextID = {TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID};
TokenDword WaForcePcBbFullCfgRestore = {TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE};
TokenDword WaCSRUncachable = {TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE};
TokenDword WaDisableFusedThreadScheduling = {TOK_FBD_WA_TABLE__WA_DISABLE_FUSED_THREAD_SCHEDULING};
TokenDword WaModifyVFEStateAfterGPGPUPreemption = {TOK_FBD_WA_TABLE__WA_MODIFY_VFESTATE_AFTER_GPGPUPREEMPTION};