Struct Fp8ActQuant 

pub struct Fp8ActQuant {
    pub shared: KernelHandle,
    pub hopper: KernelHandle,
}

The FP8 activation quantizer a layer will launch: the shared kernel, plus the Hopper twin when this target has one.

Fields

shared: KernelHandle

per_token_group_quant_fp8, present on every target.

hopper: KernelHandle

per_token_group_quant_fp8_hopper, or KernelHandle(0) off Hopper.

Implementations

impl Fp8ActQuant

pub fn resolve(gpu: &dyn GpuBackend) -> Self

Probe both. try_kernel for each: the shared one is optional on targets with no FP8 path at all (the callers already gate on Self::available), and the twin is optional everywhere but Hopper.

pub fn shared_only(shared: KernelHandle) -> Self

A quantizer with only the shared kernel — the state every non-Hopper target resolves to, and the one unit tests construct.

pub fn available(&self) -> bool

Is there a quantizer to launch at all? The replacement for the handle.0 != 0 test every W8A8 selector used to spell inline.

EITHER handle, not Self::pick’s: the pick is width-dependent, and a caller asking “is there an FP8 path on this target” is not asking about one launch’s M.

pub fn twin_present(&self) -> bool

Is the twin in this image? PRESENCE, which is a property of the build — not “will the next launch use it”, which is Fp8QuantPick::twin.

pub fn pick(&self, m: u32, k: u32) -> Fp8QuantPick

Which kernel this (m, k) launches, on which grid, and why not the other one — the process’s resolved lever and the compiled target’s SM count. See Self::pick_with for the pure form.

pub fn pick_with( &self, requested: bool, m: u32, k: u32, sm_count: u32, ) -> Fp8QuantPick

Self::pick over an explicit lever and SM count — pure, so every (M, K) the attribution prices is gradeable from a CPU test.

pub fn kernel(&self, m: u32, k: u32) -> KernelHandle

The handle this (m, k) launches.

pub fn grid(&self, m: u32, k: u32) -> [u32; 3]

The grid for (m, k), matching Self::kernel — from the SAME pick, so a twin handle can never reach the parent’s grid.

Trait Implementations

impl Clone for Fp8ActQuant

fn clone(&self) -> Fp8ActQuant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fp8ActQuant

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

Formats the value using the given formatter.

impl Default for Fp8ActQuant

fn default() -> Self

No quantizer at all — what a target with no FP8 path resolves, and the negative every W8A8 selector is tested against.

impl Copy for Fp8ActQuant