Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Iterator implementation #22

Merged
merged 2 commits into from
Apr 22, 2019
Merged

Iterator implementation #22

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
5872f16
Implements IntoIter for PVec
arazabishov Apr 20, 2019
1ba0716
Adds benchmarks for iterator implementation
arazabishov Apr 22, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
180 changes: 136 additions & 44 deletions benches/lib-criterion.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,7 @@ extern crate pvec;
extern crate rand;
extern crate test as test_crate;

use criterion::{BatchSize, Criterion, ParameterizedBenchmark};
use criterion::{black_box, BatchSize, Criterion, ParameterizedBenchmark};
use dogged::DVec;
use im::Vector as IVec;
use rand::{Rng, SeedableRng, XorShiftRng};
Expand Down Expand Up @@ -196,58 +196,82 @@ fn index_sequentially(criterion: &mut Criterion) {
ParameterizedBenchmark::new(
"std",
|bencher, n| {
let mut vec = Vec::new();
bencher.iter_batched(
|| {
let mut vec = Vec::new();

for i in 0..*n {
vec.push(i * 2);
}
for i in 0..*n {
vec.push(i * 2);
}

bencher.iter(|| {
for i in 0..*n {
let _ = vec[i];
}
})
vec
},
|data| {
for i in 0..*n {
black_box(data[i]);
}
},
BatchSize::SmallInput,
)
},
vec![100, 500, 1000, 5000, 10000, 50000, 100000, 200000, 500000],
)
.with_function("dvec", |bencher, n| {
let mut vec = DVec::new();
bencher.iter_batched(
|| {
let mut vec = DVec::new();

for i in 0..*n {
vec.push(i * 2);
}
for i in 0..*n {
vec.push(i * 2);
}

bencher.iter(|| {
for i in 0..*n {
let _ = vec[i];
}
});
vec
},
|data| {
for i in 0..*n {
black_box(data[i]);
}
},
BatchSize::SmallInput,
)
})
.with_function("im-rs", |bencher, n| {
let mut vec = IVec::new();
bencher.iter_batched(
|| {
let mut vec = IVec::new();

for i in 0..*n {
vec.push_back(i * 2);
}
for i in 0..*n {
vec.push_back(i * 2);
}

bencher.iter(|| {
for i in 0..*n {
let _ = vec[i];
}
});
vec
},
|data| {
for i in 0..*n {
black_box(data[i]);
}
},
BatchSize::SmallInput,
)
})
.with_function("pvec", |bencher, n| {
let mut vec = PVec::new();
bencher.iter_batched(
|| {
let mut vec = PVec::new();

for i in 0..*n {
vec.push(i * 2);
}
for i in 0..*n {
vec.push(i * 2);
}

bencher.iter(|| {
for i in 0..*n {
let _ = vec[i];
}
});
vec
},
|data| {
for i in 0..*n {
black_box(data[i]);
}
},
BatchSize::SmallInput,
)
}),
);
}
Expand Down Expand Up @@ -543,15 +567,83 @@ fn append_push(criterion: &mut Criterion) {
);
}

fn iterator(criterion: &mut Criterion) {
criterion.bench(
"iterator",
ParameterizedBenchmark::new(
"std",
|bencher, n| {
bencher.iter_batched(
|| {
let mut vec = Vec::new();

for i in 0..*n {
vec.push(i * 2);
}

vec
},
|data| {
for i in data.into_iter() {
black_box(i);
}
},
BatchSize::SmallInput,
)
},
vec![100, 500, 1000, 5000, 10000, 50000, 100000, 200000, 500000],
)
.with_function("im-rs", |bencher, n| {
bencher.iter_batched(
|| {
let mut vec = IVec::new();

for i in 0..*n {
vec.push_back(i * 2);
}

vec
},
|data| {
for i in data.into_iter() {
black_box(i);
}
},
BatchSize::SmallInput,
)
})
.with_function("pvec", |bencher, n| {
bencher.iter_batched(
|| {
let mut vec = PVec::new();

for i in 0..*n {
vec.push(i * 2);
}

vec
},
|data| {
for i in data.into_iter() {
black_box(i);
}
},
BatchSize::SmallInput,
)
}),
);
}

criterion_group!(
benches,
push,
push_clone,
pop_clone,
// push,
// push_clone,
// pop_clone,
index_sequentially,
index_randomly,
append,
append_clone,
append_push
iterator,
// index_randomly,
// append,
// append_clone,
// append_push
);
criterion_main!(benches);
152 changes: 146 additions & 6 deletions src/iter.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,22 +1,55 @@
use super::PVec;
use rrbtree::iter::RrbTreeIter;
use rrbtree::BRANCH_FACTOR;
use std::fmt::Debug;

#[derive(Debug, Clone)]
pub struct PVecIter<T> {
// - you should avoid heap allocation in iterators
pvec: PVec<T>,
len: usize,
tree_iter: RrbTreeIter<T>,
tree_len: usize,
tail: [Option<T>; BRANCH_FACTOR],
tail_len: usize,
index: usize,
chunk: Option<([Option<T>; BRANCH_FACTOR], usize)>,
chunk_index: usize,
}

impl<T: Clone + Debug> Iterator for PVecIter<T> {
type Item = T;

fn next(&mut self) -> Option<Self::Item> {
return None;
return if self.index < self.tree_len {
if self.chunk.is_none() {
self.chunk = self.tree_iter.next();
}

let chunk = self.chunk.as_mut().unwrap();
if self.chunk_index >= chunk.1 {
self.chunk_index = 0;
self.chunk = self.tree_iter.next();
}

let chunk = self.chunk.as_mut().unwrap();
let value = chunk.0[self.chunk_index].take();

self.chunk_index += 1;
self.index += 1;

value
} else if self.index < self.tree_len + self.tail_len {
let index = self.index - self.tree_len;

self.index += 1;
self.tail[index].take()
} else {
None
};
}

fn size_hint(&self) -> (usize, Option<usize>) {
(self.len, Some(self.len))
let len = self.tree_len + self.tail_len;
(len, Some(len))
}
}

Expand All @@ -26,8 +59,115 @@ impl<T: Clone + Debug> IntoIterator for PVec<T> {

fn into_iter(self) -> Self::IntoIter {
PVecIter {
len: self.len(),
pvec: self,
tree_len: self.tree.len(),
tree_iter: self.tree.into_iter(),
tail_len: self.tail_len,
tail: self.tail,
index: 0,
chunk: None,
chunk_index: 0,
}
}
}

#[cfg(test)]
#[macro_use]
mod test {
use super::PVec;
use super::BRANCH_FACTOR;

#[test]
fn empty_pvec() {
let pvec: PVec<usize> = PVec::new();
let mut iter = pvec.into_iter();

let size = iter.size_hint();
let next = iter.next();

assert_eq!(next, None);
assert_eq!(size, (0, Some(0)));
}

#[test]
fn pvec_has_tail_only() {
let mut pvec = PVec::new();

for i in 0..BRANCH_FACTOR {
pvec.push(i);
}

for (i, val) in pvec.into_iter().enumerate() {
assert_eq!(i, val);
}
}

#[test]
fn underlying_tree_has_multiple_levels() {
let mut pvec = PVec::new();

let mut val = 0;
for _ in 0..(BRANCH_FACTOR * BRANCH_FACTOR * BRANCH_FACTOR) {
pvec.push(val);
val += 1;
}

for _ in 0..(BRANCH_FACTOR / 2) {
pvec.push(val);
val += 1;
}

for (i, val) in pvec.into_iter().enumerate() {
assert_eq!(i, val);
}
}

#[test]
fn underlying_tree_is_relaxed() {
let vec_size = 33;

let mut vec = PVec::new();
let mut vec_item = 0;

for i in 0..128 {
if i % 2 == 0 {
let mut vec_temp = PVec::new();

for _ in 0..vec_size {
vec_temp.push(vec_item);
vec_item += 1;
}

assert_eq!(vec_temp.len(), vec_size);

vec.append(&mut vec_temp);

assert_eq!(vec_temp.len(), 0);
} else {
for _ in 0..(vec_size + vec_size) {
vec.push(vec_item);
vec_item += 1;
}
}

assert_eq!(vec.len(), vec_item);

for i in 0..vec.len() {
assert_eq!(*vec.get(i).unwrap(), i);
assert_eq!(*vec.get_mut(i).unwrap(), i);
}

let mut vec_one_clone = vec.clone();
for i in (0..vec_item).rev() {
assert_eq!(vec_one_clone.pop().unwrap(), i);
}

assert_eq!(vec_one_clone.len(), 0);
assert_eq!(vec.len(), vec_item);

let vec_clone = vec.clone();
for (i, val) in vec_clone.into_iter().enumerate() {
assert_eq!(i, val);
}
}
}
}
Loading