Struct RnsBatch 

pub struct RnsBatch {
    pub data: Vec<u64>,
    pub batch_size: usize,
    pub channels: Channels,
}

A batch of RNS values in a flat, backend-agnostic buffer.

Fields

data: Vec<u64>

Flat row-major residues: length batch_size * channels.len().

batch_size: usize

Number of items B.

channels: Channels

The K channels shared by every item.

Implementations

impl RnsBatch

pub fn new(batch_size: usize, channels: Channels) -> Self

Allocate a zeroed batch (alias of RnsBatch::zeros).

pub fn zeros(batch_size: usize, channels: Channels) -> Self

Allocate a batch with all residues set to zero.

pub fn channels_len(&self) -> usize

Number of channels K.

pub fn get(&self, b: usize, c: usize) -> u64

Residue of item b in channel c.

pub fn set(&mut self, b: usize, c: usize, val: u64)

Set the residue of item b in channel c.

pub fn from_rns_ints(items: &[RnsInt]) -> Self

Pack a slice of RnsInt values into a batch.

Panics if items is empty (no channels to infer) or if the items do not all share the same channels.

Examples found in repository

examples/benchmark_backends.rs (line 41)

fn main() {
    let exec = executor();
    let ch = Channels::standard(32);
    let has_gpu = exec.gpu().is_some();

    println!("== adele-ring :: backend benchmark (32 channels) ==");
    println!(
        "GPU available: {}\n",
        if has_gpu {
            exec.gpu().map(|g| g.adapter_name().to_string()).unwrap_or_default()
        } else {
            "no (CPU-only)".to_string()
        }
    );

    println!("{:>10} | {:>14} | {:>12} | winner", "batch_size", "cpu_rayon_us", "gpu_us");
    println!("{}", "-".repeat(56));

    for &size in &[1usize, 16, 128, 1024, 16_384, 65_536] {
        let a = RnsBatch::from_rns_ints(&vec![RnsInt::from_i64(123, ch.clone()); size]);
        let b = RnsBatch::from_rns_ints(&vec![RnsInt::from_i64(456, ch.clone()); size]);

        let iters = if size <= 128 { 2000 } else { 100 };
        let cpu_us = time_backend(|| exec.cpu().batch_rns_add(&a, &b), iters);

        let (gpu_str, winner) = if let Some(gpu) = exec.gpu() {
            let gpu_us = time_backend(|| gpu.batch_rns_add(&a, &b), iters);
            let w = if cpu_us <= gpu_us { "CPU" } else { "GPU" };
            (format!("{gpu_us:>12.2}"), w)
        } else {
            ("         n/a".to_string(), "CPU")
        };

        println!("{size:>10} | {cpu_us:>14.2} | {gpu_str} | {winner}");
    }

    println!(
        "\nNote: CPU wins for small batches (GPU upload/dispatch overhead ~100us);\n\
         GPU pulls ahead once the batch is large enough to amortize that fixed cost."
    );
}

pub fn to_rns_ints(&self) -> Vec<RnsInt>

Unpack the batch back into individual RnsInt values.

pub fn as_u32_bytes(&self) -> Vec<u8>

Pack for GPU upload: residues as little-endian u32 bytes.

Moduli are chosen <= 2^31 so every residue fits in a u32. The cast to bytes is zero-copy via bytemuck.

pub fn from_u32(values: &[u32], batch_size: usize, channels: Channels) -> Self

Rebuild a batch from a flat u32 slice downloaded from the GPU.

Trait Implementations

impl Clone for RnsBatch

fn clone(&self) -> RnsBatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RnsBatch

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

Formats the value using the given formatter.