bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

make TinyList more readable and optimize remove(_)

Browse source 
also add benchmarks

Before:

```
test tiny_list::test::bench_insert_empty             ... bench:           1 ns/iter (+/- 0)
test tiny_list::test::bench_insert_one               ... bench:          16 ns/iter (+/- 0)
test tiny_list::test::bench_remove_empty             ... bench:           2 ns/iter (+/- 0)
test tiny_list::test::bench_remove_one               ... bench:           6 ns/iter (+/- 0)
test tiny_list::test::bench_remove_unknown           ... bench:           4 ns/iter (+/- 0)
```

After:

```
test tiny_list::test::bench_insert_empty             ... bench:           1 ns/iter (+/- 0)
test tiny_list::test::bench_insert_one               ... bench:          16 ns/iter (+/- 0)
test tiny_list::test::bench_remove_empty             ... bench:           0 ns/iter (+/- 0)
test tiny_list::test::bench_remove_one               ... bench:           3 ns/iter (+/- 0)
test tiny_list::test::bench_remove_unknown           ... bench:           2 ns/iter (+/- 0)
```
This commit is contained in:
Andre Bogus 2018-08-02 22:58:53 +02:00
parent 03da14ba8c
commit 4471537ea0
1 changed files with 49 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

81
src/librustc_data_structures/tiny_list.rs
View file

@ -50,44 +50,22 @@ impl<T: PartialEq> TinyList<T> {
#[inline] #[inline]
pub fn insert(&mut self, data: T) { pub fn insert(&mut self, data: T) {
let current_head = mem::replace(&mut self.head, None); self.head = Some(Element {
data,
if let Some(current_head) = current_head { next: mem::replace(&mut self.head, None).map(Box::new),
let current_head = Box::new(current_head); });
self.head = Some(Element {
data,
next: Some(current_head)
});
} else {
self.head = Some(Element {
data,
next: None,
})
}
} }
#[inline] #[inline]
pub fn remove(&mut self, data: &T) -> bool { pub fn remove(&mut self, data: &T) -> bool {
let remove_head = if let Some(ref mut head) = self.head { self.head = match self.head {
if head.data == *data { Some(ref mut head) if head.data == *data => {
Some(mem::replace(&mut head.next, None)) mem::replace(&mut head.next, None).map(|x| *x)
} else {
None
} }
} else { Some(ref mut head) => return head.remove_next(data),
return false None => return false,
}; };
true
if let Some(remove_head) = remove_head {
if let Some(next) = remove_head {
self.head = Some(*next);
} else {
self.head = None;
}
return true
}
self.head.as_mut().unwrap().remove_next(data)
} }
#[inline] #[inline]
@ -156,6 +134,8 @@ impl<T: PartialEq> Element<T> {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use super::*;
extern crate test;
use self::test::Bencher;
#[test] #[test]
fn test_contains_and_insert() { fn test_contains_and_insert() {
@ -248,4 +228,41 @@ mod test {
assert_eq!(list.len(), 0); assert_eq!(list.len(), 0);
} }
#[bench]
fn bench_insert_empty(b: &mut Bencher) {
b.iter(|| {
let mut list = TinyList::new();
list.insert(1);
})
}
#[bench]
fn bench_insert_one(b: &mut Bencher) {
b.iter(|| {
let mut list = TinyList::new_single(0);
list.insert(1);
})
}
#[bench]
fn bench_remove_empty(b: &mut Bencher) {
b.iter(|| {
TinyList::new().remove(&1)
});
}
#[bench]
fn bench_remove_unknown(b: &mut Bencher) {
b.iter(|| {
TinyList::new_single(0).remove(&1)
});
}
#[bench]
fn bench_remove_one(b: &mut Bencher) {
b.iter(|| {
TinyList::new_single(1).remove(&1)
});
}
} }