| // Copyright 2019 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include "src/dawn/native/d3d12/D3D12Info.h" |
| |
| #include <array> |
| #include <utility> |
| |
| #include "src/dawn/common/GPUInfo.h" |
| #include "src/dawn/native/d3d/D3DError.h" |
| #include "src/dawn/native/d3d12/BackendD3D12.h" |
| #include "src/dawn/native/d3d12/PhysicalDeviceD3D12.h" |
| #include "src/dawn/native/d3d12/PlatformFunctionsD3D12.h" |
| |
| namespace dawn::native::d3d12 { |
| |
| namespace { |
| #ifdef DAWN_USE_AGILITY_SDK |
| std::vector<D3D12DeviceInfo::LinAlgWMMSupport> GatherLinAlgWaveMatrixMultiplySupports( |
| ComPtr<ID3D12Device> d3d12Device, |
| uint32_t waveLaneCountMin) { |
| std::vector<D3D12DeviceInfo::LinAlgWMMSupport> result; |
| |
| auto typesToQuery = std::array{ |
| D3D12_LINEAR_ALGEBRA_DATATYPE_SINT32, // |
| D3D12_LINEAR_ALGEBRA_DATATYPE_UINT32, // |
| D3D12_LINEAR_ALGEBRA_DATATYPE_FLOAT16, // |
| D3D12_LINEAR_ALGEBRA_DATATYPE_FLOAT32, // |
| D3D12_LINEAR_ALGEBRA_DATATYPE_SINT8, // |
| D3D12_LINEAR_ALGEBRA_DATATYPE_UINT8, // |
| }; |
| |
| for (auto dataTypeAB : typesToQuery) { |
| for (auto dataTypeAcc : typesToQuery) { |
| D3D12_FEATURE_DATA_LINEAR_ALGEBRA_MATRIX_OPERATION_SUPPORT opSupport{}; |
| opSupport.OperationType = D3D12_LINEAR_ALGEBRA_OPERATION_TYPE_WAVE_MATRIX_MULTIPLY; |
| opSupport.WaveMatrixMultiply = {}; |
| // Set WaveSize to waveLaneCountMin only. We assume if shapes are returned for this |
| // size, they are supported for all supported wave sizes (waveLaneCountMin to |
| // waveLaneCountMax). |
| // TODO(crbug.com/527055544): We should be able to set this to '0' instead. |
| DAWN_ASSERT(waveLaneCountMin != 0); |
| opSupport.WaveMatrixMultiply.Inputs.WaveSize = waveLaneCountMin; |
| opSupport.WaveMatrixMultiply.Inputs.MatrixAComponentType = dataTypeAB; |
| opSupport.WaveMatrixMultiply.Inputs.MatrixBComponentType = dataTypeAB; |
| opSupport.WaveMatrixMultiply.Inputs.AccumulatorComponentType = dataTypeAcc; |
| |
| // First call to get number of shapes |
| opSupport.WaveMatrixMultiply.NumShapes = 0; |
| opSupport.WaveMatrixMultiply.Shapes = nullptr; |
| |
| if (FAILED(d3d12Device->CheckFeatureSupport( |
| D3D12_FEATURE_LINEAR_ALGEBRA_LINEAR_ALGEBRA_MATRIX_OPERATION_SUPPORT, |
| &opSupport, sizeof(opSupport)))) { |
| continue; |
| } |
| |
| uint32_t numShapes = opSupport.WaveMatrixMultiply.NumShapes; |
| if (numShapes == 0) { |
| continue; |
| } |
| |
| // Second call to populate shapes |
| std::vector<D3D12_LINEAR_ALGEBRA_MATRIX_MULTIPLY_SHAPE> shapes(numShapes); |
| opSupport.WaveMatrixMultiply.Shapes = shapes.data(); |
| |
| if (FAILED(d3d12Device->CheckFeatureSupport( |
| D3D12_FEATURE_LINEAR_ALGEBRA_LINEAR_ALGEBRA_MATRIX_OPERATION_SUPPORT, |
| &opSupport, sizeof(opSupport)))) { |
| continue; |
| } |
| |
| // Add support entry |
| auto wmm = opSupport.WaveMatrixMultiply; |
| wmm.Shapes = nullptr; // Clear so that we don't attempt to use this |
| result.emplace_back(wmm.Inputs, wmm.SupportFlags, std::move(shapes)); |
| } |
| } |
| |
| return result; |
| } |
| #endif // DAWN_USE_AGILITY_SDK |
| } // namespace |
| |
| ResultOrError<D3D12DeviceInfo> GatherDeviceInfo(const PhysicalDevice& physicalDevice) { |
| D3D12DeviceInfo info = {}; |
| |
| ComPtr<ID3D12Device> d3d12Device = physicalDevice.GetDevice(); |
| |
| // Newer builds replace D3D_FEATURE_DATA_ARCHITECTURE with |
| // D3D_FEATURE_DATA_ARCHITECTURE1. However, D3D_FEATURE_DATA_ARCHITECTURE can be used |
| // for backwards compat. |
| // https://docs.microsoft.com/en-us/windows/desktop/api/d3d12/ne-d3d12-d3d12_feature |
| D3D12_FEATURE_DATA_ARCHITECTURE arch = {}; |
| DAWN_TRY(CheckHRESULT( |
| d3d12Device->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE, &arch, sizeof(arch)), |
| "ID3D12Device::CheckFeatureSupport")); |
| |
| info.isUMA = arch.UMA; |
| info.isCacheCoherentUMA = arch.CacheCoherentUMA; |
| |
| D3D12_FEATURE_DATA_D3D12_OPTIONS featureOptions = {}; |
| DAWN_TRY(CheckHRESULT(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, |
| &featureOptions, sizeof(featureOptions)), |
| "ID3D12Device::CheckFeatureSupport")); |
| info.resourceHeapTier = featureOptions.ResourceHeapTier; |
| info.resourceBindingTier = featureOptions.ResourceBindingTier; |
| |
| D3D12_FEATURE_DATA_D3D12_OPTIONS2 featureOptions2 = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS2, &featureOptions2, |
| sizeof(featureOptions2)))) { |
| info.programmableSamplePositionsTier = featureOptions2.ProgrammableSamplePositionsTier; |
| } |
| |
| D3D12_FEATURE_DATA_D3D12_OPTIONS3 featureOptions3 = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &featureOptions3, |
| sizeof(featureOptions3)))) { |
| info.supportsCastingFullyTypedFormat = featureOptions3.CastingFullyTypedFormatSupported; |
| } |
| |
| // Used to share resources cross-API. If we query CheckFeatureSupport for |
| // D3D12_FEATURE_D3D12_OPTIONS4 successfully, then we can use cross-API sharing. |
| info.supportsSharedResourceCapabilityTier1 = false; |
| D3D12_FEATURE_DATA_D3D12_OPTIONS4 featureOptions4 = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS4, &featureOptions4, |
| sizeof(featureOptions4)))) { |
| // Tier 1 support additionally enables the NV12 format. Since only the NV12 format |
| // is used by Dawn, check for Tier 1. |
| if (featureOptions4.SharedResourceCompatibilityTier >= |
| D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1) { |
| info.supportsSharedResourceCapabilityTier1 = true; |
| } |
| |
| // featureOptions4.MSAA64KBAlignedTextureSupported indicates whether 64KB-aligned MSAA |
| // textures are supported. |
| info.use64KBAlignedMSAATexture = featureOptions4.MSAA64KBAlignedTextureSupported; |
| |
| // To support shader f16 feature, both featureOptions4.Native16BitShaderOpsSupported and |
| // using shader model version >= 6.2 are required. |
| info.supportsNative16BitShaderOps = featureOptions4.Native16BitShaderOpsSupported; |
| } |
| |
| // D3D12_HEAP_FLAG_CREATE_NOT_ZEROED is available anytime that ID3D12Device8 is exposed, or a |
| // check for D3D12_FEATURE_D3D12_OPTIONS7 succeeds. |
| D3D12_FEATURE_DATA_D3D12_OPTIONS7 featureOptions7 = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &featureOptions7, |
| sizeof(featureOptions7)))) { |
| info.supportsHeapFlagCreateNotZeroed = true; |
| } |
| |
| D3D12_FEATURE_DATA_D3D12_OPTIONS8 featureOptions8 = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS8, &featureOptions8, |
| sizeof(featureOptions8)))) { |
| info.supportsTextureCompressionUnaligned = featureOptions8.UnalignedBlockTexturesSupported; |
| } |
| |
| D3D12_FEATURE_DATA_D3D12_OPTIONS13 featureOptions13 = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS13, &featureOptions13, |
| sizeof(featureOptions13)))) { |
| info.supportsTextureCopyBetweenDimensions = |
| featureOptions13.TextureCopyBetweenDimensionsSupported; |
| info.supportsUnrestrictedBufferTextureCopyPitch = |
| featureOptions13.UnrestrictedBufferTextureCopyPitchSupported; |
| } |
| |
| #if D3D12_SDK_VERSION >= 612 |
| D3D12_FEATURE_DATA_D3D12_OPTIONS18 featureOptions18 = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS18, &featureOptions18, |
| sizeof(featureOptions18)))) { |
| info.supportsRenderPass = featureOptions18.RenderPassesValid; |
| } |
| #endif |
| |
| info.supportsRootSignatureVersion1_1 = false; |
| D3D12_FEATURE_DATA_ROOT_SIGNATURE featureDataRootSignature = {}; |
| featureDataRootSignature.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_ROOT_SIGNATURE, |
| &featureDataRootSignature, |
| sizeof(featureDataRootSignature)))) { |
| info.supportsRootSignatureVersion1_1 = |
| featureDataRootSignature.HighestVersion >= D3D_ROOT_SIGNATURE_VERSION_1_1; |
| } |
| |
| D3D12_FEATURE_DATA_EXISTING_HEAPS existingHeapInfo = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_EXISTING_HEAPS, &existingHeapInfo, |
| sizeof(existingHeapInfo)))) { |
| info.supportsExistingHeap = existingHeapInfo.Supported; |
| } |
| |
| // D3D_SHADER_MODEL_6_10 is only defined in the Agility SDK headers; guard it |
| // so builds that fall back to the Windows SDK header still compile. |
| D3D12_FEATURE_DATA_SHADER_MODEL knownShaderModels[] = { |
| #ifdef DAWN_USE_AGILITY_SDK |
| {D3D_SHADER_MODEL_6_10}, |
| #endif |
| {D3D_SHADER_MODEL_6_9}, {D3D_SHADER_MODEL_6_8}, {D3D_SHADER_MODEL_6_7}, |
| {D3D_SHADER_MODEL_6_6}, {D3D_SHADER_MODEL_6_5}, {D3D_SHADER_MODEL_6_4}, |
| {D3D_SHADER_MODEL_6_3}, {D3D_SHADER_MODEL_6_2}, {D3D_SHADER_MODEL_6_1}, |
| {D3D_SHADER_MODEL_6_0}, {D3D_SHADER_MODEL_5_1}}; |
| |
| uint32_t driverShaderModel = 0; |
| for (D3D12_FEATURE_DATA_SHADER_MODEL shaderModel : knownShaderModels) { |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport(D3D12_FEATURE_SHADER_MODEL, &shaderModel, |
| sizeof(shaderModel)))) { |
| driverShaderModel = shaderModel.HighestShaderModel; |
| break; |
| } |
| } |
| |
| if (driverShaderModel < D3D_SHADER_MODEL_5_1) { |
| return DAWN_INTERNAL_ERROR("Driver doesn't support Shader Model 5.1 or higher"); |
| } |
| |
| // D3D_SHADER_MODEL is encoded as 0xMm with M the major version and m the minor version |
| |
| DAWN_ASSERT(driverShaderModel <= 0xFF); |
| uint32_t shaderModelMajor = (driverShaderModel & 0xF0) >> 4; |
| uint32_t shaderModelMinor = (driverShaderModel & 0xF); |
| |
| DAWN_ASSERT(shaderModelMajor < 10); |
| DAWN_ASSERT(shaderModelMinor < 16); |
| // TODO(crbug.com/513251803): Don't use shader model as decimal value |
| info.highestSupportedShaderModel = 10 * shaderModelMajor + shaderModelMinor; |
| |
| // Device support wave intrinsics if shader model >= SM6.0 and capabilities flag WaveOps is set. |
| // https://github.com/Microsoft/DirectXShaderCompiler/wiki/Wave-Intrinsics |
| if (driverShaderModel >= D3D_SHADER_MODEL_6_0) { |
| D3D12_FEATURE_DATA_D3D12_OPTIONS1 featureOptions1 = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport( |
| D3D12_FEATURE_D3D12_OPTIONS1, &featureOptions1, sizeof(featureOptions1)))) { |
| info.supportsWaveOps = featureOptions1.WaveOps; |
| info.waveLaneCountMin = featureOptions1.WaveLaneCountMin; |
| // Currently the WaveLaneCountMax queried from D3D12 API is not reliable and the meaning |
| // is unclear. The result is recorded into D3D12DeviceInfo, but is not intended to be |
| // used now. |
| info.waveLaneCountMax = featureOptions1.WaveLaneCountMax; |
| |
| if (driverShaderModel >= D3D_SHADER_MODEL_6_6 && featureOptions1.Int64ShaderOps) { |
| D3D12_FEATURE_DATA_D3D12_OPTIONS9 featureOptions9 = {}; |
| if (SUCCEEDED(d3d12Device->CheckFeatureSupport( |
| D3D12_FEATURE_D3D12_OPTIONS9, &featureOptions9, sizeof(featureOptions9)))) { |
| info.supportsInt64Atomics = featureOptions9.AtomicInt64OnTypedResourceSupported; |
| } |
| } |
| } |
| } |
| { |
| DXGI_ADAPTER_DESC adapterDesc; |
| DAWN_TRY(CheckHRESULT(physicalDevice.GetHardwareAdapter()->GetDesc(&adapterDesc), |
| "IDXGIAdapter3::GetDesc")); |
| info.dedicatedVideoMemory = adapterDesc.DedicatedVideoMemory; |
| info.sharedSystemMemory = adapterDesc.SharedSystemMemory; |
| } |
| |
| #ifdef DAWN_USE_AGILITY_SDK |
| info.linAlgWaveMatrixMultiplySupports = |
| GatherLinAlgWaveMatrixMultiplySupports(d3d12Device, info.waveLaneCountMin); |
| #endif |
| |
| return std::move(info); |
| } |
| |
| } // namespace dawn::native::d3d12 |
