use super::*;
use crate::fuse::compute_costs;
use strided_view::auxiliary::index_order;
#[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, 8]);
let negative = compute_block_sizes(&dims, &[&[-1, -100], &[-100, 1]], &[8, 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 num_complex::Complex64 as C64;
use oracle::{legacy_blocks, model_blocks, model_blocks_sized, 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, &vec![elem_size; strides.len()]);
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![])
);
}
fn sweep_elem_sizes(operands: usize, case: usize, seed: usize) -> Vec<usize> {
const SIZES: [usize; 6] = [0, 1, 2, 4, 8, 16];
(0..operands)
.map(|k| SIZES[(case + 2 * k + seed) % SIZES.len()])
.collect()
}
#[test]
fn compute_block_sizes_equals_the_exact_model_per_operand_on_the_sweep() {
let mut mixed = 0;
for (case, (dims, strides, seed)) in oracle::sweep().into_iter().enumerate() {
let strides = refs(&strides);
let elem_sizes = sweep_elem_sizes(strides.len(), case, seed);
let model = model_blocks_sized(&dims, &strides, &elem_sizes);
let blocks = compute_block_sizes(&dims, &strides, &elem_sizes);
assert_eq!(
blocks.as_slice(),
model,
"{dims:?} {strides:?} e={elem_sizes:?}"
);
if elem_sizes.iter().any(|&e| e != elem_sizes[0]) {
mixed += 1;
}
}
assert!(mixed > 0, "{mixed} mixed-size cases");
}
#[test]
fn a_mixed_size_pair_blocks_at_each_operands_own_footprint() {
let dims = [128usize, 128];
let dst = [1isize, 128];
let src = [128, 1];
let strides: [&[isize]; 2] = [&dst, &src];
let cases: [(usize, usize, [usize; 2], [usize; 2]); 2] =
[(8, 1, [57, 56], [64, 32]), (16, 8, [40, 32], [32, 32])];
for (dst_size, src_size, blocks, old_blocks) in cases {
let elem_sizes = [dst_size, src_size];
let model = model_blocks_sized(&dims, &strides, &elem_sizes);
assert_eq!(
compute_block_sizes(&dims, &strides, &elem_sizes).as_slice(),
model
);
let uniform = dst_size.max(src_size);
let old = model_blocks_sized(&dims, &strides, &[uniform, uniform]);
assert_eq!(
legacy_blocks(&dims, &strides, uniform, LegacyCosts::Saturating),
Some(old.clone())
);
assert_eq!(model, blocks, "dst={dst_size} src={src_size}");
assert_eq!(
old, old_blocks,
"dst={dst_size} src={src_size}: the shared size {uniform} answer"
);
assert_ne!(
model, old,
"dst={dst_size} src={src_size}: a shared size {uniform} must change the tile"
);
}
}
fn planned_blocks_sized(dims: &[usize], strides: &[&[isize]], elem_sizes: &[usize]) -> Vec<usize> {
let mut blocks = model_blocks_sized(dims, strides, elem_sizes);
if blocks != dims {
super::fit_l1_sets(dims, strides, elem_sizes, 0, &mut blocks);
}
blocks
}
#[test]
fn the_pointwise_plan_uses_each_operands_element_size() {
let dims = [128usize, 128];
let dst = [1isize, 128];
let src = [128, 1];
let strides: [&[isize]; 2] = [&dst, &src];
let total = 128 * 128;
let cases: [[usize; 2]; 2] = [
[std::mem::size_of::<f64>(), std::mem::size_of::<u8>()],
[std::mem::size_of::<C64>(), std::mem::size_of::<f64>()],
];
for elem_sizes in cases {
let (fused_dims, ordered, plan) =
crate::kernel::pointwise_plan(&dims, &strides, Some(0), &elem_sizes, total);
let ordered: Vec<&[isize]> = ordered.iter().map(|s| s.as_slice()).collect();
assert_eq!(
plan.block.as_slice(),
planned_blocks_sized(&fused_dims, &ordered, &elem_sizes),
"{elem_sizes:?}"
);
let uniform = elem_sizes.iter().copied().max().unwrap();
let (_, _, shared) =
crate::kernel::pointwise_plan(&dims, &strides, Some(0), &[uniform; 2], total);
assert_ne!(plan.block, shared.block, "{elem_sizes:?}");
}
}
#[test]
fn the_view_path_keeps_the_flat_walk_where_the_tiles_share_no_cache_line() {
let dims = [4096usize, 17, 33];
let dst = [1isize, 4096, 69_632];
let src = [1, 135_168, 4096];
let strides: [&[isize]; 2] = [&dst, &src];
let elem_sizes = [std::mem::size_of::<f64>(); 2];
let total = 4096 * 17 * 33;
assert_eq!(
model_blocks_sized(&dims, &strides, &elem_sizes),
[4096, 16, 16]
);
let (fused_dims, ordered, plan) =
crate::kernel::pointwise_plan(&dims, &strides, Some(0), &elem_sizes, total);
let ordered: Vec<&[isize]> = ordered.iter().map(|s| s.as_slice()).collect();
assert_eq!(fused_dims.as_slice(), dims);
assert_eq!(ordered.as_slice(), strides.as_slice());
assert_eq!(
plan.block.as_slice(),
fused_dims.as_slice(),
"the view path must keep the flat walk where no visit order reuses a line"
);
let dims = [64usize, 64, 64];
let dst = [1isize, 64, 4096];
let src = [0isize, 1, 1];
let strides: [&[isize]; 2] = [&dst, &src];
let (fused_dims, ordered, plan) =
crate::kernel::pointwise_plan(&dims, &strides, Some(0), &elem_sizes, 64 * 64 * 64);
let ordered: Vec<&[isize]> = ordered.iter().map(|s| s.as_slice()).collect();
assert_eq!(
model_blocks_sized(&fused_dims, &ordered, &elem_sizes),
[64, 31, 16]
);
assert_eq!(plan.block.as_slice(), [64, 31, 16]);
let parity = [
([1024usize, 1024], [1024isize, 1], [1isize, 1024]),
([512usize, 512], [1isize, 512], [0isize, 1]),
];
for (dims, dst, src) in parity {
let strides: [&[isize]; 2] = [&dst, &src];
let (fused_dims, ordered, plan) = crate::kernel::pointwise_plan(
&dims,
&strides,
Some(0),
&elem_sizes,
dims.iter().product(),
);
let ordered: Vec<&[isize]> = ordered.iter().map(|s| s.as_slice()).collect();
assert_ne!(plan.block.as_slice(), fused_dims.as_slice(), "must tile");
assert_eq!(
plan.block.as_slice(),
planned_blocks_sized(&fused_dims, &ordered, &elem_sizes),
"{dims:?}"
);
}
}
#[test]
fn a_zero_sized_destination_leaves_the_reduction_to_the_source() {
let dims = [2usize, 8192];
let dst = [1isize, 2];
let src = [2, 1 << 14];
let strides: [&[isize]; 2] = [&dst, &src];
let elem_sizes = [0usize, 8];
let model = model_blocks_sized(&dims, &strides, &elem_sizes);
assert_eq!(
compute_block_sizes(&dims, &strides, &elem_sizes).as_slice(),
model
);
assert_eq!(model, [2, 511]);
assert_eq!(
model_blocks_sized(&dims, &strides, &[8, 8]),
[2, 8192],
"the pre-#426 answer for the same input"
);
}
#[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, 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_stops_the_increasing_strides_exit() {
let dims = [2usize, 8192];
let dst_strides = [1isize, 2];
let src_strides = [1isize << 61, 1];
let strides = [&dst_strides[..], &src_strides[..]];
let (_, _, plan) = build_plan_fused(&dims, &strides, Some(0), &[8, 0]);
assert_eq!(model_blocks_sized(&dims, &strides, &[8, 0]), [2, 2044]);
assert_eq!(plan.block.as_slice(), [2, 2044]);
assert_eq!(
legacy_blocks(&dims, &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);
let zeros = vec![0usize; strides.len()];
assert_eq!(
compute_block_sizes(&dims, &strides, &zeros).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, 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, 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, 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]);
}
fn permuted_strides(dims: &[usize], perm: &[usize]) -> Vec<isize> {
let mut strides = vec![0isize; dims.len()];
let mut stride = 1isize;
for &axis in perm {
strides[axis] = stride;
stride *= dims[axis] as isize;
}
strides
}
#[test]
fn flat_scratch_matches_the_model_across_its_spill_boundaries() {
let cases: [(usize, usize); 5] = [(8, 2), (9, 2), (8, 5), (9, 5), (12, 6)];
for (rank, operands) in cases {
let dims: Vec<usize> = (0..rank).map(|i| 2 + i % 3).collect();
let strides: Vec<Vec<isize>> = (0..operands)
.map(|k| {
let mut perm: Vec<usize> = (0..rank).map(|i| (i + k) % rank).collect();
if k % 2 == 1 {
perm.reverse();
}
permuted_strides(&dims, &perm)
})
.collect();
let strides = refs(&strides);
assert!(!strides.iter().all(|s| strictly_increasing(s)));
let blocks = compute_block_sizes(&dims, &strides, &vec![8usize; operands]);
assert_ne!(
blocks.as_slice(),
dims.as_slice(),
"rank {rank}, {operands} operands"
);
assert_eq!(
blocks.as_slice(),
model_blocks(&dims, &strides, 8),
"rank {rank}, {operands} operands"
);
}
let dims = [8usize, 5, 6, 7, 4, 3];
let strides: Vec<Vec<isize>> = [
[0usize, 1, 2, 3, 4, 5],
[0, 1, 5, 4, 3, 2],
[0, 1, 3, 5, 2, 4],
]
.iter()
.map(|perm| permuted_strides(&dims, perm))
.collect();
let strides = refs(&strides);
let blocks = reduced_block_sizes(&dims, &strides, &[8, 8, 8]).unwrap();
assert_eq!(blocks[..2], dims[..2]);
assert_ne!(blocks.as_slice(), dims.as_slice());
assert_eq!(blocks.as_slice(), model_blocks(&dims, &strides, 8));
assert_eq!(blocks.as_slice(), [8, 5, 5, 5, 2, 3]);
assert_eq!(
compute_block_sizes(&dims, &strides, &[8, 8, 8]).as_slice(),
dims
);
}
#[test]
fn a_padded_tail_beyond_the_bounded_branch_keeps_the_slab_answer() {
let mut dims = vec![4096usize, 17, 33];
let mut dst = vec![1isize, 4096, 69_632];
let mut src = vec![1isize, 135_168, 4096];
let unpadded = reduced_block_sizes(&dims, &[&dst, &src], &[8, 8]).unwrap();
dims.extend([1usize; 100]);
dst.extend([0isize; 100]);
src.extend([0isize; 100]);
let blocks = reduced_block_sizes(&dims, &[&dst, &src], &[8, 8]).unwrap();
let mut expected = unpadded.to_vec();
expected.extend([1usize; 100]);
assert_eq!(blocks.as_slice(), expected);
assert!(dims.len() - 1 > crate::raw_ops::MAX_MOVING_AXES);
assert!(!declines_tiles(&dims, &[&dst, &src], &[8, 8], &blocks));
}