Trait opencv::core::DeviceInfoTraitConst[−][src]

pub trait DeviceInfoTraitConst {

Show 59 methods    fn as_raw_DeviceInfo(&self) -> *const c_void;

    fn device_id(&self) -> Result<i32> { ... }

    fn name(&self) -> Result<String> { ... }

    fn total_global_mem(&self) -> Result<size_t> { ... }

    fn shared_mem_per_block(&self) -> Result<size_t> { ... }

    fn regs_per_block(&self) -> Result<i32> { ... }

    fn warp_size(&self) -> Result<i32> { ... }

    fn mem_pitch(&self) -> Result<size_t> { ... }

    fn max_threads_per_block(&self) -> Result<i32> { ... }

    fn max_threads_dim(&self) -> Result<Vec3i> { ... }

    fn max_grid_size(&self) -> Result<Vec3i> { ... }

    fn clock_rate(&self) -> Result<i32> { ... }

    fn total_const_mem(&self) -> Result<size_t> { ... }

    fn major_version(&self) -> Result<i32> { ... }

    fn minor_version(&self) -> Result<i32> { ... }

    fn texture_alignment(&self) -> Result<size_t> { ... }

    fn texture_pitch_alignment(&self) -> Result<size_t> { ... }

    fn multi_processor_count(&self) -> Result<i32> { ... }

    fn kernel_exec_timeout_enabled(&self) -> Result<bool> { ... }

    fn integrated(&self) -> Result<bool> { ... }

    fn can_map_host_memory(&self) -> Result<bool> { ... }

    fn compute_mode(&self) -> Result<DeviceInfo_ComputeMode> { ... }

    fn max_texture1_d(&self) -> Result<i32> { ... }

    fn max_texture1_d_mipmap(&self) -> Result<i32> { ... }

    fn max_texture1_d_linear(&self) -> Result<i32> { ... }

    fn max_texture_2d(&self) -> Result<Vec2i> { ... }

    fn max_texture2_d_mipmap(&self) -> Result<Vec2i> { ... }

    fn max_texture2_d_linear(&self) -> Result<Vec3i> { ... }

    fn max_texture2_d_gather(&self) -> Result<Vec2i> { ... }

    fn max_texture_3d(&self) -> Result<Vec3i> { ... }

    fn max_texture_cubemap(&self) -> Result<i32> { ... }

    fn max_texture1_d_layered(&self) -> Result<Vec2i> { ... }

    fn max_texture2_d_layered(&self) -> Result<Vec3i> { ... }

    fn max_texture_cubemap_layered(&self) -> Result<Vec2i> { ... }

    fn max_surface1_d(&self) -> Result<i32> { ... }

    fn max_surface_2d(&self) -> Result<Vec2i> { ... }

    fn max_surface_3d(&self) -> Result<Vec3i> { ... }

    fn max_surface1_d_layered(&self) -> Result<Vec2i> { ... }

    fn max_surface2_d_layered(&self) -> Result<Vec3i> { ... }

    fn max_surface_cubemap(&self) -> Result<i32> { ... }

    fn max_surface_cubemap_layered(&self) -> Result<Vec2i> { ... }

    fn surface_alignment(&self) -> Result<size_t> { ... }

    fn concurrent_kernels(&self) -> Result<bool> { ... }

    fn ecc_enabled(&self) -> Result<bool> { ... }

    fn pci_bus_id(&self) -> Result<i32> { ... }

    fn pci_device_id(&self) -> Result<i32> { ... }

    fn pci_domain_id(&self) -> Result<i32> { ... }

    fn tcc_driver(&self) -> Result<bool> { ... }

    fn async_engine_count(&self) -> Result<i32> { ... }

    fn unified_addressing(&self) -> Result<bool> { ... }

    fn memory_clock_rate(&self) -> Result<i32> { ... }

    fn memory_bus_width(&self) -> Result<i32> { ... }

    fn l2_cache_size(&self) -> Result<i32> { ... }

    fn max_threads_per_multi_processor(&self) -> Result<i32> { ... }

    fn query_memory(
        &self, 
        total_memory: &mut size_t, 
        free_memory: &mut size_t
    ) -> Result<()> { ... }

    fn free_memory(&self) -> Result<size_t> { ... }

    fn total_memory(&self) -> Result<size_t> { ... }

    fn supports(&self, feature_set: FeatureSet) -> Result<bool> { ... }

    fn is_compatible(&self) -> Result<bool> { ... }

}
Expand description

Class providing functionality for querying the specified GPU properties.

Required methods

Provided methods

Returns system index of the CUDA device starting with 0.

ASCII string identifying device

global memory available on device in bytes

shared memory available per block in bytes

32-bit registers available per block

warp size in threads

maximum pitch in bytes allowed by memory copies

maximum number of threads per block

maximum size of each dimension of a block

maximum size of each dimension of a grid

clock frequency in kilohertz

constant memory available on device in bytes

major compute capability

minor compute capability

alignment requirement for textures

pitch alignment requirement for texture references bound to pitched memory

number of multiprocessors on device

specified whether there is a run time limit on kernels

device is integrated as opposed to discrete

device can map host memory with cudaHostAlloc/cudaHostGetDevicePointer

compute mode

maximum 1D texture size

maximum 1D mipmapped texture size

maximum size for 1D textures bound to linear memory

maximum 2D texture dimensions

maximum 2D mipmapped texture dimensions

maximum dimensions (width, height, pitch) for 2D textures bound to pitched memory

maximum 2D texture dimensions if texture gather operations have to be performed

maximum 3D texture dimensions

maximum Cubemap texture dimensions

maximum 1D layered texture dimensions

maximum 2D layered texture dimensions

maximum Cubemap layered texture dimensions

maximum 1D surface size

maximum 2D surface dimensions

maximum 3D surface dimensions

maximum 1D layered surface dimensions

maximum 2D layered surface dimensions

maximum Cubemap surface dimensions

maximum Cubemap layered surface dimensions

alignment requirements for surfaces

device can possibly execute multiple kernels concurrently

device has ECC support enabled

PCI bus ID of the device

PCI device ID of the device

PCI domain ID of the device

true if device is a Tesla device using TCC driver, false otherwise

number of asynchronous engines

device shares a unified address space with the host

peak memory clock frequency in kilohertz

global memory bus width in bits

size of L2 cache in bytes

maximum resident threads per multiprocessor

gets free and total device memory

Provides information on CUDA feature support.

Parameters
  • feature_set: Features to be checked. See cuda::FeatureSet.

This function returns true if the device has the specified CUDA feature. Otherwise, it returns false

Checks the CUDA module and device compatibility.

This function returns true if the CUDA module can be run on the specified device. Otherwise, it returns false .

Implementors