Minor improvements (#24)

* removed bounds() * Moved tests around * consolidated view creation logic * doc tidy up * a few minor fixes * improved test coverage * main_cols renamed to stride * more testing, updated criterion * removed Clone restriction on TooDee::new * benchmark to compare toodee with grid / vec impls * swap() implementation * Simplified some of the logic blocks * Removed transpose - needs some more thinking * version 0.5.0 * test fixes, added ubuntu
antonmarsden · Sep 9, 2023 · 635f059 · 635f059
1 parent eb1a05b
commit 635f059
Show file tree

Hide file tree

Showing 14 changed files with 974 additions and 583 deletions.
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -15,6 +15,8 @@ jobs:
           rust-version: stable
         - os: windows-latest
           rust-version: stable
+        - os: ubuntu-latest
+          rust-version: stable
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v2

diff --git a/CHANGES.md b/CHANGES.md
@@ -2,9 +2,10 @@
 
 ## Changes
 
-### Unreleased
+### Version 0.5.0
 
-- `transpose` integration
+- Comparison (vs) benchmarks added
+- _Breaking change_: Removed the `bounds()` function due to additional complexity and limited value.
 
 ### Version 0.4.2
 

diff --git a/Cargo.toml b/Cargo.toml
@@ -1,24 +1,22 @@
 [package]
 name = "toodee"
-version = "0.4.2"
+version = "0.5.0"
 authors = ["Anton Marsden <anton.marsden@ninetyten.co.nz>"]
 edition = "2021"
 description = "A lightweight 2D wrapper around a Vec."
 documentation = "https://docs.rs/toodee/"
 repository = "https://github.com/antonmarsden/toodee"
 readme = "README.md"
-keywords = ["array", "matrix", "sort", "transpose", "translate"]
+keywords = ["array", "matrix", "sort", "translate"]
 license = "MIT OR Apache-2.0"
 categories = ["algorithms", "data structures", "no-std"]
 exclude = [ ".github/*", ]
 
 [features]
-default = ["translate", "sort", "copy", "serde", "transpose"]
+default = ["translate", "sort", "copy", "serde"]
 
 translate = []
 
-transpose = ["dep:transpose"]
-
 sort = []
 
 copy = []
@@ -27,14 +25,14 @@ serde = ["dep:serde"]
 
 [dependencies]
 serde = { version = "1.0.181", optional = true, default-features = false, features = ["derive", "alloc"] }
-transpose = { version = "0.2.2", optional = true }
 
 [dev-dependencies]
 rand = "0.8.5"
 serde_json = "1.0.104"
+grid = "0.10.0"
 
 [dev-dependencies.criterion]
-version = "0.3.4"
+version = "0.5.1"
 features = ["html_reports"]
 
 [[bench]]
@@ -48,3 +46,7 @@ harness = false
 [[bench]]
 name = "sort"
 harness = false
+
+[[bench]]
+name = "vs"
+harness = false
diff --git a/README.md b/README.md
@@ -117,11 +117,6 @@ Here's a small feature comparison chart:
 
 - GPU integration
 
-## Limitations
-
-- Views are not nested for the time being, The only impact is that the `bounds()` of a view
-  are always relative to the underlying `TooDee` array.
-
 ## License
 
 Licensed under either of

diff --git a/benches/vs.rs b/benches/vs.rs
@@ -0,0 +1,296 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use toodee::TooDee;
+use grid::Grid;
+use rand;
+use rand::Rng;
+
+const SIZE: usize = 1_000;
+
+fn init_vec_vec() -> Vec<Vec<u8>> {
+    vec![vec![0; SIZE]; SIZE]
+}
+
+fn init_grid() -> Grid<u8> {
+    Grid::init(SIZE, SIZE, 0)
+}
+
+fn init_toodee() -> TooDee<u8> {
+    TooDee::init(SIZE, SIZE, 0)
+}
+
+fn create_rand_ranged() -> usize {
+    rand::thread_rng().gen_range(0..SIZE)
+}
+
+fn create_rand_tuple() -> (usize, usize) {
+    let mut rnd = rand::thread_rng();
+    (rnd.gen_range(0..SIZE), rnd.gen_range(0..SIZE))
+}
+
+fn bench_idx(c: &mut Criterion) {
+    let mut group = c.benchmark_group("idx");
+    group.bench_function("vecvec", |b| {
+        let vec_vec = init_vec_vec();
+        b.iter_batched(
+            || create_rand_tuple(),
+            |(x, y)| {
+                let _v = vec_vec[x][y];
+            },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || create_rand_tuple(),
+            |(x, y)| {
+                let _v = grid[x][y];
+            },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || create_rand_tuple(),
+            |(x, y)| {
+                let _v = toodee[x][y];
+            },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+fn bench_get(c: &mut Criterion) {
+    let mut group = c.benchmark_group("get");
+    group.bench_function("vecvec", |b| {
+        let vec_vec = init_vec_vec();
+        b.iter_batched(
+            || create_rand_tuple(),
+            |(x, y)| {
+                let _v = vec_vec.get(x).unwrap().get(y).unwrap();
+            },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || create_rand_tuple(),
+            |(x, y)| {
+                let _v = grid.get(x, y).unwrap();
+            },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || create_rand_tuple(),
+            |(x, y)| {
+                let _v = toodee[(x,y)];
+            },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+fn bench_set(c: &mut Criterion) {
+    let mut group = c.benchmark_group("set");
+    group.bench_function("vecvec", |b| {
+        let mut vec_vec = init_vec_vec();
+        b.iter_batched(
+            || create_rand_tuple(),
+            |(x, y)| vec_vec[x][y] = 42,
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("grid", |b| {
+        let mut g = init_grid();
+        b.iter_batched(
+            || create_rand_tuple(),
+            |(x, y)| g[x][y] = 42,
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let mut toodee = init_toodee();
+        b.iter_batched(
+            || create_rand_tuple(),
+            |(x, y)| toodee[x][y] = 42,
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+fn bench_push_row(c: &mut Criterion) {
+    let mut group = c.benchmark_group("push_row");
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || (grid.clone(), vec![0; SIZE]),
+            |(mut g, r) | g.push_row(r),
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || (toodee.clone(), vec![0; SIZE]),
+            |(mut g, r) | g.push_row(r),
+            criterion::BatchSize::SmallInput,
+        )
+    });
+}
+
+fn bench_push_col(c: &mut Criterion) {
+    let mut group = c.benchmark_group("push_col");
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || (grid.clone(), vec![0; SIZE]),
+            |(mut g, c) | g.push_col(c),
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || (toodee.clone(), vec![0; SIZE]),
+            |(mut g, c) | g.push_row(c),
+            criterion::BatchSize::SmallInput,
+        )
+    });
+}
+
+fn bench_pop_row(c: &mut Criterion) {
+    let mut group = c.benchmark_group("pop_row");
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || grid.clone(),
+            |mut g | { g.pop_row(); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || toodee.clone(),
+            |mut g | { g.pop_row(); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+}
+
+fn bench_pop_col(c: &mut Criterion) {
+    let mut group = c.benchmark_group("pop_col");
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || grid.clone(),
+            |mut g | { g.pop_col(); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || toodee.clone(),
+            |mut g | { g.pop_col(); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+}
+
+fn bench_insert_row(c: &mut Criterion) {
+    let mut group = c.benchmark_group("insert_row");
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || (grid.clone(), create_rand_ranged(), vec![0; SIZE]),
+            |(mut g, idx, data) | { g.insert_row(idx, data); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || (toodee.clone(), create_rand_ranged(), vec![0; SIZE]),
+            |(mut g, idx, data) | { g.insert_row(idx, data); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+}
+
+fn bench_insert_col(c: &mut Criterion) {
+    let mut group = c.benchmark_group("insert_col");
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || (grid.clone(), create_rand_ranged(), vec![0; SIZE]),
+            |(mut g, idx, data) | { g.insert_col(idx, data); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || (toodee.clone(), create_rand_ranged(), vec![0; SIZE]),
+            |(mut g, idx, data) | { g.insert_col(idx, data); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+}
+
+fn bench_remove_row(c: &mut Criterion) {
+    let mut group = c.benchmark_group("remove_row");
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || (grid.clone(), create_rand_ranged()),
+            |(mut g, idx) | { g.remove_row(idx); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || (toodee.clone(), create_rand_ranged()),
+            |(mut g, idx) | { g.remove_row(idx); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+}
+
+fn bench_remove_col(c: &mut Criterion) {
+    let mut group = c.benchmark_group("remove_col");
+    group.bench_function("grid", |b| {
+        let grid = init_grid();
+        b.iter_batched(
+            || (grid.clone(), create_rand_ranged()),
+            |(mut g, idx) | { g.remove_col(idx); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+    group.bench_function("toodee", |b| {
+        let toodee = init_toodee();
+        b.iter_batched(
+            || (toodee.clone(), create_rand_ranged()),
+            |(mut g, idx) | { g.remove_col(idx); },
+            criterion::BatchSize::SmallInput,
+        )
+    });
+}
+
+
+
+criterion_group!(benches, bench_idx, bench_get, bench_set,
+    bench_push_row, bench_push_col,
+    bench_pop_row, bench_pop_col,
+    bench_insert_row, bench_insert_col,
+    bench_remove_row, bench_remove_col);
+criterion_main!(benches);