Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Updating wsl compute helper tokens and enbaling local memory

Browse Source 
Adding tokens needed for DG2 local mem enabling in WSL
Enabling local memory for DG2 for WSL

Signed-off-by: Kamil Diedrich <kamil.diedrich@intel.com>
This commit is contained in:
Kamil Diedrich
2022-01-27 01:08:08 +01:00
committed by Compute-Runtime-Automation
parent a83b173bbe
commit d2fbcc1960
15 changed files with 74 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
opencl/test/unit_test/os_interface/hw_info_config_tests.cpp
View File

@ -387,11 +387,3 @@ HWTEST_F(HwInfoConfigTest, givenHwInfoConfigWhenAskedIfTile64With3DSurfaceOnBCSI
const auto &hwInfoConfig = *HwInfoConfig::get(pInHwInfo.platform.eProductFamily);
EXPECT_TRUE(hwInfoConfig.isTile64With3DSurfaceOnBCSSupported(pInHwInfo));
}
HWTEST_F(HwInfoConfigTest, WhenOverrideResourceInfoParamsForWslForDRMandWDDMThenFalseIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(pInHwInfo.platform.eProductFamily);
bool ret = hwInfoConfig->overrideResourceInfoParamsForWsl(DriverModelType::DRM);
EXPECT_FALSE(ret);
ret = hwInfoConfig->overrideResourceInfoParamsForWsl(DriverModelType::WDDM);
EXPECT_FALSE(ret);
}

12
opencl/test/unit_test/xe_hpg_core/dg2/linux/hw_info_config_tests_dg2.cpp
View File

@ -41,15 +41,3 @@ DG2TEST_F(HwInfoConfigTestLinuxDg2, GivenDg2WhenConfigureHardwareCustomThenKmdNo
EXPECT_TRUE(pInHwInfo.capabilityTable.kmdNotifyProperties.enableQuickKmdSleepForDirectSubmission);
EXPECT_EQ(20ll, pInHwInfo.capabilityTable.kmdNotifyProperties.delayQuickKmdSleepForDirectSubmissionMicroseconds);
}
DG2TEST_F(HwInfoConfigTestLinuxDg2, WhenOverrideResourceInfoParamsForWslAndDriverModelWDDMThenTrueIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
bool ret = hwInfoConfig->overrideResourceInfoParamsForWsl(DriverModelType::WDDM);
EXPECT_TRUE(ret);
}
DG2TEST_F(HwInfoConfigTestLinuxDg2, WhenOverrideResourceInfoParamsForWslAndDriverModelDRMThenFalseIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
bool ret = hwInfoConfig->overrideResourceInfoParamsForWsl(DriverModelType::DRM);
EXPECT_FALSE(ret);
}

1
opencl/test/unit_test/xe_hpg_core/excludes_xe_hpg_core.cpp
View File

@ -14,4 +14,3 @@ HWTEST_EXCLUDE_PRODUCT(XeHPAndLaterImageTests, givenImageFromBufferWhenSettingSu
HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenSamplerStateWhenAdjustSamplerStateThenNothingIsChanged, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenAskedIfBlitterForImagesIsSupportedThenFalseIsReturned, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenAskedIfTile64With3DSurfaceOnBCSIsSupportedThenTrueIsReturned, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, WhenOverrideResourceInfoParamsForWslForDRMandWDDMThenFalseIsReturned, IGFX_XE_HPG_CORE);

1
shared/source/gmm_helper/client_context/gmm_client_context.cpp
View File

@ -32,7 +32,6 @@ GmmClientContext::GmmClientContext(OSInterface *osInterface, HardwareInfo *hwInf
if (osInterface && osInterface->getDriverModel()) {
osInterface->getDriverModel()->setGmmInputArgs(&inArgs);
driverModelType = osInterface->getDriverModel()->getDriverModelType();
}
auto ret = GmmInterface::initialize(&inArgs, &outArgs);

6
shared/source/gmm_helper/client_context/gmm_client_context.h
View File

@ -8,7 +8,6 @@
#pragma once
#include "shared/source/gmm_helper/client_context/gmm_handle_allocator.h"
#include "shared/source/gmm_helper/gmm_lib.h"
#include "shared/source/helpers/driver_model_type.h"
#include <memory>
@ -36,10 +35,6 @@ class GmmClientContext {
return hardwareInfo;
}
DriverModelType getDriverModelType() {
return driverModelType;
}
MOCKABLE_VIRTUAL uint8_t getSurfaceStateCompressionFormat(GMM_RESOURCE_FORMAT format);
MOCKABLE_VIRTUAL uint8_t getMediaSurfaceStateCompressionFormat(GMM_RESOURCE_FORMAT format);
@ -54,7 +49,6 @@ class GmmClientContext {
}
protected:
DriverModelType driverModelType = DriverModelType::UNKNOWN;
HardwareInfo *hardwareInfo = nullptr;
GMM_CLIENT_CONTEXT *clientContext;
std::unique_ptr<GmmHandleAllocator> handleAllocator;

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

@ -12,12 +12,10 @@
#include "shared/source/gmm_helper/resource_info.h"
#include "shared/source/helpers/aligned_memory.h"
#include "shared/source/helpers/debug_helpers.h"
#include "shared/source/helpers/driver_model_type.h"
#include "shared/source/helpers/hw_helper.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/helpers/ptr_math.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/source/os_interface/hw_info_config.h"
namespace NEO {
Gmm::Gmm(GmmClientContext *clientContext, const void *alignedPtr, size_t alignedSize, size_t alignment, bool uncacheable) : Gmm(clientContext, alignedPtr, alignedSize, alignment, uncacheable, false, true, {}) {}
@ -66,12 +64,6 @@ Gmm::Gmm(GmmClientContext *clientContext, const void *alignedPtr, size_t aligned
applyAppResource(storageInfo);
applyDebugOverrides();
auto hardwareInfo = clientContext->getHardwareInfo();
if (HwInfoConfig::get(hardwareInfo->platform.eProductFamily)->overrideResourceInfoParamsForWsl(clientContext->getDriverModelType())) {
resourceParams.Flags.Info.NonLocalOnly = 1;
resourceParams.Flags.Info.LocalOnly = 0;
}
gmmResourceInfo.reset(GmmResourceInfo::create(clientContext, &resourceParams));
}

2
shared/source/os_interface/hw_info_config.h
View File

@ -58,7 +58,6 @@ class HwInfoConfig {
virtual void setAdditionalPipelineSelectFields(void *pipelineSelectCmd, const PipelineSelectArgs &pipelineSelectArgs, const HardwareInfo &hwInfo) = 0;
virtual bool isDefaultEngineTypeAdjustmentRequired(const HardwareInfo &hwInfo) const = 0;
virtual bool overrideGfxPartitionLayoutForWsl() const = 0;
virtual bool overrideResourceInfoParamsForWsl(DriverModelType driverModelType) const = 0;
virtual std::string getDeviceMemoryName() const = 0;
virtual bool isDisableOverdispatchAvailable(const HardwareInfo &hwInfo) const = 0;
virtual bool allowCompression(const HardwareInfo &hwInfo) const = 0;
@ -122,7 +121,6 @@ class HwInfoConfigHw : public HwInfoConfig {
bool isBlitterFullySupported(const HardwareInfo &hwInfo) const override;
bool isPageTableManagerSupported(const HardwareInfo &hwInfo) const override;
bool overrideGfxPartitionLayoutForWsl() const override;
bool overrideResourceInfoParamsForWsl(DriverModelType driverModelType) const override;
uint32_t getHwRevIdFromStepping(uint32_t stepping, const HardwareInfo &hwInfo) const override;
uint32_t getSteppingFromHwRevId(const HardwareInfo &hwInfo) const override;
uint32_t getAubStreamSteppingFromHwRevId(const HardwareInfo &hwInfo) const override;

5
shared/source/os_interface/hw_info_config.inl
View File

@ -124,11 +124,6 @@ bool HwInfoConfigHw<gfxProduct>::overrideGfxPartitionLayoutForWsl() const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
bool HwInfoConfigHw<gfxProduct>::overrideResourceInfoParamsForWsl(DriverModelType driverModelType) const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
uint32_t HwInfoConfigHw<gfxProduct>::getHwRevIdFromStepping(uint32_t stepping, const HardwareInfo &hwInfo) const {
return CommonConstants::invalidStepping;

5
shared/source/xe_hpg_core/linux/hw_info_config_dg2.cpp
View File

@ -38,10 +38,5 @@ int HwInfoConfigHw<gfxProduct>::configureHardwareCustom(HardwareInfo *hwInfo, OS
return 0;
}
template <>
bool HwInfoConfigHw<gfxProduct>::overrideResourceInfoParamsForWsl(DriverModelType driverModelType) const {
return driverModelType == DriverModelType::WDDM;
}
template class HwInfoConfigHw<gfxProduct>;
} // namespace NEO

5
shared/test/common/mocks/mock_hw_info_config.cpp
View File

@ -277,9 +277,4 @@ bool HwInfoConfigHw<IGFX_UNKNOWN>::getUuid(Device *device, std::array<uint8_t, H
return false;
}
template <>
bool HwInfoConfigHw<IGFX_UNKNOWN>::overrideResourceInfoParamsForWsl(DriverModelType driverModelType) const {
return false;
}
} //namespace NEO

10
shared/test/unit_test/os_interface/wddm_linux/configure_device_address_space_drm_or_wddm_test.cpp
View File

@ -239,16 +239,6 @@ struct WddmLinuxTest : public ::testing::Test {
using GmmTestsDG2 = WddmLinuxTest;
HWTEST_EXCLUDE_PRODUCT(GmmTests, givenGmmWithForceLocalMemThenNonLocalIsSetToFalse, IGFX_XE_HPG_CORE);
HWTEST2_F(GmmTestsDG2, givenGmmForBufferWithForceLocalMemThenNonLocalIsSetToTrue, IsDG2) {
void *pSysMem = nullptr;
std::unique_ptr<NEO::Gmm> gmm(new NEO::Gmm(mockExecEnv.rootDeviceEnvironments[0]->getGmmClientContext(), pSysMem, 4096, 0, false, false, false, {}));
EXPECT_EQ(gmm->resourceParams.Flags.Info.NonLocalOnly, 1u);
EXPECT_EQ(gmm->resourceParams.Flags.Info.LocalOnly, 0u);
}
HWTEST2_F(GmmTestsDG2, givenGmmForImageWithForceLocalMemThenNonLocalIsSetToFalseAndoLocalOnlyIsSetToTrue, IsDG2) {
const_cast<NEO::HardwareInfo *>(mockExecEnv.rootDeviceEnvironments[0]->getHardwareInfo())->featureTable.flags.ftrLocalMemory = 1u;

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -5202,6 +5202,12 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_FLAG_REC> {
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
dst.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.Wa.PreGen12FastClearOnly)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN: {
dst.Wa.ForceStdAllocAlign = readTokValue<decltype(dst.Wa.ForceStdAllocAlign)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION: {
dst.Wa.DeniableLocalOnlyForCompression = readTokValue<decltype(dst.Wa.DeniableLocalOnlyForCompression)>(*tokWa);
} break;
};
tokWa = tokWa + 1 + tokWa->valueDwordCount;
} else {
@ -6288,6 +6294,12 @@ struct Demarshaller<TOK_S_GMM_TEXTURE_INFO_REC> {
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
dst.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN: {
dst.Flags.Wa.ForceStdAllocAlign = readTokValue<decltype(dst.Flags.Wa.ForceStdAllocAlign)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION: {
dst.Flags.Wa.DeniableLocalOnlyForCompression = readTokValue<decltype(dst.Flags.Wa.DeniableLocalOnlyForCompression)>(*tokWa);
} break;
};
tokWa = tokWa + 1 + tokWa->valueDwordCount;
} else {
@ -7363,6 +7375,12 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT> {
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
dst.Surf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.Surf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN: {
dst.Surf.Flags.Wa.ForceStdAllocAlign = readTokValue<decltype(dst.Surf.Flags.Wa.ForceStdAllocAlign)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION: {
dst.Surf.Flags.Wa.DeniableLocalOnlyForCompression = readTokValue<decltype(dst.Surf.Flags.Wa.DeniableLocalOnlyForCompression)>(*tokWa);
} break;
};
tokWa = tokWa + 1 + tokWa->valueDwordCount;
} else {
@ -8343,6 +8361,12 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT> {
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
dst.AuxSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.AuxSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN: {
dst.AuxSurf.Flags.Wa.ForceStdAllocAlign = readTokValue<decltype(dst.AuxSurf.Flags.Wa.ForceStdAllocAlign)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION: {
dst.AuxSurf.Flags.Wa.DeniableLocalOnlyForCompression = readTokValue<decltype(dst.AuxSurf.Flags.Wa.DeniableLocalOnlyForCompression)>(*tokWa);
} break;
};
tokWa = tokWa + 1 + tokWa->valueDwordCount;
} else {
@ -9323,6 +9347,12 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT> {
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
dst.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN: {
dst.AuxSecSurf.Flags.Wa.ForceStdAllocAlign = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.ForceStdAllocAlign)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION: {
dst.AuxSecSurf.Flags.Wa.DeniableLocalOnlyForCompression = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.DeniableLocalOnlyForCompression)>(*tokWa);
} break;
};
tokWa = tokWa + 1 + tokWa->valueDwordCount;
} else {
@ -10445,6 +10475,12 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT> {
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
dst.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN: {
dst.GmmResourceInfoCommon.Surf.Flags.Wa.ForceStdAllocAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.ForceStdAllocAlign)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION: {
dst.GmmResourceInfoCommon.Surf.Flags.Wa.DeniableLocalOnlyForCompression = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.DeniableLocalOnlyForCompression)>(*tokWa);
} break;
};
tokWa = tokWa + 1 + tokWa->valueDwordCount;
} else {
@ -11425,6 +11461,12 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT> {
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN: {
dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ForceStdAllocAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ForceStdAllocAlign)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION: {
dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DeniableLocalOnlyForCompression = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DeniableLocalOnlyForCompression)>(*tokWa);
} break;
};
tokWa = tokWa + 1 + tokWa->valueDwordCount;
} else {
@ -12405,6 +12447,12 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT> {
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN: {
dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ForceStdAllocAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ForceStdAllocAlign)>(*tokWa);
} break;
case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION: {
dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DeniableLocalOnlyForCompression = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DeniableLocalOnlyForCompression)>(*tokWa);
} break;
};
tokWa = tokWa + 1 + tokWa->valueDwordCount;
} else {

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -2556,6 +2556,8 @@ inline void marshall(TOKSTR_GMM_RESOURCE_FLAG_REC &dst, const GMM_RESOURCE_FLAG_
dst.Wa.DisableDisplayCcsClearColor.setValue(src.Wa.DisableDisplayCcsClearColor);
dst.Wa.DisableDisplayCcsCompression.setValue(src.Wa.DisableDisplayCcsCompression);
dst.Wa.PreGen12FastClearOnly.setValue(src.Wa.PreGen12FastClearOnly);
dst.Wa.ForceStdAllocAlign.setValue(src.Wa.ForceStdAllocAlign);
dst.Wa.DeniableLocalOnlyForCompression.setValue(src.Wa.DeniableLocalOnlyForCompression);
}
template <>
struct Marshaller<TOK_S_GMM_RESOURCE_FLAG_REC> {
@ -2828,6 +2830,8 @@ inline void marshall(TOKSTR_GMM_TEXTURE_INFO_REC &dst, const GMM_TEXTURE_INFO_RE
dst.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.Flags.Wa.DisableDisplayCcsClearColor);
dst.Flags.Wa.DisableDisplayCcsCompression.setValue(src.Flags.Wa.DisableDisplayCcsCompression);
dst.Flags.Wa.PreGen12FastClearOnly.setValue(src.Flags.Wa.PreGen12FastClearOnly);
dst.Flags.Wa.ForceStdAllocAlign.setValue(src.Flags.Wa.ForceStdAllocAlign);
dst.Flags.Wa.DeniableLocalOnlyForCompression.setValue(src.Flags.Wa.DeniableLocalOnlyForCompression);
dst.BaseWidth.setValue(src.BaseWidth);
dst.BaseHeight.setValue(src.BaseHeight);
dst.Depth.setValue(src.Depth);
@ -3039,6 +3043,8 @@ inline void marshall(TOKSTR_GmmResourceInfoCommonStruct &dst, const GmmResourceI
dst.Surf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.Surf.Flags.Wa.DisableDisplayCcsClearColor);
dst.Surf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.Surf.Flags.Wa.DisableDisplayCcsCompression);
dst.Surf.Flags.Wa.PreGen12FastClearOnly.setValue(src.Surf.Flags.Wa.PreGen12FastClearOnly);
dst.Surf.Flags.Wa.ForceStdAllocAlign.setValue(src.Surf.Flags.Wa.ForceStdAllocAlign);
dst.Surf.Flags.Wa.DeniableLocalOnlyForCompression.setValue(src.Surf.Flags.Wa.DeniableLocalOnlyForCompression);
dst.Surf.BaseWidth.setValue(src.Surf.BaseWidth);
dst.Surf.BaseHeight.setValue(src.Surf.BaseHeight);
dst.Surf.Depth.setValue(src.Surf.Depth);
@ -3216,6 +3222,8 @@ inline void marshall(TOKSTR_GmmResourceInfoCommonStruct &dst, const GmmResourceI
dst.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor);
dst.AuxSurf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.AuxSurf.Flags.Wa.DisableDisplayCcsCompression);
dst.AuxSurf.Flags.Wa.PreGen12FastClearOnly.setValue(src.AuxSurf.Flags.Wa.PreGen12FastClearOnly);
dst.AuxSurf.Flags.Wa.ForceStdAllocAlign.setValue(src.AuxSurf.Flags.Wa.ForceStdAllocAlign);
dst.AuxSurf.Flags.Wa.DeniableLocalOnlyForCompression.setValue(src.AuxSurf.Flags.Wa.DeniableLocalOnlyForCompression);
dst.AuxSurf.BaseWidth.setValue(src.AuxSurf.BaseWidth);
dst.AuxSurf.BaseHeight.setValue(src.AuxSurf.BaseHeight);
dst.AuxSurf.Depth.setValue(src.AuxSurf.Depth);
@ -3393,6 +3401,8 @@ inline void marshall(TOKSTR_GmmResourceInfoCommonStruct &dst, const GmmResourceI
dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor);
dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression);
dst.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly.setValue(src.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly);
dst.AuxSecSurf.Flags.Wa.ForceStdAllocAlign.setValue(src.AuxSecSurf.Flags.Wa.ForceStdAllocAlign);
dst.AuxSecSurf.Flags.Wa.DeniableLocalOnlyForCompression.setValue(src.AuxSecSurf.Flags.Wa.DeniableLocalOnlyForCompression);
dst.AuxSecSurf.BaseWidth.setValue(src.AuxSecSurf.BaseWidth);
dst.AuxSecSurf.BaseHeight.setValue(src.AuxSecSurf.BaseHeight);
dst.AuxSecSurf.Depth.setValue(src.AuxSecSurf.Depth);
@ -3598,6 +3608,8 @@ inline void marshall(TOKSTR_GmmResourceInfoWinStruct &dst, const GmmResourceInfo
dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsClearColor);
dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsCompression);
dst.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly);
dst.GmmResourceInfoCommon.Surf.Flags.Wa.ForceStdAllocAlign.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.ForceStdAllocAlign);
dst.GmmResourceInfoCommon.Surf.Flags.Wa.DeniableLocalOnlyForCompression.setValue(src.GmmResourceInfoCommon.Surf.Flags.Wa.DeniableLocalOnlyForCompression);
dst.GmmResourceInfoCommon.Surf.BaseWidth.setValue(src.GmmResourceInfoCommon.Surf.BaseWidth);
dst.GmmResourceInfoCommon.Surf.BaseHeight.setValue(src.GmmResourceInfoCommon.Surf.BaseHeight);
dst.GmmResourceInfoCommon.Surf.Depth.setValue(src.GmmResourceInfoCommon.Surf.Depth);
@ -3775,6 +3787,8 @@ inline void marshall(TOKSTR_GmmResourceInfoWinStruct &dst, const GmmResourceInfo
dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor);
dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsCompression);
dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly);
dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ForceStdAllocAlign.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ForceStdAllocAlign);
dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DeniableLocalOnlyForCompression.setValue(src.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DeniableLocalOnlyForCompression);
dst.GmmResourceInfoCommon.AuxSurf.BaseWidth.setValue(src.GmmResourceInfoCommon.AuxSurf.BaseWidth);
dst.GmmResourceInfoCommon.AuxSurf.BaseHeight.setValue(src.GmmResourceInfoCommon.AuxSurf.BaseHeight);
dst.GmmResourceInfoCommon.AuxSurf.Depth.setValue(src.GmmResourceInfoCommon.AuxSurf.Depth);
@ -3952,6 +3966,8 @@ inline void marshall(TOKSTR_GmmResourceInfoWinStruct &dst, const GmmResourceInfo
dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor);
dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression);
dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly);
dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ForceStdAllocAlign.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ForceStdAllocAlign);
dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DeniableLocalOnlyForCompression.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DeniableLocalOnlyForCompression);
dst.GmmResourceInfoCommon.AuxSecSurf.BaseWidth.setValue(src.GmmResourceInfoCommon.AuxSecSurf.BaseWidth);
dst.GmmResourceInfoCommon.AuxSecSurf.BaseHeight.setValue(src.GmmResourceInfoCommon.AuxSecSurf.BaseHeight);
dst.GmmResourceInfoCommon.AuxSecSurf.Depth.setValue(src.GmmResourceInfoCommon.AuxSecSurf.Depth);

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -779,6 +779,7 @@ enum TOK : uint32_t {
TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR = 3845,
TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION = 3846,
TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY = 3847,
TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN = 3848,
TOK_FS_GMM_RESOURCE_FLAG_REC__GPU = 3849,
TOK_FS_GMM_RESOURCE_FLAG_REC__INFO = 3850,
TOK_FS_GMM_RESOURCE_FLAG_REC__WA = 3851,
@ -891,6 +892,7 @@ enum TOK : uint32_t {
TOK_FS_TIME_STAMP_DATA_HEADER__M_HEADER = 3986,
TOK_FS_TIME_STAMP_DATA_HEADER__M_DATA = 3987,
TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM = 3988, // !(_DEBUG || _RELEASE_INTERNAL)
TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION = 4283,
//-------------------
};

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -1362,7 +1362,7 @@ struct TOKSTR_GMM_RESOURCE_FLAG_REC {
TokenVariableLength base;
TOKSTR_ANONYMOUS12521(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS12521, PreGen12FastClearOnly) + sizeof(PreGen12FastClearOnly) - offsetof(TOKSTR_ANONYMOUS12521, GTMfx2ndLevelBatchRingSizeAlign), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
: base(tokenId, elementId, offsetof(TOKSTR_ANONYMOUS12521, DeniableLocalOnlyForCompression) + sizeof(DeniableLocalOnlyForCompression) - offsetof(TOKSTR_ANONYMOUS12521, GTMfx2ndLevelBatchRingSizeAlign), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TOKSTR_ANONYMOUS12521()
: base(TOK_S_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521, 0, sizeof(*this) - sizeof(base)) {}
@ -1378,6 +1378,8 @@ struct TOKSTR_GMM_RESOURCE_FLAG_REC {
TokenDword DisableDisplayCcsClearColor = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR};
TokenDword DisableDisplayCcsCompression = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION};
TokenDword PreGen12FastClearOnly = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY};
TokenDword ForceStdAllocAlign = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__FORCE_STD_ALLOC_ALIGN};
TokenDword DeniableLocalOnlyForCompression = {TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DENIABLE_LOCAL_ONLY_FOR_COMPRESSION};
};
static_assert(std::is_standard_layout_v<TOKSTR_ANONYMOUS12521>, "");
static_assert(sizeof(TOKSTR_ANONYMOUS12521) % sizeof(uint32_t) == 0, "");
@ -1689,35 +1691,16 @@ struct TOKSTR_GmmResourceInfoCommonStruct {
static_assert(std::is_standard_layout_v<TOKSTR_GmmResourceInfoCommonStruct>, "");
static_assert(sizeof(TOKSTR_GmmResourceInfoCommonStruct) % sizeof(uint32_t) == 0, "");
struct TOKSTR_GmmResourceInfoWinStructPadding00 {
TokenVariableLength base;
TOKSTR_GmmResourceInfoWinStructPadding00(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR_GmmResourceInfoWinStructPadding00, padding000) + sizeof(padding000) - offsetof(TOKSTR_GmmResourceInfoWinStructPadding00, padding000), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TokenQword padding000 = {3933};
};
struct TOKSTR_GmmResourceInfoWinStructPadding0 {
TokenVariableLength base;
TOKSTR_GmmResourceInfoWinStructPadding0(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR_GmmResourceInfoWinStructPadding0, padding00) + sizeof(padding00) - offsetof(TOKSTR_GmmResourceInfoWinStructPadding0, padding00), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TOKSTR_GmmResourceInfoWinStructPadding00 padding00 = {3943};
};
struct TOKSTR_GmmResourceInfoWinStruct {
TokenVariableLength base;
TOKSTR_GmmResourceInfoWinStruct(uint16_t tokenId, uint32_t elementId = 0)
: base(tokenId, elementId, offsetof(TOKSTR_GmmResourceInfoWinStruct, padding0) + sizeof(padding0) - offsetof(TOKSTR_GmmResourceInfoWinStruct, GmmResourceInfoCommon), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
: base(tokenId, elementId, offsetof(TOKSTR_GmmResourceInfoWinStruct, GmmResourceInfoCommon) + sizeof(GmmResourceInfoCommon) - offsetof(TOKSTR_GmmResourceInfoWinStruct, GmmResourceInfoCommon), (sizeof(*this) - sizeof(base)) / sizeof(uint32_t)) {}
TOKSTR_GmmResourceInfoWinStruct()
: base(TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT, 0, sizeof(*this) - sizeof(base)) {}
TOKSTR_GmmResourceInfoCommonStruct GmmResourceInfoCommon = {TOK_FS_GMM_RESOURCE_INFO_WIN_STRUCT__GMM_RESOURCE_INFO_COMMON};
TOKSTR_GmmResourceInfoWinStructPadding0 padding0 = {3967};
};
static_assert(std::is_standard_layout_v<TOKSTR_GmmResourceInfoWinStruct>, "");
static_assert(sizeof(TOKSTR_GmmResourceInfoWinStruct) % sizeof(uint32_t) == 0, "");