Struct Cycles 

pub struct Cycles(/* private fields */);

Time, as multiples of one simple ALU operation.

Fixed point with two decimal places, per Cycles::SCALE. Integers are not enough: an lea on x86-64 costs less than an add on some microarchitectures and more on others, and a table that can only say one or two has to round the answer before any pass has seen it. Floating point would do, and is not used, because two compilers built from the same source must make the same decisions and a cost that is compared for equality is a cost that has to be exact.

Infinity

Cycles::INFINITE means the thing is not possible, which is a different statement from very expensive and is the same type so that the comparison operators work on both. Section 40.2 takes this from GCC’s infinite_cost in gcc/tree-ssa-loop-ivopts.cc, and the reason to have it once rather than in each pass is that i64::MAX / 2 written in eight places is eight chances to overflow it.

Arithmetic saturates at infinity rather than wrapping. Section 40.13 asks that the saturating case be visible rather than silent, and crate::Cost is where that is recorded, because a saturation matters when it decides something and a bare Cycles has not decided anything yet.

Implementations

impl Cycles

pub const SCALE: i64 = 100

How many units one simple ALU operation is worth, which fixes where the point sits.

A hundred, so that a table can be read and written in the units people quote latencies in. GCC’s COSTS_N_INSNS uses four, which buys quarter granularity and makes every number in every target file a multiple of four that has to be divided in your head.

pub const ZERO: Self

Free. Not the same as Cycles::ONE on a machine that issues several operations a cycle, and not the same as unknown either.

pub const ONE: Self

One simple ALU operation, the unit everything else is quoted against.

pub const INFINITE: Self

This is not possible. Saturating, and larger than every finite cost.

pub const fn insns(n: i64) -> Self

A whole number of simple operations.

pub const fn hundredths(n: i64) -> Self

A number of hundredths, for a table entry that is not a whole number of operations.

pub const fn is_infinite(self) -> bool

Whether this is Cycles::INFINITE, meaning impossible rather than expensive.

Worth asking before printing a cost and before dividing by one, and worth not asking anywhere else, since the ordering already puts it above everything finite.

pub const fn raw(self) -> i64

The raw hundredths, for a report that wants to do its own arithmetic.

Trait Implementations

impl Add for Cycles

type Output = Cycles

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl AddAssign for Cycles

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl Capability for Cycles

fn impossible(&self) -> Vec<bool>

One entry per costed lane, saying whether that lane is impossible.

impl Clone for Cycles

fn clone(&self) -> Cycles

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Cycles

impl Debug for Cycles

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

Formats the value using the given formatter.

impl Default for Cycles

fn default() -> Cycles

Returns the “default value” for a type.

impl Display for Cycles

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

Formats the value using the given formatter.

impl Div<i64> for Cycles

fn div(self, by: i64) -> Self

Dividing infinity leaves infinity, and dividing by zero is a bug rather than an infinity.

A pass that divides a cost by a count it did not check is a pass with an empty set it thought was non-empty, and turning that into a very large number would hide it until the number came out of a heuristic somewhere else.

type Output = Cycles

The resulting type after applying the / operator.

impl Eq for Cycles

impl Hash for Cycles

fn hash<__H: Hasher>(&self, state: &mut __H)

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 Mul<i64> for Cycles

type Output = Cycles

The resulting type after applying the * operator.

fn mul(self, by: i64) -> Self

Performs the * operation.

impl Ord for Cycles

fn cmp(&self, other: &Cycles) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Cycles

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Cycles

fn partial_cmp(&self, other: &Cycles) -> 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 StructuralPartialEq for Cycles

impl Sub for Cycles

fn sub(self, other: Self) -> Self

Saturating below at zero as well as above at infinity.

A negative cost is not a thing any pass here means. Every subtraction in the documents is a saving, of the form what it cost before minus what it costs now, and a saving that came out negative is a transformation that did not pay, which zero says as well as minus three does and without the risk that something later multiplies by it.

type Output = Cycles

The resulting type after applying the - operator.