refactor

Sebastian Thiel committed 6 years ago

Commit deea36c1 parent 83a01022 files · +30 −30Browse files

Unified · Split

2 files

git-odb/src/pack/tree/iter.rs +22 −22
git-odb/src/pack/tree/mod.rs +8 −8

@@ -1,14 +1,14 @@
1	1	use crate::pack::tree::{Item, Tree};
2	2
3	3	/// All the unsafe bits to support parallel iteration with write access
4		−impl<D> Tree<D> {
	4	+impl<T> Tree<T> {
5	5	#[allow(unsafe_code)]
6	6	/// SAFETY: Called from node with is guaranteed to not be aliasing with any other node.
7	7	/// Note that we are iterating nodes that we are affecting here, but that only affects the
8	8	/// 'is_root' field fo the item, not the data field that we are writing here.
9	9	/// For all details see `from_node_take_entry()`.
10		− unsafe fn from_node_put_data(&self, index: usize, data: D) {
11		− let items_mut: &mut Vec<Item<D>> = &mut *(self.items.get());
	10	+ unsafe fn from_node_put_data(&self, index: usize, data: T) {
	11	+ let items_mut: &mut Vec<Item<T>> = &mut *(self.items.get());
12	12	items_mut.get_unchecked_mut(index).data = data;
13	13	}
14	14
@@ -22,11 +22,11 @@ impl<D> Tree<D> { · 7 unmodified lines
22	22	/// alias multiple nodes in the tree.
23	23	/// It's safe for multiple threads to hold different chunks, as they are guaranteed to be non-overlapping and unique.
24	24	/// If the tree is accessed after iteration, it will panic as no mutation is allowed anymore, nor is
25		− unsafe fn from_node_take_entry(&self, index: usize) -> (D, Vec<usize>)
	25	+ unsafe fn from_node_take_entry(&self, index: usize) -> (T, Vec<usize>)
26	26	where
27		− D: Default,
	27	+ T: Default,
28	28	{
29		− let items_mut: &mut Vec<Item<D>> = &mut *(self.items.get());
	29	+ let items_mut: &mut Vec<Item<T>> = &mut *(self.items.get());
30	30	let item = items_mut.get_unchecked_mut(index);
31	31	let children = std::mem::take(&mut item.children);
32	32	let data = std::mem::take(&mut item.data);
@@ -35,11 +35,11 @@ impl<D> Tree<D> { · 2 unmodified lines
35	35
36	36	#[allow(unsafe_code)]
37	37	/// SAFETY: As `take_entry(…)` - but this one only takes if the data of Node is a root
38		− unsafe fn from_iter_take_entry_if_root(&self, index: usize) -> Option<(D, Vec<usize>)>
	38	+ unsafe fn from_iter_take_entry_if_root(&self, index: usize) -> Option<(T, Vec<usize>)>
39	39	where
40		− D: Default,
	40	+ T: Default,
41	41	{
42		− let items_mut: &mut Vec<Item<D>> = &mut *(self.items.get());
	42	+ let items_mut: &mut Vec<Item<T>> = &mut *(self.items.get());
43	43	let item = items_mut.get_unchecked_mut(index);
44	44	if item.is_root {
45	45	let children = std::mem::take(&mut item.children);
@@ -52,9 +52,9 @@ impl<D> Tree<D> { · 6 unmodified lines
52	52	}
53	53
54	54	/// Iteration
55		−impl<D> Tree<D> {
	55	+impl<T> Tree<T> {
56	56	/// Return an iterator over chunks of roots. Roots are not children themselves, they have no parents.
57		− pub fn iter_root_chunks(&mut self, size: usize) -> Chunks<D> {
	57	+ pub fn iter_root_chunks(&mut self, size: usize) -> Chunks<T> {
58	58	Chunks {
59	59	tree: self,
60	60	size,
@@ -63,18 +63,18 @@ impl<D> Tree<D> { · 2 unmodified lines
63	63	}
64	64	}
65	65
66		−pub struct Node<'a, D> {
67		− tree: &'a Tree<D>,
	66	+pub struct Node<'a, T> {
	67	+ tree: &'a Tree<T>,
68	68	index: usize,
69	69	children: Vec<usize>,
70		− pub data: D,
	70	+ pub data: T,
71	71	}
72	72
73		−impl<'a, D> Node<'a, D>
	73	+impl<'a, T> Node<'a, T>
74	74	where
75		− D: Default,
	75	+ T: Default,
76	76	{
77		− pub fn store_changes_then_into_child_iter(self) -> impl Iterator<Item = Node<'a, D>> {
	77	+ pub fn store_changes_then_into_child_iter(self) -> impl Iterator<Item = Node<'a, T>> {
78	78	#[allow(unsafe_code)]
79	79	// SAFETY: The index is valid as it was controlled by `add_child(…)`, then see `take_entry(…)`
80	80	unsafe {
@@ -95,17 +95,17 @@ where · 14 unmodified lines
95	95	}
96	96	}
97	97
98		−pub struct Chunks<'a, D> {
99		− tree: &'a Tree<D>,
	98	+pub struct Chunks<'a, T> {
	99	+ tree: &'a Tree<T>,
100	100	size: usize,
101	101	cursor: usize,
102	102	}
103	103
104		−impl<'a, D> Iterator for Chunks<'a, D>
	104	+impl<'a, T> Iterator for Chunks<'a, T>
105	105	where
106		− D: Default,
	106	+ T: Default,
107	107	{
108		− type Item = Vec<Node<'a, D>>;
	108	+ type Item = Vec<Node<'a, T>>;
109	109
110	110	fn next(&mut self) -> Option<Self::Item> {
111	111	if self.cursor == self.tree.one_past_last_seen_root {

git-odb/src/pack/tree/mod.rs+8−8

@@ -21,18 +21,18 @@ pub use iter::{Chunks, Node}; · 20 unmodified lines
21	21
22	22	pub mod from_offsets;
23	23
24		−pub struct Item<D> {
	24	+pub struct Item<T> {
25	25	pub offset: u64,
26	26	is_root: bool,
27		− pub data: D,
	27	+ pub data: T,
28	28	// TODO: figure out average amount of children per node and use smallvec instead
29	29	children: Vec<usize>,
30	30	}
31	31	/// A tree that allows one-time iteration over all nodes and their children, consuming it in the process,
32	32	/// while being shareable among threads without a lock.
33	33	/// It does this by making the run-time guarantee that iteration only happens once.
34		−pub struct Tree<D> {
35		− items: UnsafeCell<Vec<Item<D>>>,
	34	+pub struct Tree<T> {
	35	+ items: UnsafeCell<Vec<Item<T>>>,
36	36	last_added_offset: u64,
37	37	one_past_last_seen_root: usize,
38	38	}
@@ -42,7 +42,7 @@ pub struct Tree<D> { · 3 unmodified lines
42	42	#[allow(unsafe_code)]
43	43	unsafe impl<T> Sync for Tree<T> {}
44	44
45		−impl<D> Tree<D> {
	45	+impl<T> Tree<T> {
46	46	pub fn with_capacity(num_objects: usize) -> Result<Self, Error> {
47	47	if num_objects == 0 {
48	48	return Err(Error::InvariantNonEmpty);
@@ -63,7 +63,7 @@ impl<D> Tree<D> { · 14 unmodified lines
63	63	}
64	64	}
65	65
66		− pub fn add_root(&mut self, offset: u64, data: D) -> Result<(), Error> {
	66	+ pub fn add_root(&mut self, offset: u64, data: T) -> Result<(), Error> {
67	67	// SAFETY: Because we passed the assertion above which implies no other access is possible as per
68	68	// standard borrow check rules.
69	69	#[allow(unsafe_code)]
@@ -79,7 +79,7 @@ impl<D> Tree<D> { · 9 unmodified lines
79	79	Ok(())
80	80	}
81	81
82		− pub fn add_child(&mut self, base_offset: u64, offset: u64, data: D) -> Result<(), Error> {
	82	+ pub fn add_child(&mut self, base_offset: u64, offset: u64, data: T) -> Result<(), Error> {
83	83	// SAFETY: Because we passed the assertion above which implies no other access is possible as per
84	84	// standard borrow check rules.
85	85	#[allow(unsafe_code)]
@@ -99,7 +99,7 @@ impl<D> Tree<D> { · 13 unmodified lines
99	99	Ok(())
100	100	}
101	101
102		− pub fn into_items(self) -> Vec<Item<D>> {
	102	+ pub fn into_items(self) -> Vec<Item<T>> {
103	103	self.items.into_inner()
104	104	}
105	105	}

refactor

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code