use super::*;
#[test]
fn test_total_memory_region_contiguous() {
let dims = [100usize];
let strides = [8u128]; let byte_strides: Vec<&[u128]> = vec![&strides];
let region = total_memory_region(&dims, &byte_strides);
assert_eq!(region, 832);
}
#[test]
fn test_total_memory_region_strided() {
let dims = [10usize];
let strides = [128u128]; let byte_strides: Vec<&[u128]> = vec![&strides];
let region = total_memory_region(&dims, &byte_strides);
assert_eq!(region, 640);
}
#[test]
fn test_compute_blocks_small() {
let dims = [10usize, 10];
let costs = [2isize, 2];
let strides = [8u128, 80];
let orders = [1usize, 2];
let byte_strides: Vec<&[u128]> = vec![&strides];
let stride_orders: Vec<&[usize]> = vec![&orders];
let blocks = compute_blocks(
&dims,
&costs,
&byte_strides,
&stride_orders,
BLOCK_MEMORY_SIZE,
);
assert_eq!(blocks.as_slice(), vec![10, 10]);
}
#[test]
fn test_compute_blocks_large() {
let dims = [1000usize, 1000];
let costs = [2isize, 2];
let strides = [8u128, 8000]; let orders = [1usize, 2];
let byte_strides: Vec<&[u128]> = vec![&strides];
let stride_orders: Vec<&[usize]> = vec![&orders];
let blocks = compute_blocks(
&dims,
&costs,
&byte_strides,
&stride_orders,
BLOCK_MEMORY_SIZE,
);
assert!(blocks[0] <= dims[0]);
assert!(blocks[1] <= dims[1]);
assert!(blocks[0] >= 1);
assert!(blocks[1] >= 1);
}
#[test]
fn test_last_argmax_weighted() {
let blocks = [10usize, 20, 5];
let costs = [1isize, 1, 2];
let idx = last_argmax_weighted(&blocks, &costs);
assert_eq!(idx, Some(1));
}
#[test]
fn test_last_argmax_weighted_tie() {
let blocks = [10usize, 10];
let costs = [1isize, 1];
let idx = last_argmax_weighted(&blocks, &costs);
assert_eq!(idx, Some(1));
}
#[test]
fn test_compute_block_sizes_full_pipeline() {
let dims = [100usize, 100];
let strides = [1isize, 100];
let strides_list: Vec<&[isize]> = vec![&strides];
let blocks = compute_block_sizes(&dims, &strides_list, 8);
assert_eq!(blocks.len(), 2);
assert!(blocks[0] >= 1 && blocks[0] <= 100);
assert!(blocks[1] >= 1 && blocks[1] <= 100);
}
#[test]
fn test_total_memory_region_julia_match_2d() {
let dims = [10usize, 10];
let strides = [8u128, 80];
let byte_strides: Vec<&[u128]> = vec![&strides];
let region = total_memory_region(&dims, &byte_strides);
assert_eq!(region, 1280);
}
#[test]
fn test_total_memory_region_julia_match_multiple_arrays() {
let dims = [10usize, 10];
let strides1 = [8u128, 80]; let strides2 = [80u128, 8]; let byte_strides: Vec<&[u128]> = vec![&strides1, &strides2];
let region = total_memory_region(&dims, &byte_strides);
assert_eq!(region, 2560);
}
#[test]
fn test_total_memory_region_all_contiguous() {
let dims = [10usize, 5];
let strides = [8u128, 40]; let byte_strides: Vec<&[u128]> = vec![&strides];
let region = total_memory_region(&dims, &byte_strides);
assert_eq!(region, 256);
}
#[test]
fn test_total_memory_region_all_large_strides() {
let dims = [5usize, 4];
let strides = [64u128, 320]; let byte_strides: Vec<&[u128]> = vec![&strides];
let region = total_memory_region(&dims, &byte_strides);
assert_eq!(region, 1280);
}
#[test]
fn test_compute_blocks_first_dim_smallest_stride() {
let dims = [100usize, 10, 10];
let costs = [2isize, 2, 2];
let strides1 = [8u128, 800, 8000];
let orders1 = [1usize, 2, 3]; let byte_strides: Vec<&[u128]> = vec![&strides1];
let stride_orders: Vec<&[usize]> = vec![&orders1];
let blocks = compute_blocks(
&dims,
&costs,
&byte_strides,
&stride_orders,
BLOCK_MEMORY_SIZE,
);
assert_eq!(blocks[0], 100);
}
#[test]
fn test_compute_blocks_min_stride_larger_than_blocksize() {
let dims = [100usize, 100];
let costs = [2isize, 2];
let strides = [40000000u128, 40000]; let orders = [2usize, 1]; let byte_strides: Vec<&[u128]> = vec![&strides];
let stride_orders: Vec<&[usize]> = vec![&orders];
let initial_mem = total_memory_region(&dims, &byte_strides);
assert!(
initial_mem > BLOCK_MEMORY_SIZE as u128,
"Initial memory {} should exceed {}",
initial_mem,
BLOCK_MEMORY_SIZE
);
let min_stride = strides.iter().copied().min().unwrap();
assert!(
min_stride > BLOCK_MEMORY_SIZE as u128,
"Min stride {} should exceed {}",
min_stride,
BLOCK_MEMORY_SIZE
);
let blocks = compute_blocks(
&dims,
&costs,
&byte_strides,
&stride_orders,
BLOCK_MEMORY_SIZE,
);
assert_eq!(blocks.as_slice(), vec![1, 1]);
}
#[test]
fn test_compute_blocks_4d_array_first_dim_smallest() {
let dims = [10usize, 10, 10, 10];
let costs = [2isize, 2, 2, 2];
let strides = [8u128, 80, 800, 8000];
let orders = [1usize, 2, 3, 4];
let byte_strides: Vec<&[u128]> = vec![&strides];
let stride_orders: Vec<&[usize]> = vec![&orders];
let blocks = compute_blocks(
&dims,
&costs,
&byte_strides,
&stride_orders,
BLOCK_MEMORY_SIZE,
);
assert_eq!(blocks.len(), 4);
for (i, &b) in blocks.iter().enumerate() {
assert!(b >= 1 && b <= dims[i], "Block {} out of range", i);
}
}
#[test]
fn test_compute_blocks_4d_needs_reduction() {
let dims = [100usize, 100, 100, 100];
let costs = [2isize, 2, 2, 2];
let strides = [80u128, 8, 8000, 800];
let orders = [2usize, 1, 4, 3]; let byte_strides: Vec<&[u128]> = vec![&strides];
let stride_orders: Vec<&[usize]> = vec![&orders];
let initial_mem = total_memory_region(&dims, &byte_strides);
assert!(initial_mem > BLOCK_MEMORY_SIZE as u128);
let blocks = compute_blocks(
&dims,
&costs,
&byte_strides,
&stride_orders,
BLOCK_MEMORY_SIZE,
);
assert_eq!(blocks.len(), 4);
let total_elements: usize = blocks.iter().product();
let original_elements: usize = dims.iter().product();
assert!(
total_elements < original_elements,
"Blocks should be smaller than original"
);
}
#[test]
fn test_compute_blocks_4d_permuted() {
let dims = [10usize, 10, 10, 10];
let costs = [2isize, 4, 8, 16]; let strides = [8000u128, 800, 80, 8];
let orders = [4usize, 3, 2, 1];
let byte_strides: Vec<&[u128]> = vec![&strides];
let stride_orders: Vec<&[usize]> = vec![&orders];
let blocks = compute_blocks(
&dims,
&costs,
&byte_strides,
&stride_orders,
BLOCK_MEMORY_SIZE,
);
assert_eq!(blocks.len(), 4);
for (i, &b) in blocks.iter().enumerate() {
assert!(b >= 1 && b <= dims[i]);
}
}
#[test]
fn test_compute_blocks_mixed_strides_two_arrays() {
let dims = [100usize, 100];
let costs = [2isize, 2];
let strides1 = [8u128, 800]; let strides2 = [800u128, 8]; let orders1 = [1usize, 2];
let orders2 = [2usize, 1];
let byte_strides: Vec<&[u128]> = vec![&strides1, &strides2];
let stride_orders: Vec<&[usize]> = vec![&orders1, &orders2];
let blocks = compute_blocks(
&dims,
&costs,
&byte_strides,
&stride_orders,
BLOCK_MEMORY_SIZE,
);
assert_eq!(blocks.len(), 2);
assert!(blocks[0] >= 1 && blocks[0] <= 100);
assert!(blocks[1] >= 1 && blocks[1] <= 100);
}
#[test]
fn test_last_argmax_weighted_all_ones() {
let blocks = [1usize, 1, 1];
let costs = [1isize, 2, 3];
let idx = last_argmax_weighted(&blocks, &costs);
assert_eq!(idx, None);
}
#[test]
fn test_last_argmax_weighted_mixed() {
let blocks = [1usize, 5, 3];
let costs = [100isize, 1, 1];
let idx = last_argmax_weighted(&blocks, &costs);
assert_eq!(idx, Some(1));
}
#[test]
fn test_last_argmax_weighted_cost_matters() {
let blocks = [3usize, 10];
let costs = [10isize, 1];
let idx = last_argmax_weighted(&blocks, &costs);
assert_eq!(idx, Some(0));
}
#[test]
fn test_compute_blocks_negative_strides() {
let dims = [100usize, 100];
let positive = compute_block_sizes(&dims, &[&[1, 100], &[100, 1]], 8);
let negative = compute_block_sizes(&dims, &[&[-1, -100], &[-100, 1]], 8);
assert_eq!(negative, positive);
}
#[test]
fn test_compute_block_sizes_4d_column_major() {
let dims = [32usize, 32, 32, 32];
let strides = [1isize, 32, 1024, 32768]; let strides_list: Vec<&[isize]> = vec![&strides];
let blocks = compute_block_sizes(&dims, &strides_list, 8);
assert_eq!(blocks.len(), 4);
for (i, &b) in blocks.iter().enumerate() {
assert!(b >= 1 && b <= dims[i], "Block {} = {} out of range", i, b);
}
}
#[test]
fn test_compute_block_sizes_4d_permuted_strides() {
let dims = [32usize, 32, 32, 32];
let strides = [1isize, 32, 1024, 32768];
let strides_list: Vec<&[isize]> = vec![&strides];
let blocks = compute_block_sizes(&dims, &strides_list, 8);
assert_eq!(blocks.as_slice(), [32, 32, 32, 32]);
}
#[path = "oracle.rs"]
mod oracle;
use crate::kernel::{build_plan, build_plan_fused};
use oracle::{legacy_blocks, model_blocks, LegacyCosts};
fn refs(strides: &[Vec<isize>]) -> Vec<&[isize]> {
strides.iter().map(|s| s.as_slice()).collect()
}
#[test]
fn compute_block_sizes_equals_the_exact_model_on_the_sweep() {
let (mut fits, mut overflows) = (0, 0);
for (dims, strides, elem_size) in oracle::sweep() {
let strides = refs(&strides);
let model = model_blocks(&dims, &strides, elem_size);
let blocks = compute_block_sizes(&dims, &strides, elem_size);
assert_eq!(
blocks.as_slice(),
model,
"{dims:?} {strides:?} e={elem_size}"
);
if elem_size == 0 {
assert_eq!(model, dims, "a zero element size keeps every axis");
}
match legacy_blocks(&dims, &strides, elem_size, LegacyCosts::Saturating) {
Some(legacy) => {
assert_eq!(legacy, model, "{dims:?} {strides:?} e={elem_size}");
fits += 1;
}
None => overflows += 1,
}
}
assert!(
fits > 0 && overflows > 0,
"{fits} fitting, {overflows} overflowing"
);
assert!(compute_block_sizes(&[], &[&[]], usize::MAX).is_empty());
assert_eq!(
legacy_blocks(&[], &[&[]], usize::MAX, LegacyCosts::Saturating),
Some(vec![])
);
}
#[test]
fn a_zip_reduce_region_beyond_usize_is_exact() {
let dims = [1024usize; 6];
let a = [8isize, 16, 8, 8, 8, 8];
let b = [16isize, 8, 8, 8, 8, 8];
let (dims, strides, plan) = build_plan_fused(&dims, &[&a, &b], None, 8);
assert_eq!(dims.as_slice(), [1024; 6]);
assert_eq!(strides[0].as_slice(), [8, 8, 8, 8, 8, 16]);
assert_eq!(strides[1].as_slice(), [8, 8, 8, 8, 16, 8]);
assert_eq!(plan.block.as_slice(), [1024, 1024, 1024, 1024, 16, 16]);
let strides: Vec<&[isize]> = strides.iter().map(|s| s.as_slice()).collect();
assert_eq!(model_blocks(&dims, &strides, 8), plan.block.as_slice());
assert_eq!(
legacy_blocks(&dims, &strides, 8, LegacyCosts::Saturating),
None
);
}
#[derive(Clone, Copy, Debug, Default, PartialEq)]
struct Zst;
impl crate::ElementOpApply for Zst {}
static ZSTS: [Zst; 1 << 62] = [Zst; 1 << 62];
#[test]
fn a_zero_sized_source_byte_stride_beyond_isize_is_exact() {
let dims = [2usize, 8192];
let dst_strides = [1isize, 2];
let src_strides = [1isize << 61, 1];
let (_, _, plan) = build_plan_fused(&dims, &[&dst_strides, &src_strides], Some(0), 8);
assert_eq!(plan.block.as_slice(), [2, 1024]);
assert_eq!(
legacy_blocks(
&dims,
&[&dst_strides, &src_strides],
8,
LegacyCosts::Saturating
),
None
);
let src = crate::StridedView::<Zst>::new(&ZSTS[..], &dims, &src_strides, 0).unwrap();
let mut data = vec![0.0f64; 2 * 8192];
let mut dst = crate::StridedViewMut::new(&mut data, &dims, &dst_strides, 0).unwrap();
crate::map_into(&mut dst, &src, |_: Zst| 1.5f64, crate::Exec::serial()).unwrap();
assert!(data.iter().all(|&x| x == 1.5));
}
#[test]
fn a_zero_element_size_keeps_every_axis_for_any_operand_count() {
let dims = [2usize, 2];
let mut strides = vec![vec![1isize, 2]; 512];
strides.push(vec![2, 1]);
let strides = refs(&strides);
assert_eq!(compute_block_sizes(&dims, &strides, 0).as_slice(), [2, 2]);
assert_eq!(model_blocks(&dims, &strides, 0), [2, 2]);
assert_eq!(
legacy_blocks(&dims, &strides, 0, LegacyCosts::Saturating),
Some(vec![2, 2])
);
let orders: Vec<InlineVec<usize>> = strides.iter().map(|s| index_order(s)).collect();
let orders: Vec<&[usize]> = orders.iter().map(|o| o.as_slice()).collect();
let zeros = [0u128; 2];
let byte_strides = vec![&zeros[..]; 513];
let costs = compute_costs(&strides);
assert_eq!(
compute_blocks(&dims, &costs, &byte_strides, &orders, BLOCK_MEMORY_SIZE).as_slice(),
[1, 1]
);
}
#[test]
fn a_halving_score_beyond_isize_selects_the_exact_maximum() {
let dims = [3usize, 8192];
let a = [1isize << 61, 1];
let b = [1isize << 61, 2];
assert_eq!(compute_costs(&[&a, &b]).as_slice(), [1 << 62, 2]);
assert_eq!(
compute_block_sizes(&dims, &[&a, &b], 1).as_slice(),
[1, 8192]
);
assert_eq!(model_blocks(&dims, &[&a, &b], 1), [1, 8192]);
assert_eq!(
legacy_blocks(&dims, &[&a, &b], 1, LegacyCosts::Saturating),
None
);
}
#[test]
fn tied_strides_run_the_full_core() {
let dims = [64usize, 64, 64];
let dst = [1isize, 64, 4096];
for src in [[0isize, 1, 1], [1, 1, 1]] {
assert_eq!(
compute_block_sizes(&dims, &[&dst, &src], 8).as_slice(),
[64, 31, 16]
);
assert_eq!(model_blocks(&dims, &[&dst, &src], 8), [64, 31, 16]);
}
}
#[test]
fn strictly_increasing_strides_keep_every_axis_in_the_model() {
let cases: [(&[usize], [isize; 2], [isize; 2]); 2] = [
(&[3840, 4096], [1, 3840], [1, 4096]),
(&[4096, 4096], [1, 4096], [-1, 4096]),
];
for (dims, dst, src) in cases {
assert_eq!(model_blocks(dims, &[&dst, &src], 8), dims);
assert_eq!(compute_block_sizes(dims, &[&dst, &src], 8).as_slice(), dims);
}
}
#[test]
fn build_plan_forwards_ordered_dims_and_strides() {
let plan = build_plan(&[3, 5], &[&[5, 1]], Some(0), 8);
assert_eq!(plan.order.as_slice(), [1, 0]);
assert_eq!(plan.block.as_slice(), [5, 3]);
let plan = build_plan(&[3, 1000], &[&[1000, 1]], Some(0), 8);
assert_eq!(plan.order.as_slice(), [1, 0]);
assert_eq!(plan.block.as_slice(), [1000, 3]);
}