Vulkan.Extensions.VK_AMD_shader_core_properties

Name

VK_AMD_shader_core_properties - device extension

VK_AMD_shader_core_properties

Name String

VK_AMD_shader_core_properties

Extension Type

Device extension

Registered Extension Number

186

Revision

2

Extension and Version Dependencies

• Requires Vulkan 1.0
• Requires VK_KHR_get_physical_device_properties2

Contact

• Martin Dinkov https://github.com/KhronosGroup/Vulkan-Docs/issues/new?title=VK_AMD_shader_core_properties:%20&body=@mdinkov%20

Other Extension Metadata

Last Modified Date

2019-06-25

IP Status

No known IP claims.

Contributors

• Martin Dinkov, AMD
• Matthaeus G. Chajdas, AMD

Description

This extension exposes shader core properties for a target physical device through the VK_KHR_get_physical_device_properties2 extension. Please refer to the example below for proper usage.

New Structures

• Extending PhysicalDeviceProperties2:

  • PhysicalDeviceShaderCorePropertiesAMD

New Enum Constants

• AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME

• AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION

• Extending StructureType:

  • STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD

Examples

This example retrieves the shader core properties for a physical device.

extern VkInstance       instance;

PFN_vkGetPhysicalDeviceProperties2 pfnVkGetPhysicalDeviceProperties2 =
    reinterpret_cast<PFN_vkGetPhysicalDeviceProperties2>
    (vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2") );

VkPhysicalDeviceProperties2             general_props;
VkPhysicalDeviceShaderCorePropertiesAMD shader_core_properties;

shader_core_properties.pNext = nullptr;
shader_core_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;

general_props.pNext = &shader_core_properties;
general_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;

// After this call, shader_core_properties has been populated
pfnVkGetPhysicalDeviceProperties2(device, &general_props);

printf("Number of shader engines: %d\n",
    m_shader_core_properties.shader_engine_count =
    shader_core_properties.shaderEngineCount;
printf("Number of shader arrays: %d\n",
    m_shader_core_properties.shader_arrays_per_engine_count =
    shader_core_properties.shaderArraysPerEngineCount;
printf("Number of CUs per shader array: %d\n",
    m_shader_core_properties.compute_units_per_shader_array =
    shader_core_properties.computeUnitsPerShaderArray;
printf("Number of SIMDs per compute unit: %d\n",
    m_shader_core_properties.simd_per_compute_unit =
    shader_core_properties.simdPerComputeUnit;
printf("Number of wavefront slots in each SIMD: %d\n",
    m_shader_core_properties.wavefronts_per_simd =
    shader_core_properties.wavefrontsPerSimd;
printf("Number of threads per wavefront: %d\n",
    m_shader_core_properties.wavefront_size =
    shader_core_properties.wavefrontSize;
printf("Number of physical SGPRs per SIMD: %d\n",
    m_shader_core_properties.sgprs_per_simd =
    shader_core_properties.sgprsPerSimd;
printf("Minimum number of SGPRs that can be allocated by a wave: %d\n",
    m_shader_core_properties.min_sgpr_allocation =
    shader_core_properties.minSgprAllocation;
printf("Number of available SGPRs: %d\n",
    m_shader_core_properties.max_sgpr_allocation =
    shader_core_properties.maxSgprAllocation;
printf("SGPRs are allocated in groups of this size: %d\n",
    m_shader_core_properties.sgpr_allocation_granularity =
    shader_core_properties.sgprAllocationGranularity;
printf("Number of physical VGPRs per SIMD: %d\n",
    m_shader_core_properties.vgprs_per_simd =
    shader_core_properties.vgprsPerSimd;
printf("Minimum number of VGPRs that can be allocated by a wave: %d\n",
    m_shader_core_properties.min_vgpr_allocation =
    shader_core_properties.minVgprAllocation;
printf("Number of available VGPRs: %d\n",
    m_shader_core_properties.max_vgpr_allocation =
    shader_core_properties.maxVgprAllocation;
printf("VGPRs are allocated in groups of this size: %d\n",
    m_shader_core_properties.vgpr_allocation_granularity =
    shader_core_properties.vgprAllocationGranularity;

Version History

• Revision 2, 2019-06-25 (Matthaeus G. Chajdas)

  • Clarified the meaning of a few fields.

• Revision 1, 2018-02-15 (Martin Dinkov)

  • Initial draft.

See Also

PhysicalDeviceShaderCorePropertiesAMD

Document Notes

For more information, see the Vulkan Specification

This page is a generated document. Fixes and changes should be made to the generator scripts, not directly.

Documentation

data PhysicalDeviceShaderCorePropertiesAMD

VkPhysicalDeviceShaderCorePropertiesAMD - Structure describing shader core properties that can be supported by an implementation

Description

If the PhysicalDeviceShaderCorePropertiesAMD structure is included in the pNext chain of the PhysicalDeviceProperties2 structure passed to getPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

See Also

StructureType

Constructors

PhysicalDeviceShaderCorePropertiesAMD

Fields

• shaderEngineCount :: Word32

  shaderEngineCount is an unsigned integer value indicating the number of shader engines found inside the shader core of the physical device.

• shaderArraysPerEngineCount :: Word32

  shaderArraysPerEngineCount is an unsigned integer value indicating the number of shader arrays inside a shader engine. Each shader array has its own scan converter, set of compute units, and a render back end (color and depth buffers). Shader arrays within a shader engine share shader processor input (wave launcher) and shader export (export buffer) units. Currently, a shader engine can have one or two shader arrays.

• computeUnitsPerShaderArray :: Word32

  computeUnitsPerShaderArray is an unsigned integer value indicating the physical number of compute units within a shader array. The active number of compute units in a shader array may be lower. A compute unit houses a set of SIMDs along with a sequencer module and a local data store.

• simdPerComputeUnit :: Word32

  simdPerComputeUnit is an unsigned integer value indicating the number of SIMDs inside a compute unit. Each SIMD processes a single instruction at a time.

• wavefrontsPerSimd :: Word32
• wavefrontSize :: Word32

  wavefrontSize is an unsigned integer value indicating the maximum size of a subgroup.

• sgprsPerSimd :: Word32

  sgprsPerSimd is an unsigned integer value indicating the number of physical Scalar General Purpose Registers (SGPRs) per SIMD.

• minSgprAllocation :: Word32

  minSgprAllocation is an unsigned integer value indicating the minimum number of SGPRs allocated for a wave.

• maxSgprAllocation :: Word32

  maxSgprAllocation is an unsigned integer value indicating the maximum number of SGPRs allocated for a wave.

• sgprAllocationGranularity :: Word32

  sgprAllocationGranularity is an unsigned integer value indicating the granularity of SGPR allocation for a wave.

• vgprsPerSimd :: Word32

  vgprsPerSimd is an unsigned integer value indicating the number of physical Vector General Purpose Registers (VGPRs) per SIMD.

• minVgprAllocation :: Word32

  minVgprAllocation is an unsigned integer value indicating the minimum number of VGPRs allocated for a wave.

• maxVgprAllocation :: Word32

  maxVgprAllocation is an unsigned integer value indicating the maximum number of VGPRs allocated for a wave.

• vgprAllocationGranularity :: Word32

  vgprAllocationGranularity is an unsigned integer value indicating the granularity of VGPR allocation for a wave.

Instances

Eq PhysicalDeviceShaderCorePropertiesAMD

Defined in Vulkan.Extensions.VK_AMD_shader_core_properties

Methods

(==) :: PhysicalDeviceShaderCorePropertiesAMD -> PhysicalDeviceShaderCorePropertiesAMD -> Bool

(/=) :: PhysicalDeviceShaderCorePropertiesAMD -> PhysicalDeviceShaderCorePropertiesAMD -> Bool

Show PhysicalDeviceShaderCorePropertiesAMD

Defined in Vulkan.Extensions.VK_AMD_shader_core_properties

Methods

showsPrec :: Int -> PhysicalDeviceShaderCorePropertiesAMD -> ShowS

show :: PhysicalDeviceShaderCorePropertiesAMD -> String

showList :: [PhysicalDeviceShaderCorePropertiesAMD] -> ShowS

Storable PhysicalDeviceShaderCorePropertiesAMD

Defined in Vulkan.Extensions.VK_AMD_shader_core_properties

Methods

sizeOf :: PhysicalDeviceShaderCorePropertiesAMD -> Int

alignment :: PhysicalDeviceShaderCorePropertiesAMD -> Int

peekElemOff :: Ptr PhysicalDeviceShaderCorePropertiesAMD -> Int -> IO PhysicalDeviceShaderCorePropertiesAMD

pokeElemOff :: Ptr PhysicalDeviceShaderCorePropertiesAMD -> Int -> PhysicalDeviceShaderCorePropertiesAMD -> IO ()

peekByteOff :: Ptr b -> Int -> IO PhysicalDeviceShaderCorePropertiesAMD

pokeByteOff :: Ptr b -> Int -> PhysicalDeviceShaderCorePropertiesAMD -> IO ()

peek :: Ptr PhysicalDeviceShaderCorePropertiesAMD -> IO PhysicalDeviceShaderCorePropertiesAMD

poke :: Ptr PhysicalDeviceShaderCorePropertiesAMD -> PhysicalDeviceShaderCorePropertiesAMD -> IO ()

FromCStruct PhysicalDeviceShaderCorePropertiesAMD

Defined in Vulkan.Extensions.VK_AMD_shader_core_properties

Methods

peekCStruct :: Ptr PhysicalDeviceShaderCorePropertiesAMD -> IO PhysicalDeviceShaderCorePropertiesAMD

ToCStruct PhysicalDeviceShaderCorePropertiesAMD

Defined in Vulkan.Extensions.VK_AMD_shader_core_properties

Methods

withCStruct :: PhysicalDeviceShaderCorePropertiesAMD -> (Ptr PhysicalDeviceShaderCorePropertiesAMD -> IO b) -> IO b

pokeCStruct :: Ptr PhysicalDeviceShaderCorePropertiesAMD -> PhysicalDeviceShaderCorePropertiesAMD -> IO b -> IO b

withZeroCStruct :: (Ptr PhysicalDeviceShaderCorePropertiesAMD -> IO b) -> IO b

pokeZeroCStruct :: Ptr PhysicalDeviceShaderCorePropertiesAMD -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero PhysicalDeviceShaderCorePropertiesAMD

Defined in Vulkan.Extensions.VK_AMD_shader_core_properties

Methods

zero :: PhysicalDeviceShaderCorePropertiesAMD

type AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION = 2

pattern AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION :: forall a. Integral a => a

type AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME = "VK_AMD_shader_core_properties"

pattern AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a