unify trait bounds for parallel code: prefer Clone over Sync (#259)

Sebastian Thiel committed 4 years ago

Commit c805d0b1 parent 3c790e06 files · +24 −24Browse files

Unified · Split

6 files

DEVELOPMENT.md +6 −0
git-features/src/parallel/in_parallel.rs +4 −4
git-features/src/parallel/mod.rs +2 −2
git-features/src/parallel/reduce.rs +7 −13
git-pack/src/data/output/count/objects/mod.rs +2 −2
git-pack/src/data/output/entry/iter_from_counts.rs +3 −3

@@ -683,3 +683,9 @@ Please note that these are based on the following value system: · 682 unmodified lines
683	a single-threaded version).	683	a single-threaded version).
684	- Maybe… after some benchmarks, we can entirely drop the single-threaded version if it's not significantly faster on a single thread (without thread primiives) than the	684	- Maybe… after some benchmarks, we can entirely drop the single-threaded version if it's not significantly faster on a single thread (without thread primiives) than the
685	same with multi-threading (but a single-thread).	685	same with multi-threading (but a single-thread).
		686	- Servers would be split into readers and writers, where…
		687	- …readers share a common pool and thus all maps, with lazy loading and refresh (but their pack-ids change due to that, and packs might disappear)
		688	- …writers when…
		689	- …cloning use an eagerly loaded Repository just for that particular clone for stable pack ids
		690	- …fetches use a lazy-loaded Repository with refresh disabled, and full retries if the pack they were referring to goes away. Maybe there can be a policy for that to keep
		691	pack ids stable despite refresh, which would also solve clones which could then lazy-load.

git-features/src/parallel/in_parallel.rs+4−4

 pub fn in_parallel<I, S, O, R>(
     input: impl Iterator<Item = I> + Send,
     thread_limit: Option<usize>,
-    new_thread_state: impl Fn(usize) -> S + Send + Sync,
+    new_thread_state: impl Fn(usize) -> S + Send + Clone,
-    consume: impl Fn(I, &mut S) -> O + Send + Sync,
+    consume: impl Fn(I, &mut S) -> O + Send + Clone,
     mut reducer: R,
 ) -> Result<<R as Reduce>::Output, <R as Reduce>::Error>
 where
     O: Send,
 {
     let num_threads = num_threads(thread_limit);
-    let new_thread_state = &new_thread_state;
-    let consume = &consume;
     crossbeam_utils::thread::scope(move |s| {
         let receive_result = {
             let (send_input, receive_input) = crossbeam_channel::bounded::<I>(num_threads);
                 s.spawn({
                     let send_result = send_result.clone();
                     let receive_input = receive_input.clone();
+                    let new_thread_state = new_thread_state.clone();
+                    let consume = consume.clone();
                     move |_| {
                         let mut state = new_thread_state(thread_id);
                         for item in receive_input {

git-features/src/parallel/mod.rs+2−2

@@ -133,8 +133,8 @@ pub fn in_parallel_if<I, S, O, R>( · 132 unmodified lines
133	condition: impl FnOnce() -> bool,	133	condition: impl FnOnce() -> bool,
134	input: impl Iterator<Item = I> + Send,	134	input: impl Iterator<Item = I> + Send,
135	thread_limit: Option<usize>,	135	thread_limit: Option<usize>,
136	new_thread_state: impl Fn(usize) -> S + Send + Sync,	136	new_thread_state: impl Fn(usize) -> S + Send + Clone,
137	consume: impl Fn(I, &mut S) -> O + Send + Sync,	137	consume: impl Fn(I, &mut S) -> O + Send + Clone,
138	reducer: R,	138	reducer: R,
139	) -> Result<<R as Reduce>::Output, <R as Reduce>::Error>	139	) -> Result<<R as Reduce>::Output, <R as Reduce>::Error>
140	where	140	where

git-features/src/parallel/reduce.rs+7−13

     impl<InputIter, ConsumeFn, Reduce, I, O, S> Stepwise<InputIter, ConsumeFn, S, Reduce>
     where
-        InputIter: Iterator<Item = I> + Send,
+        InputIter: Iterator<Item = I>,
-        ConsumeFn: Fn(I, &mut S) -> O + Send + Sync,
+        ConsumeFn: Fn(I, &mut S) -> O,
         Reduce: super::Reduce<Input = O>,
-        I: Send,
-        O: Send,
     {
         /// Instantiate a new iterator.
         /// For a description of parameters, see [`in_parallel()`][crate::parallel::in_parallel()].
             reducer: Reduce,
         ) -> Self
         where
-            ThreadStateFn: Fn(usize) -> S + Send + Sync,
+            ThreadStateFn: Fn(usize) -> S,
         {
             Stepwise {
                 input,
     impl<InputIter, ConsumeFn, ThreadState, Reduce, I, O> Iterator for Stepwise<InputIter, ConsumeFn, ThreadState, Reduce>
     where
-        InputIter: Iterator<Item = I> + Send,
+        InputIter: Iterator<Item = I>,
-        ConsumeFn: Fn(I, &mut ThreadState) -> O + Send + Sync,
+        ConsumeFn: Fn(I, &mut ThreadState) -> O,
         Reduce: super::Reduce<Input = O>,
-        I: Send,
-        O: Send,
     {
         type Item = Result<Reduce::FeedProduce, Reduce::Error>;
     impl<InputIter, ConsumeFn, R, I, O, S> super::Finalize for Stepwise<InputIter, ConsumeFn, S, R>
     where
-        InputIter: Iterator<Item = I> + Send,
+        InputIter: Iterator<Item = I>,
-        ConsumeFn: Fn(I, &mut S) -> O + Send + Sync,
+        ConsumeFn: Fn(I, &mut S) -> O,
         R: super::Reduce<Input = O>,
-        I: Send,
-        O: Send,
     {
         type Reduce = R;

git-pack/src/data/output/count/objects/mod.rs+2−2

@@ -39,7 +39,7 @@ pub type Result<E1, E2> = std::result::Result<(Vec<output::Count>, Outcome), Err · 38 unmodified lines
39	/// * more configuration	39	/// * more configuration
40	pub fn objects<Find, Iter, IterErr, Oid, PackCache, ObjectCache>(	40	pub fn objects<Find, Iter, IterErr, Oid, PackCache, ObjectCache>(
41	db: Find,	41	db: Find,
42	make_caches: impl Fn() -> (PackCache, ObjectCache) + Send + Sync,	42	make_caches: impl Fn() -> (PackCache, ObjectCache) + Send + Clone,
43	objects_ids: Iter,	43	objects_ids: Iter,
44	progress: impl Progress,	44	progress: impl Progress,
45	should_interrupt: &AtomicBool,	45	should_interrupt: &AtomicBool,
@@ -50,7 +50,7 @@ pub fn objects<Find, Iter, IterErr, Oid, PackCache, ObjectCache>( · 4 unmodified lines
50	}: Options,	50	}: Options,
51	) -> Result<find::existing::Error<Find::Error>, IterErr>	51	) -> Result<find::existing::Error<Find::Error>, IterErr>
52	where	52	where
53	Find: crate::Find + Send + Sync,	53	Find: crate::Find + Send + Clone,
54	<Find as crate::Find>::Error: Send,	54	<Find as crate::Find>::Error: Send,
55	Iter: Iterator<Item = std::result::Result<Oid, IterErr>> + Send,	55	Iter: Iterator<Item = std::result::Result<Oid, IterErr>> + Send,
56	Oid: Into<ObjectId> + Send,	56	Oid: Into<ObjectId> + Send,

git-pack/src/data/output/entry/iter_from_counts.rs+3−3

@@ -42,7 +42,7 @@ use crate::data::{output, output::ChunkId}; · 41 unmodified lines
42	pub fn iter_from_counts<Find, Cache>(	42	pub fn iter_from_counts<Find, Cache>(
43	mut counts: Vec<output::Count>,	43	mut counts: Vec<output::Count>,
44	db: Find,	44	db: Find,
45	make_cache: impl Fn() -> Cache + Send + Sync + 'static,	45	make_cache: impl Fn() -> Cache + Send + Clone + Sync + 'static,
46	mut progress: impl Progress,	46	mut progress: impl Progress,
47	Options {	47	Options {
48	version,	48	version,
@@ -54,7 +54,7 @@ pub fn iter_from_counts<Find, Cache>( · 5 unmodified lines
54	) -> impl Iterator<Item = Result<(ChunkId, Vec<output::Entry>), Error<Find::Error>>>	54	) -> impl Iterator<Item = Result<(ChunkId, Vec<output::Entry>), Error<Find::Error>>>
55	+ parallel::reduce::Finalize<Reduce = reduce::Statistics<Error<Find::Error>>>	55	+ parallel::reduce::Finalize<Reduce = reduce::Statistics<Error<Find::Error>>>
56	where	56	where
57	Find: crate::Find + Send + Sync + 'static,	57	Find: crate::Find + Send + Clone + 'static,
58	<Find as crate::Find>::Error: Send,	58	<Find as crate::Find>::Error: Send,
59	Cache: crate::cache::DecodeEntry,	59	Cache: crate::cache::DecodeEntry,
60	{	60	{
@@ -78,7 +78,7 @@ where · 17 unmodified lines
78	{	78	{
79	let progress = Arc::clone(&progress);	79	let progress = Arc::clone(&progress);
80	let counts = &counts;	80	let counts = &counts;
81	let db = &db;	81	let db = db.clone();
82	move \|chunk_range, buf\| {	82	move \|chunk_range, buf\| {
83	let chunk = {	83	let chunk = {
84	let c = &counts[chunk_range];	84	let c = &counts[chunk_range];

unify trait bounds for parallel code: prefer Clone over Sync (#259)

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code