Struct BackendDispatcher 

pub struct BackendDispatcher { /* private fields */ }

Cost-based backend selection

References:

• Gregg & Hazelwood (2011): PCIe bus bottleneck analysis
• Breß et al. (2014): Operator variant selection on heterogeneous hardware

Implementations

impl BackendDispatcher

pub fn select(total_bytes: usize, estimated_flops: f64) -> Backend

Select backend based on arithmetic intensity (FLOPs/Byte)

Arguments

• total_bytes - Total data size in bytes
• estimated_flops - Estimated floating point operations

Returns

Backend selection (GPU, SIMD, or Scalar)

Algorithm

1. Check minimum data size threshold (10 MB)
2. Calculate PCIe transfer time: bytes / 32 GB/s
3. Estimate GPU compute time: FLOPs / 100 GFLOP/s
4. Apply 5x rule: GPU only if compute > 5x transfer

pub const fn arithmetic_intensity(total_flops: f64, total_bytes: usize) -> f64

Calculate arithmetic intensity (FLOPs per byte)

Higher arithmetic intensity means more compute per data transfer, making GPU acceleration more beneficial.

Arguments

• total_flops - Total floating point operations
• total_bytes - Total data size in bytes

Returns

Arithmetic intensity ratio (FLOPs/Byte)

Example

use trueno_db::backend::BackendDispatcher;

// Matrix multiply: N^3 FLOPs for N^2 elements = N FLOPs/element
let intensity = BackendDispatcher::arithmetic_intensity(1_000_000_000.0, 100_000_000);
assert_eq!(intensity, 10.0); // 10 FLOPs per byte

pub const fn estimate_simple_aggregation_flops(num_elements: usize) -> f64

Estimate FLOPs for simple aggregation (SUM, AVG, COUNT, MIN, MAX)

Simple aggregations perform ~1 FLOP per element (single pass)

Arguments

• num_elements - Number of elements to aggregate

Returns

Estimated FLOPs

Example

use trueno_db::backend::BackendDispatcher;

// SUM over 100M elements = 100M FLOPs
let flops = BackendDispatcher::estimate_simple_aggregation_flops(100_000_000);
assert_eq!(flops, 100_000_000.0);

pub const fn estimate_group_by_flops(num_elements: usize) -> f64

Estimate FLOPs for GROUP BY aggregation

GROUP BY requires hashing (5 FLOPs/element) + aggregation (1 FLOP/element)

Arguments

• num_elements - Number of elements to process

Returns

Estimated FLOPs

Example

use trueno_db::backend::BackendDispatcher;

// GROUP BY over 100M elements = 600M FLOPs
let flops = BackendDispatcher::estimate_group_by_flops(100_000_000);
assert_eq!(flops, 600_000_000.0);

pub const fn estimate_filter_flops(num_elements: usize) -> f64

Estimate FLOPs for WHERE filter

Filters require predicate evaluation (~2 FLOPs per element)

Arguments

• num_elements - Number of elements to filter

Returns

Estimated FLOPs

pub const fn estimate_join_flops(left_size: usize, right_size: usize) -> f64

Estimate FLOPs for JOIN operation

Hash join: Build hash table (5 FLOPs/elem) + Probe (5 FLOPs/elem)

Arguments

• left_size - Number of elements in left table
• right_size - Number of elements in right table

Returns

Estimated FLOPs