README.md

@@ -65,17 +65,13 @@ algorithms in Rust and benchmark them. Let the battle begin.
 
 - `single thread`: No multi-threading or any optimization of any kind. Used as
   a reference.
-- `multi threads`: Manual multi-threading but no optimization of any kind. Used
-  as a reference.
-- `lpt`: Manual multi-threading. Tasks are sorted so the shortest ones are
-  executed first. This is the [longest-processing-time-first algorithm][lpt].
 - `rayon`: Multi-threading provided by the `rayon` crate, but no optimization
   of any kind. Used as a reference.
 - `rayon sorted`: Multi-threading provided by the `rayon` crate. Tasks are
   sorted so the shortest ones are executed first.
 - `rayon sorted reverse`: Multi-threading provided by the `rayon` crate. Tasks
   are sorted so the longest ones are executed first. This should behave as an
-  LPT.
+  [LPT][lpt].
 - `rayon sorted reverse`: Similar to `rayon sorted reverse`, but tasks are
   sorted from shortest to longest and are then iterated in the reverse order.
 

benches/job_scheduling.rs

@@ -6,8 +6,6 @@ use rust_job_scheduling::Task;
 const TEST_DATA: &[(&str, &[Task])] = &[("10 tasks", T_10), ("500 tasks", T_500)];
 const TEST_FUNCS: &[(&str, &dyn Fn(&[Task]))] = &[
 	("single thread", &single_thread),
-	("multi threads", &multi_threads),
-	("lpt", &lpt),
 	("rayon", &rayon),
 	("rayon sorted", &rayon_sorted),
 	("rayon sorted reverse", &rayon_sorted_reverse),

src/algorithm.rs

@@ -1,7 +1,5 @@
-mod lpt;
 mod rayon;
 mod single_thread;
 
-pub use lpt::*;
 pub use rayon::*;
 pub use single_thread::single_thread;

src/algorithm/lpt.rs

@@ -1,42 +0,0 @@
-use crate::Task;
-use std::sync::{Arc, Mutex};
-use std::thread;
-
-pub fn lpt(data: &[Task]) {
-	let mut data = data.to_vec();
-	data.sort();
-	run_multi(data);
-}
-
-pub fn multi_threads(data: &[Task]) {
-	let data = data.to_vec();
-	run_multi(data);
-}
-
-#[inline(always)]
-fn run_multi(data: Vec<Task>) {
-	let data_mt = Arc::new(Mutex::new(data));
-	let nb_threads = thread::available_parallelism()
-		.map(|n| n.get())
-		.unwrap_or(1);
-	let mut handles = Vec::with_capacity(nb_threads);
-
-	for _ in 0..nb_threads {
-		let dt = data_mt.clone();
-		let h = thread::spawn(move || loop {
-			let mut data = dt.lock().unwrap();
-			let task = match data.pop() {
-				Some(t) => t,
-				None => {
-					break;
-				}
-			};
-			std::mem::drop(data);
-			task.execute();
-		});
-		handles.push(h);
-	}
-	for h in handles {
-		let _ = h.join();
-	}
-}