Struct cubecl_core::frontend::Comptime

pub struct Comptime<T> { /* private fields */ }

Encapsulates a value to signify it must be used at compilation time rather than in the kernel

Use Comptime<Option<T>> to have an alternate runtime behaviour if the compilation time value is not present

Implementations

impl<T> Comptime<T>

pub fn new(inner: T) -> Self

Create a new Comptime. Useful when hardcoding values in Cube kernels. For instance: if Comptime::new(false) {…} never generates the inner code block

pub fn get(_comptime: Self) -> T

Get the inner value of a Comptime. For instance: let c = Comptime::new(false); if Comptime::get(c) {…}

pub fn map<R, F: Fn(T) -> R>(_comptime: Self, _closure: F) -> Comptime<R>

Executes a closure on the comptime and returns a new comptime containing the value.

pub fn __expand_map<R, F: Fn(T) -> R>(inner: T, closure: F) -> R

impl<T: ComptimeType> Comptime<Option<T>>

pub fn is_some(comptime: Self) -> Comptime<bool>

Map a Comptime optional to a Comptime boolean that tell whether the optional contained a value

pub fn unwrap_or_else<F>(_comptime: Self, _alt: F) -> T

where F: FnOnce() -> T,

Return the inner value of the Comptime if it exists, otherwise tell how to compute it at runtime

pub fn __expand_unwrap_or_else<F>( context: &mut CubeContext, t: Option<T>, alt: F, ) -> <T as CubeType>::ExpandType

where F: FnOnce(&mut CubeContext) -> T::ExpandType,

Expanded version of unwrap_or_else

impl<T: Vectorized> Comptime<T>

pub fn vectorization(_state: &T) -> Comptime<UInt>

pub fn __expand_vectorization(_context: &mut CubeContext, state: T) -> UInt

impl<T: CubePrimitive + Into<ExpandElement>> Comptime<T>

pub fn runtime(_comptime: Self) -> T

pub fn __expand_runtime( _context: &mut CubeContext, inner: T, ) -> ExpandElementTyped<T>

Trait Implementations

impl<T: Add<T, Output = T>> Add for Comptime<T>

type Output = Comptime<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Clone> Clone for Comptime<T>

fn clone(&self) -> Comptime<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Clone + Init> CubeType for Comptime<T>

type ExpandType = T

fn init(context: &mut CubeContext, expand: Self::ExpandType) -> Self::ExpandType

Wrapper around the init method, necessary to type inference.

impl<T: Div<T, Output = T>> Div for Comptime<T>

type Output = Comptime<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl From<Comptime<u32>> for UInt

fn from(value: Comptime<u32>) -> Self

Converts to this type from the input type.

impl<T: Mul<T, Output = T>> Mul for Comptime<T>

type Output = Comptime<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T: PartialOrd + PartialEq> PartialEq for Comptime<T>

fn eq(&self, other: &Self) -> 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<T: PartialOrd + PartialEq> PartialOrd for Comptime<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Rem<T, Output = T>> Rem for Comptime<T>

type Output = Comptime<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<T: Sub<T, Output = T>> Sub for Comptime<T>

type Output = Comptime<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: Copy> Copy for Comptime<T>