Struct hip_runtime_sys::hipDeviceProp_t

#[repr(C)]
pub struct hipDeviceProp_t {

    pub name: [c_char; 256],
    pub totalGlobalMem: usize,
    pub sharedMemPerBlock: usize,
    pub regsPerBlock: c_int,
    pub warpSize: c_int,
    pub maxThreadsPerBlock: c_int,
    pub maxThreadsDim: [c_int; 3],
    pub maxGridSize: [c_int; 3],
    pub clockRate: c_int,
    pub memoryClockRate: c_int,
    pub memoryBusWidth: c_int,
    pub totalConstMem: usize,
    pub major: c_int,
    pub minor: c_int,
    pub multiProcessorCount: c_int,
    pub l2CacheSize: c_int,
    pub maxThreadsPerMultiProcessor: c_int,
    pub computeMode: c_int,
    pub clockInstructionRate: c_int,
    pub arch: hipDeviceArch_t,
    pub concurrentKernels: c_int,
    pub pciDomainID: c_int,
    pub pciBusID: c_int,
    pub pciDeviceID: c_int,
    pub maxSharedMemoryPerMultiProcessor: usize,
    pub isMultiGpuBoard: c_int,
    pub canMapHostMemory: c_int,
    pub gcnArch: c_int,
    pub gcnArchName: [c_char; 256],
    pub integrated: c_int,
    pub cooperativeLaunch: c_int,
    pub cooperativeMultiDeviceLaunch: c_int,
    pub maxTexture1DLinear: c_int,
    pub maxTexture1D: c_int,
    pub maxTexture2D: [c_int; 2],
    pub maxTexture3D: [c_int; 3],
    pub hdpMemFlushCntl: *mut c_uint,
    pub hdpRegFlushCntl: *mut c_uint,
    pub memPitch: usize,
    pub textureAlignment: usize,
    pub texturePitchAlignment: usize,
    pub kernelExecTimeoutEnabled: c_int,
    pub ECCEnabled: c_int,
    pub tccDriver: c_int,
    pub cooperativeMultiDeviceUnmatchedFunc: c_int,
    pub cooperativeMultiDeviceUnmatchedGridDim: c_int,
    pub cooperativeMultiDeviceUnmatchedBlockDim: c_int,
    pub cooperativeMultiDeviceUnmatchedSharedMem: c_int,
    pub isLargeBar: c_int,
    pub asicRevision: c_int,
    pub managedMemory: c_int,
    pub directManagedMemAccessFromHost: c_int,
    pub concurrentManagedAccess: c_int,
    pub pageableMemoryAccess: c_int,
    pub pageableMemoryAccessUsesHostPageTables: c_int,
}

hipDeviceProp

Fields

name: [c_char; 256]

< Device name.

totalGlobalMem: usize

< Size of global memory region (in bytes).

sharedMemPerBlock: usize

< Size of shared memory region (in bytes).

regsPerBlock: c_int

< Registers per block.

warpSize: c_int

< Warp size.

maxThreadsPerBlock: c_int

< Max work items per work group or workgroup max size.

maxThreadsDim: [c_int; 3]

< Max number of threads in each dimension (XYZ) of a block.

maxGridSize: [c_int; 3]

< Max grid dimensions (XYZ).

clockRate: c_int

< Max clock frequency of the multiProcessors in khz.

memoryClockRate: c_int

< Max global memory clock frequency in khz.

memoryBusWidth: c_int

< Global memory bus width in bits.

totalConstMem: usize

< Size of shared memory region (in bytes).

major: c_int

< Major compute capability. On HCC, this is an approximation and features may < differ from CUDA CC. See the arch feature flags for portable ways to query < feature caps.

minor: c_int

< Minor compute capability. On HCC, this is an approximation and features may < differ from CUDA CC. See the arch feature flags for portable ways to query < feature caps.

multiProcessorCount: c_int

< Number of multi-processors (compute units).

l2CacheSize: c_int

< L2 cache size.

maxThreadsPerMultiProcessor: c_int

< Maximum resident threads per multi-processor.

computeMode: c_int

< Compute mode.

clockInstructionRate: c_int

< Frequency in khz of the timer used by the device-side “clock*” < instructions. New for HIP.

arch: hipDeviceArch_t

< Architectural feature flags. New for HIP.

concurrentKernels: c_int

< Device can possibly execute multiple kernels concurrently.

pciDomainID: c_int

< PCI Domain ID

pciBusID: c_int

< PCI Bus ID.

pciDeviceID: c_int

< PCI Device ID.

maxSharedMemoryPerMultiProcessor: usize

< Maximum Shared Memory Per Multiprocessor.

isMultiGpuBoard: c_int

< 1 if device is on a multi-GPU board, 0 if not.

canMapHostMemory: c_int

< Check whether HIP can map host memory

gcnArch: c_int

< DEPRECATED: use gcnArchName instead

gcnArchName: [c_char; 256]

< AMD GCN Arch Name.

integrated: c_int

< APU vs dGPU

cooperativeLaunch: c_int

< HIP device supports cooperative launch

cooperativeMultiDeviceLaunch: c_int

< HIP device supports cooperative launch on multiple devices

maxTexture1DLinear: c_int

< Maximum size for 1D textures bound to linear memory

maxTexture1D: c_int

< Maximum number of elements in 1D images

maxTexture2D: [c_int; 2]

< Maximum dimensions (width, height) of 2D images, in image elements

maxTexture3D: [c_int; 3]

< Maximum dimensions (width, height, depth) of 3D images, in image elements

hdpMemFlushCntl: *mut c_uint

< Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register

hdpRegFlushCntl: *mut c_uint

< Addres of HDP_REG_COHERENCY_FLUSH_CNTL register

memPitch: usize

<Maximum pitch in bytes allowed by memory copies

textureAlignment: usize

<Alignment requirement for textures

texturePitchAlignment: usize

<Pitch alignment requirement for texture references bound to pitched memory

kernelExecTimeoutEnabled: c_int

<Run time limit for kernels executed on the device

ECCEnabled: c_int

<Device has ECC support enabled

tccDriver: c_int

< 1:If device is Tesla device using TCC driver, else 0

cooperativeMultiDeviceUnmatchedFunc: c_int

< HIP device supports cooperative launch on multiple

cooperativeMultiDeviceUnmatchedGridDim: c_int

< HIP device supports cooperative launch on multiple

cooperativeMultiDeviceUnmatchedBlockDim: c_int

< HIP device supports cooperative launch on multiple

cooperativeMultiDeviceUnmatchedSharedMem: c_int

< HIP device supports cooperative launch on multiple

isLargeBar: c_int

< 1: if it is a large PCI bar device, else 0

asicRevision: c_int

< Revision of the GPU in this device

managedMemory: c_int

< Device supports allocating managed memory on this system

directManagedMemAccessFromHost: c_int

< Host can directly access managed memory on the device without migration

concurrentManagedAccess: c_int

< Device can coherently access managed memory concurrently with the CPU

pageableMemoryAccess: c_int

< Device supports coherently accessing pageable memory < without calling hipHostRegister on it

pageableMemoryAccessUsesHostPageTables: c_int

< Device accesses pageable memory via the host’s page tables

Trait Implementations

impl Clone for hipDeviceProp_t

fn clone(&self) -> hipDeviceProp_t

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for hipDeviceProp_t

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for hipDeviceProp_t

fn default() -> Self

Returns the “default value” for a type.

impl Hash for hipDeviceProp_t

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for hipDeviceProp_t

fn cmp(&self, other: &hipDeviceProp_t) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<hipDeviceProp_t> for hipDeviceProp_t

fn eq(&self, other: &hipDeviceProp_t) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<hipDeviceProp_t> for hipDeviceProp_t

fn partial_cmp(&self, other: &hipDeviceProp_t) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for hipDeviceProp_t

impl Eq for hipDeviceProp_t

impl StructuralEq for hipDeviceProp_t

impl StructuralPartialEq for hipDeviceProp_t