Struct hip_sys::hiprt::hipDeviceProp_t

#[repr(C)]
pub struct hipDeviceProp_t {

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

hipDeviceProp

Fields

name: [i8; 256]

< Device name.

totalGlobalMem: usize

< Size of global memory region (in bytes).

sharedMemPerBlock: usize

< Size of shared memory region (in bytes).

regsPerBlock: i32

< Registers per block.

warpSize: i32

< Warp size.

maxThreadsPerBlock: i32

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

maxThreadsDim: [i32; 3]

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

maxGridSize: [i32; 3]

< Max grid dimensions (XYZ).

clockRate: i32

< Max clock frequency of the multiProcessors in khz.

memoryClockRate: i32

< Max global memory clock frequency in khz.

memoryBusWidth: i32

< Global memory bus width in bits.

totalConstMem: usize

< Size of shared memory region (in bytes).

major: i32

< 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: i32

< 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: i32

< Number of multi-processors (compute units).

l2CacheSize: i32

< L2 cache size.

maxThreadsPerMultiProcessor: i32

< Maximum resident threads per multi-processor.

computeMode: i32

< Compute mode.

clockInstructionRate: i32

< 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: i32

< Device can possibly execute multiple kernels concurrently.

pciDomainID: i32

< PCI Domain ID

pciBusID: i32

< PCI Bus ID.

pciDeviceID: i32

< PCI Device ID.

maxSharedMemoryPerMultiProcessor: usize

< Maximum Shared Memory Per Multiprocessor.

isMultiGpuBoard: i32

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

canMapHostMemory: i32

< Check whether HIP can map host memory

gcnArch: i32

< DEPRECATED: use gcnArchName instead

gcnArchName: [i8; 256]

< AMD GCN Arch Name.

integrated: i32

< APU vs dGPU

cooperativeLaunch: i32

< HIP device supports cooperative launch

cooperativeMultiDeviceLaunch: i32

< HIP device supports cooperative launch on multiple devices

maxTexture1DLinear: i32

< Maximum size for 1D textures bound to linear memory

maxTexture1D: i32

< Maximum number of elements in 1D images

maxTexture2D: [i32; 2]

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

maxTexture3D: [i32; 3]

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

hdpMemFlushCntl: *mut u32

< Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register

hdpRegFlushCntl: *mut u32

< 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: i32

<Run time limit for kernels executed on the device

ECCEnabled: i32

<Device has ECC support enabled

tccDriver: i32

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

cooperativeMultiDeviceUnmatchedFunc: i32

< HIP device supports cooperative launch on multiple

cooperativeMultiDeviceUnmatchedGridDim: i32

< HIP device supports cooperative launch on multiple

cooperativeMultiDeviceUnmatchedBlockDim: i32

< HIP device supports cooperative launch on multiple

cooperativeMultiDeviceUnmatchedSharedMem: i32

< HIP device supports cooperative launch on multiple

isLargeBar: i32

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

asicRevision: i32

< Revision of the GPU in this device

managedMemory: i32

< Device supports allocating managed memory on this system

directManagedMemAccessFromHost: i32

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

concurrentManagedAccess: i32

< Device can coherently access managed memory concurrently with the CPU

pageableMemoryAccess: i32

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

pageableMemoryAccessUsesHostPageTables: i32

< 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<(), Error>

Formats the value using the given formatter.

impl Default for hipDeviceProp_t

fn default() -> hipDeviceProp_t

Returns the “default value” for a type.

impl Hash for hipDeviceProp_t

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

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