Struct melior::dialect::ods::async::ExecuteOperation

pub struct ExecuteOperation<'c> { /* private fields */ }

An execute operation. Asynchronous execute operation.

The body region attached to the async.execute operation semantically can be executed concurrently with the successor operation. In the followup example “compute0” can be executed concurrently with “compute1”.

The actual concurrency semantics depends on the dialect lowering to the executable format. Fully sequential execution (“compute0” completes before “compute1” starts) is a completely legal execution.

Because concurrent execution is not guaranteed, it is illegal to create an implicit dependency from “compute1” to “compute0” (e.g. via shared global state). All dependencies must be made explicit with async execute arguments (async.token or async.value).

async.execute operation takes async.token dependencies and async.value operands separately, and starts execution of the attached body region only when all tokens and values become ready.

Example:

%dependency = ... : !async.token
%value = ... : !async.value<f32>

%token, %results =
  async.execute [%dependency](%value as %unwrapped: !async.value<f32>)
             -> !async.value<!some.type>
  {
    %0 = "compute0"(%unwrapped): (f32) -> !some.type
    async.yield %0 : !some.type
  }

%1 = "compute1"(...) : !some.type

In the example above asynchronous execution starts only after dependency token and value argument become ready. Unwrapped value passed to the attached body region as an %unwrapped value of f32 type.

Implementations

impl<'c> ExecuteOperation<'c>

pub fn name() -> &'static str

Returns a name.

pub fn as_operation(&self) -> &Operation<'c>

Returns a generic operation.

pub fn builder( context: &'c Context, location: Location<'c> ) -> ExecuteOperationBuilder<'c, Unset, Unset, Unset, Unset, Unset>

Creates a builder.

pub fn token(&self) -> Result<OperationResult<'c, '_>, Error>

pub fn body_results(&self) -> impl Iterator<Item = OperationResult<'c, '_>>

pub fn dependencies(&self) -> Result<impl Iterator<Item = Value<'c, '_>>, Error>

pub fn body_operands( &self ) -> Result<impl Iterator<Item = Value<'c, '_>>, Error>

pub fn body_region(&self) -> Result<RegionRef<'c, '_>, Error>

Trait Implementations

impl<'c> From<ExecuteOperation<'c>> for Operation<'c>

fn from(operation: ExecuteOperation<'c>) -> Self

Converts to this type from the input type.

impl<'c> TryFrom<Operation<'c>> for ExecuteOperation<'c>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(operation: Operation<'c>) -> Result<Self, Self::Error>

Performs the conversion.