Use prelude Ord::min/max instead of from cmp

(cherry picked from commit f3dbb42)

Author: cuviper

rayon-core/src/scope/test.rs

@@ -3,7 +3,6 @@ use crate::ThreadPoolBuilder;
 use crate::{scope, scope_fifo, Scope, ScopeFifo};
 use rand::{Rng, SeedableRng};
 use rand_xorshift::XorShiftRng;
-use std::cmp;
 use std::iter::once;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Barrier, Mutex};
@@ -182,7 +181,7 @@ fn the_final_countdown<'scope>(
     let diff = if p > q { p - q } else { q - p };
 
     let mut data = max.lock().unwrap();
-    *data = cmp::max(diff, *data);
+    *data = Ord::max(diff, *data);
 
     if n > 0 {
         s.spawn(move |s| the_final_countdown(s, bottom_of_stack, max, n - 1));

rayon-core/src/sleep/counters.rs

@@ -166,7 +166,7 @@ impl AtomicCounters {
         // Current heuristic: whenever an inactive thread goes away, if
         // there are any sleeping threads, wake 'em up.
         let sleeping_threads = old_value.sleeping_threads();
-        std::cmp::min(sleeping_threads, 2)
+        Ord::min(sleeping_threads, 2)
     }
 
     /// Subtracts a sleeping thread. This cannot fail, but it is only

rayon-core/src/sleep/mod.rs

@@ -328,10 +328,10 @@ impl Sleep {
         // -- clearly the existing idle jobs aren't enough. Otherwise,
         // check to see if we have enough idle workers.
         if !queue_was_empty {
-            let num_to_wake = std::cmp::min(num_jobs, num_sleepers);
+            let num_to_wake = Ord::min(num_jobs, num_sleepers);
             self.wake_any_threads(num_to_wake);
         } else if num_awake_but_idle < num_jobs {
-            let num_to_wake = std::cmp::min(num_jobs - num_awake_but_idle, num_sleepers);
+            let num_to_wake = Ord::min(num_jobs - num_awake_but_idle, num_sleepers);
             self.wake_any_threads(num_to_wake);
         }
     }