Struct VectorConfig 

pub struct VectorConfig<Hart>
where
    Hart: VectorHartConfig,
{ /* private fields */ }

Vector configuration: vtype together with vl, where vl never exceeds VLMAX of vtype.

Neither vtype nor vl can be written by Zicsr instructions, they only ever change together through vset{i}vl{i} and fault-only-first loads (which only shrink vl), so this is the architectural state as a single value. Constructors enforce the invariant, which unsafe code relies on to access vector register elements without bounds checks, so there must be no way to construct an instance that violates it.

vill is represented as None in Option<VectorConfig>, vl is zero then.

Implementations

impl<Hart> VectorConfig<Hart>

where Hart: VectorHartConfig,

pub const fn new(vtype: Vtype<Hart>, vl: Vl) -> Option<Self>

Create a new configuration.

Returns None if vl exceeds VLMAX of vtype.

pub const fn from_avl(vtype: Vtype<Hart>, avl: Vl) -> Self

Create a new configuration the way vset{i}vl{i} does for application vector length avl, which is min(AVL, VLMAX).

This satisfies every constraint the specification places on vl, and with no choice left to the implementation, vl is the same on every implementation with the same VLEN.

pub const fn from_raw<Reg>(vtype: Reg::Type, vl: Reg::Type) -> Option<Self>

where Reg: Register,

Decode from raw vtype and vl register values.

Returns None if vtype has vill set or is invalid otherwise, or if vl exceeds VLMAX of vtype. The latter is not a state the architecture can get into, it is treated as vill rather than corrected, so that whatever produced it does not go unnoticed.

pub const fn vtype(self) -> Vtype<Hart>

vtype

pub const fn vl(self) -> BoundedVl<Hart>

vl, which never exceeds Self::vlmax() and hence VLEN

pub const fn vlmax(self) -> Vl

VLMAX of vtype

pub const fn with_vl_at_most(self, vl: Vl) -> Self

The same configuration with vl reduced to vl if it is lower than the current one, which is what fault-only-first loads do

Trait Implementations

impl<Hart> Clone for VectorConfig<Hart>

where Hart: VectorHartConfig + Clone,

fn clone(&self) -> VectorConfig<Hart>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Hart> Copy for VectorConfig<Hart>

where Hart: VectorHartConfig + Copy,

impl<Hart> Debug for VectorConfig<Hart>

where Hart: VectorHartConfig + Debug,

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

Formats the value using the given formatter.

impl<Hart> Eq for VectorConfig<Hart>

where Hart: VectorHartConfig,

impl<Hart> PartialEq for VectorConfig<Hart>

where Hart: VectorHartConfig,

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

Equality operator ==.

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

Inequality operator !=.