Enum EngineCapability 

#[repr(i32)]
pub enum EngineCapability {
    kSTANDARD = 0,
    kSAFETY = 1,
    kDLA_STANDALONE = 2,
}

EngineCapability

List of supported engine capability flows.

The EngineCapability determines the restrictions of a network during build time and what runtime it targets. EngineCapability::kSTANDARD does not provide any restrictions on functionality and the resulting serialized engine can be executed with TensorRT’s standard runtime APIs in the nvinfer1 namespace. EngineCapability::kSAFETY provides a restricted subset of network operations that are safety certified and the resulting serialized engine can be executed with TensorRT’s safe runtime APIs in the nvinfer2::safe namespace. EngineCapability::kDLA_STANDALONE provides a restricted subset of network operations that are DLA compatible and the resulting serialized engine can be executed using standalone DLA runtime APIs. See sampleCudla for an example of integrating cuDLA APIs with TensorRT APIs.

Variants

kSTANDARD = 0

Standard: TensorRT flow without targeting the safety runtime. This flow supports both DeviceType::kGPU and DeviceType::kDLA.

kSAFETY = 1

Safety: TensorRT flow with restrictions targeting the safety runtime. See safety documentation for list of supported layers and formats. This flow supports only DeviceType::kGPU.

This flag is only supported in NVIDIA Drive(R) products.

kDLA_STANDALONE = 2

DLA Standalone: TensorRT flow with restrictions targeting external, to TensorRT, DLA runtimes. See DLA documentation for list of supported layers and formats. This flow supports only DeviceType::kDLA.

Trait Implementations

impl Clone for EngineCapability

fn clone(&self) -> EngineCapability

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Eq for EngineCapability

impl ExternType for EngineCapability

type Id = (n, v, i, n, f, e, r, _1, (), E, n, g, i, n, e, C, a, p, a, b, i, l, i, t, y)

A type-level representation of the type’s C++ namespace and type name.

type Kind = Trivial

Either cxx::kind::Opaque or cxx::kind::Trivial.

impl From<EngineCapability> for EngineCapability

fn from(value: EngineCapability) -> Self

Converts to this type from the input type.

impl Hash for EngineCapability

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 Into<EngineCapability> for EngineCapability

fn into(self) -> EngineCapability

Converts this type into the (usually inferred) input type.

impl PartialEq for EngineCapability

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl SharedPtrTarget for EngineCapability

impl StructuralPartialEq for EngineCapability

impl UniquePtrTarget for EngineCapability

impl VectorElement for EngineCapability

impl WeakPtrTarget for EngineCapability