Enum BufferIOAttr 

pub enum BufferIOAttr {
    ReadOnly,
    WriteOnly,
    ReadWrite,
    Dead,
}

What a compiled kernel does with each buffer binding, by buffer position.

The IR owns this concept — the visibility analysis stamps it on the entry function’s arguments — so the launch path reads that enum rather than a copy of it that could drift. Re-exported here because a backend reaching for it is holding a CompiledKernel (in cubecl-server), not an IR context. What a compiled kernel does with one buffer binding, stamped on the entry function’s arguments by the visibility analysis and carried to the launch site, where the write scope stages exactly what the kernel writes and checks exactly what it reads.

Four states because the launch path asks two independent questions. Writable decides what a failure taints; readable decides what is checked before launching. An aliased or accumulating argument answers yes to both, a pure output answers only the first — which is what lets a relaunch repair a tainted buffer — and a buffer the kernel never touches answers neither.

Variants

ReadOnly

Read, never written: checked before launch, never claimed by a failure.

WriteOnly

Written, never read: claimed by a failure, never checked.

ReadWrite

Both — the aliased and accumulator cases included.

Dead

Neither: no check on the way in, no claim on the way out.

Implementations

impl BufferIOAttr

pub fn new_read_only() -> BufferIOAttr

Constructs a new BufferIOAttr::ReadOnly.

impl BufferIOAttr

pub fn new_write_only() -> BufferIOAttr

Constructs a new BufferIOAttr::WriteOnly.

impl BufferIOAttr

pub fn new_read_write() -> BufferIOAttr

Constructs a new BufferIOAttr::ReadWrite.

impl BufferIOAttr

pub fn new_dead() -> BufferIOAttr

Constructs a new BufferIOAttr::Dead.

impl BufferIOAttr

pub fn is_readable(&self) -> bool

Whether the kernel reads the buffer, so its contents have to be trustworthy before the launch runs.

pub fn is_writable(&self) -> bool

Whether the kernel writes the buffer, so a failed launch leaves it carrying the failure.

pub fn is_dead(&self) -> bool

Whether the kernel never touches the buffer at all.

Trait Implementations

impl Attribute for BufferIOAttr

fn hash_attr(&self) -> TypeValueHash

Compute and get the hash for this instance of Self. Hash collisions can be a possibility.

fn eq_attr(&self, other: &(dyn Attribute + 'static)) -> bool

Is self equal to an other Attribute?

fn get_attr_id(&self) -> AttrId

Get an Attribute’s static name. This is not per instantnce. It is mostly useful for printing and parsing the attribute.

fn get_attr_id_static() -> AttrId

Same as get_attr_id, but without the self reference.

fn register<A>(ctx: &mut Context)

where A: Attribute, Self: Sized + Parsable<Arg = (), Parsed = A>,

Register this attribute’s AttrId in the dialect it belongs to.

impl Clone for BufferIOAttr

fn clone(&self) -> BufferIOAttr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BufferIOAttr

impl Debug for BufferIOAttr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BufferIOAttr

fn deserialize<__D>( __deserializer: __D, ) -> Result<BufferIOAttr, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for BufferIOAttr

impl Hash for BufferIOAttr

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 Parsable for BufferIOAttr

type Arg = ()

Type of the argument that must be passed to the parser.

type Parsed = BufferIOAttr

The type of the parsed entity.

fn parse<'__pliron_parse>( state_stream: &mut Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'__pliron_parse>>, SourcePosition>>>, State<'__pliron_parse>>, arg: <BufferIOAttr as Parsable>::Arg, ) -> Result<(<BufferIOAttr as Parsable>::Parsed, Commit<()>), Commit<Tracked<<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'__pliron_parse>>, SourcePosition>>>, State<'__pliron_parse>> as StreamOnce>::Error>>>

Define a parser using existing combinators and call into on Parser::parse_stream to get the final ParseResult. Use state_stream.state as necessary.

fn parser<'a>( arg: Self::Arg, ) -> Box<dyn Parser<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, PartialState = (), Output = Self::Parsed> + 'a>

where Self::Parsed: 'a,

Get a parser combinator that can work on StateStream as its input.

impl PartialEq for BufferIOAttr

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

Equality operator ==.

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

Inequality operator !=.

impl Printable for BufferIOAttr

fn fmt( &self, ctx: &Context, state: &State, fmt: &mut Formatter<'_>, ) -> Result<(), Error>

fn disp<'t, 'c>(&'t self, ctx: &'c Context) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and default State.

fn print<'t, 'c>( &'t self, ctx: &'c Context, state: &State, ) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and State.

impl Serialize for BufferIOAttr

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for BufferIOAttr

impl Verify for BufferIOAttr

fn verify(&self, _ctx: &Context) -> Result<(), Error>