Merge pull request #3 from mfigurski80/bench

Create basic Benchmarks

benches/insert.rs

@@ -0,0 +1,77 @@
+#![feature(test)]
+
+extern crate test;
+use test::Bencher;
+
+extern crate range_bounds_map;
+use range_bounds_map::*;
+
+/// linear multiplier for work done by benchmarks
+const REPEAT: usize = 120;
+
+#[bench]
+fn bench_insert_platonic(b: &mut Bencher) {
+	b.iter(|| {
+		let mut map = RangeBoundsMap::new();
+		for i in 0..REPEAT {
+			let r = i..=i;
+			map.insert_platonic(r, i).expect("insert failed");
+		}
+	});
+}
+
+#[bench]
+fn bench_insert_coalesce_touching(b: &mut Bencher) {
+	b.iter(|| {
+		let mut map = RangeBoundsMap::new();
+		for i in 0..REPEAT / 2 {
+			let r1 = (10 * i)..(10 * i + 1);
+			let r2 = (10 * i + 1)..(10 * i + 2);
+			map.insert_coalesce_touching(r1, true)
+				.expect("Failed to insert");
+			map.insert_coalesce_touching(r2, true)
+				.expect("Failed to insert");
+		}
+	})
+}
+
+#[bench]
+fn bench_insert_coalesce_overlapping(b: &mut Bencher) {
+	b.iter(|| {
+		let mut map = RangeBoundsMap::new();
+		for i in 0..REPEAT / 2 {
+			let r1 = (10 * i)..(10 * i + 1);
+			let r2 = (10 * i)..(10 * i + 2);
+			map.insert_coalesce_overlapping(r1, true)
+				.expect("Failed to insert");
+			map.insert_coalesce_overlapping(r2, true)
+				.expect("Failed to insert");
+		}
+	})
+}
+
+#[bench]
+fn bench_insert_coalesce_touching_or_overlapping(b: &mut Bencher) {
+	b.iter(|| {
+		let mut map = RangeBoundsMap::new();
+		for i in 0..REPEAT / 2 {
+			let r1 = (10 * i + 1)..(10 * i + 2);
+			let r2 = (10 * i)..(10 * i + 4);
+			map.insert_coalesce_touching_or_overlapping(r1, 1)
+				.expect("Failed to insert");
+			map.insert_coalesce_touching_or_overlapping(r2, 2)
+				.expect("Failed to insert");
+		}
+	})
+}
+
+#[bench]
+fn bench_overwrite(b: &mut Bencher) {
+	b.iter(|| {
+		let mut map = RangeBoundsMap::new();
+		for i in 0..REPEAT {
+			let r = i..i + 2;
+			map.overwrite(r, i).expect("insert failed");
+		}
+	});
+}

benches/operations.rs

@@ -0,0 +1,73 @@
+#![feature(test)]
+
+use std::ops::{Bound, Range};
+
+extern crate test;
+use test::Bencher;
+
+extern crate range_bounds_map;
+use range_bounds_map::*;
+
+/// linear multiplier for work done by benchmarks
+const REPEAT: usize = 120;
+
+/// utility for constructing identity [i,i]->i map for benches
+fn build_identity_map(n: usize) -> RangeBoundsMap<usize, Range<usize>, usize> {
+	let mut map = RangeBoundsMap::new();
+	for i in 0..n {
+		map.insert_platonic(i..i + 1, i).expect("insert failed");
+	}
+	map
+}
+
+#[bench]
+fn bench_overlaps(b: &mut Bencher) {
+	let map = build_identity_map(REPEAT);
+	b.iter(|| for _ in map.overlapping(&(0..REPEAT)) {})
+}
+
+#[bench]
+fn bench_iter(b: &mut Bencher) {
+	let map = build_identity_map(REPEAT);
+	b.iter(|| for _ in map.iter() {})
+}
+
+#[bench]
+fn bench_remove_overlapping(b: &mut Bencher) {
+	let map = build_identity_map(REPEAT);
+	b.iter(|| {
+		let mut map = map.clone();
+		for _ in map.remove_overlapping(&(0..REPEAT)) {}
+	})
+}
+
+#[bench]
+fn bench_cut(b: &mut Bencher) {
+	let map = build_identity_map(REPEAT);
+	b.iter(|| {
+		let mut map = map.clone();
+		for _ in map.cut(&(0..REPEAT)).expect("Failed to cut") {}
+	})
+}
+
+#[bench]
+fn bench_gaps(b: &mut Bencher) {
+	let map = build_identity_map(REPEAT);
+	b.iter(|| for _ in map.gaps(&(0..REPEAT)) {})
+}
+
+#[bench]
+fn bench_split_off(b: &mut Bencher) {
+	let map = build_identity_map(REPEAT);
+	b.iter(|| {
+		let mut map = map.clone();
+		map.split_off(Bound::Included(REPEAT / 2))
+			.expect("Failed to split");
+	})
+}
+
+#[bench]
+fn bench_overlapping_trimmed(b: &mut Bencher) {
+	let map = build_identity_map(REPEAT);
+	b.iter(|| for _ in map.overlapping_trimmed(&(1..REPEAT - 1)) {})
+}

src/range_bounds_map.rs

@@ -1412,7 +1412,7 @@ where
 	}
 
 	/// Moves all elements from `other` into `self` by
-	/// [`RangeBoundsMap::insert_platonic()`] in acending order,
+	/// [`RangeBoundsMap::insert_platonic()`] in ascending order,
 	/// leaving `other` empty.
 	///
 	/// If any of the `RangeBounds` in `other` overlap `self` then