Struct GpuBackend 

pub struct GpuBackend<D: GpuDevice> { /* private fields */ }

silvic_core::Backend over any GpuDevice.

Implementations

impl<D: GpuDevice> GpuBackend<D>

pub fn new(device: D) -> Self

Wraps device; kernels compile on GpuBackend::compile or the first load.

pub fn device(&self) -> &D

pub fn compile(&mut self) -> Result<()>

Compiles the kernels for the device, once.

pub fn gradients(&self) -> Result<(Vec<f32>, Vec<f32>)>

The training gradients and hessians of the last compute_gradients, read back for inspection.

Trait Implementations

impl<D: GpuDevice> Backend for GpuBackend<D>

fn partition_and_histogram( &mut self, leaf: LeafRange, split: &BinSplit, side: Side, quantized: bool, out: &mut [f64], ) -> Result<u32>

Partition and the child’s histogram in one command buffer: the histogram kernel takes the child’s rows from the device-side left count, so the host waits once.

fn name(&self) -> String

Human-readable device name for logs (cpu (14 threads), Apple M4 Pro (metal)).

fn load( &mut self, train: &BinnedDataset, valid: &[&BinnedDataset], objective: &ObjectiveSetup, ) -> Result<()>

Takes the training set and validation sets; called once, before anything else.

fn init_scores(&mut self, dataset: usize, value: f64) -> Result<()>

Sets every score of dataset to value.

fn compute_gradients(&mut self) -> Result<GradientStats>

Computes f32 gradients and hessians of the training scores; returns their local maxima.

fn quantize(&mut self, spec: &QuantSpec) -> Result<()>

Quantizes the gradients and hessians with spec (quantize::quantize_row, keyed by global row id).

fn reset_partition(&mut self, bag: &BagSpec) -> Result<u32>

Refills the partition with the bagged training rows in ascending order; returns their count.

fn histogram( &mut self, leaf: LeafRange, quantized: bool, out: &mut [f64], ) -> Result<()>

Histogram of the rows of leaf into out (2 * total_bins, overwritten): quantized units when quantized, else float sums of gradients and hessians.

fn partition(&mut self, leaf: LeafRange, split: &BinSplit) -> Result<u32>

Stable in-place partition of leaf’s rows by split; returns the number of rows going left.

fn leaf_sums( &mut self, leaves: &[LeafRange], grad_scale: f32, hess_scale: f32, ) -> Result<Vec<[i64; 2]>>

Exact fixed-point sums [sum rint(g * scale), sum rint(h * scale)] of each leaf’s float gradients (quantize::to_fixed), for leaf renewal.

fn add_tree(&mut self, tree: &DeviceTree) -> Result<()>

Adds tree to the scores of every dataset, traversing binned rows.

fn scores(&mut self, dataset: usize) -> Result<Vec<f32>>

The current scores of dataset.

fn set_thread_pool(&mut self, pool: Arc<ThreadPool>)

The pool host-side parallel work runs on when num_threads is set; backends without host-side parallelism ignore it. Called before load.

fn set_histogram_features(&mut self, used: &[bool])

Histograms from now on only need the bins of the features with used[feature] (LightGBM is_feature_used: the tree’s feature mask and the parent’s splittable features); the other bins may hold anything. Every rank passes the same mask. Backends may ignore it.