Struct DirectiveBuilder

pub struct DirectiveBuilder { /* private fields */ }

Builder for constructing DirectiveIR with a fluent API

Implementations

impl<'a> DirectiveBuilder

pub fn parallel() -> Self

Create a new builder for a parallel directive

Example

use roup::ir::{DirectiveBuilder, Language, SourceLocation};

let directive = DirectiveBuilder::parallel()
    .default_shared()
    .build(SourceLocation::start(), Language::C);

assert!(directive.kind().is_parallel());

pub fn parallel_for() -> Self

Create a new builder for a parallel for directive

pub fn for_loop() -> Self

Create a new builder for a for directive

pub fn task() -> Self

Create a new builder for a task directive

pub fn target() -> Self

Create a new builder for a target directive

pub fn teams() -> Self

Create a new builder for a teams directive

pub fn new(kind: DirectiveKind) -> Self

Create a new builder for any directive kind

pub fn default_shared(self) -> Self

Add a default(shared) clause

pub fn default_none(self) -> Self

Add a default(none) clause

pub fn default(self, kind: DefaultKind) -> Self

Add a default clause with specified kind

pub fn private(self, vars: &[&'a str]) -> Self

Add a private clause

Example

use roup::ir::{DirectiveBuilder, Language, SourceLocation};

let directive = DirectiveBuilder::parallel()
    .private(&["x", "y", "z"])
    .build(SourceLocation::start(), Language::C);

pub fn firstprivate(self, vars: &[&'a str]) -> Self

Add a firstprivate clause

pub fn shared(self, vars: &[&'a str]) -> Self

Add a shared clause

pub fn reduction(self, operator: ReductionOperator, vars: &[&'a str]) -> Self

Add a reduction clause

Example

use roup::ir::{DirectiveBuilder, ReductionOperator, Language, SourceLocation};

let directive = DirectiveBuilder::parallel()
    .reduction(ReductionOperator::Add, &["sum"])
    .build(SourceLocation::start(), Language::C);

pub fn num_threads(self, num: i32) -> Self

Add a num_threads clause

Note: This creates an unparsed expression. For better control, use num_threads_expr() with a static string.

pub fn num_threads_expr(self, expr: &'a str) -> Self

Add a num_threads clause with expression

pub fn if_clause(self, condition: &'a str) -> Self

Add an if clause

pub fn schedule_simple(self, kind: ScheduleKind) -> Self

Add a schedule clause

Example

use roup::ir::{DirectiveBuilder, ScheduleKind, Language, SourceLocation};

let directive = DirectiveBuilder::for_loop()
    .schedule_simple(ScheduleKind::Static)
    .build(SourceLocation::start(), Language::C);

pub fn schedule(self, kind: ScheduleKind, chunk_size: Option<&'a str>) -> Self

Add a schedule clause with chunk size expression

pub fn schedule_with_modifiers( self, kind: ScheduleKind, modifiers: Vec<ScheduleModifier>, chunk_size: Option<&'a str>, ) -> Self

Add a schedule clause with modifiers

pub fn collapse(self, n: &'a str) -> Self

Add a collapse clause with expression

pub fn ordered(self) -> Self

Add an ordered clause

pub fn ordered_n(self, n: &'a str) -> Self

Add an ordered clause with parameter

pub fn nowait(self) -> Self

Add a nowait clause

pub fn map(self, map_type: MapType, vars: &[&'a str]) -> Self

Add a map clause

pub fn depend(self, depend_type: DependType, vars: &[&'a str]) -> Self

Add a depend clause

pub fn proc_bind(self, kind: ProcBind) -> Self

Add a proc_bind clause

pub fn build(self, location: SourceLocation, language: Language) -> DirectiveIR

Build the DirectiveIR

Example

use roup::ir::{DirectiveBuilder, Language, SourceLocation};

let directive = DirectiveBuilder::parallel()
    .default_shared()
    .private(&["x"])
    .build(SourceLocation::start(), Language::C);

assert_eq!(directive.clauses().len(), 2);