diff --git a/src/arithmetic.rs b/src/arithmetic.rs
index cf66ecd7..94753cea 100644
--- a/src/arithmetic.rs
+++ b/src/arithmetic.rs
@@ -167,13 +167,13 @@ pub fn small_multiexp<C: CurveAffine>(coeffs: &[C::Scalar], bases: &[C]) -> C::C
 pub fn best_multiexp<C: CurveAffine>(coeffs: &[C::Scalar], bases: &[C]) -> C::Curve {
     assert_eq!(coeffs.len(), bases.len());
 
-    let num_cpus = multicore::current_num_threads();
-    if coeffs.len() > num_cpus {
-        let chunk = coeffs.len() / num_cpus;
+    let num_threads = multicore::current_num_threads();
+    if coeffs.len() > num_threads {
+        let chunk = coeffs.len() / num_threads;
         let num_chunks = coeffs.chunks(chunk).len();
         let mut results = vec![C::Curve::identity(); num_chunks];
         multicore::scope(|scope| {
-            let chunk = coeffs.len() / num_cpus;
+            let chunk = coeffs.len() / num_threads;
 
             for ((coeffs, bases), acc) in coeffs
                 .chunks(chunk)
@@ -204,13 +204,13 @@ pub fn best_multiexp<C: CurveAffine>(coeffs: &[C::Scalar], bases: &[C]) -> C::Cu
 ///
 /// This will use multithreading if beneficial.
 pub fn best_fft<G: Group>(a: &mut [G], omega: G::Scalar, log_n: u32) {
-    let cpus = multicore::current_num_threads();
-    let log_cpus = log2_floor(cpus);
+    let threads = multicore::current_num_threads();
+    let log_threads = log2_floor(threads);
 
-    if log_n <= log_cpus {
+    if log_n <= log_threads {
         serial_fft(a, omega, log_n);
     } else {
-        parallel_fft(a, omega, log_n, log_cpus);
+        parallel_fft(a, omega, log_n, log_threads);
     }
 }
 
@@ -257,13 +257,13 @@ fn serial_fft<G: Group>(a: &mut [G], omega: G::Scalar, log_n: u32) {
     }
 }
 
-fn parallel_fft<G: Group>(a: &mut [G], omega: G::Scalar, log_n: u32, log_cpus: u32) {
-    assert!(log_n >= log_cpus);
+fn parallel_fft<G: Group>(a: &mut [G], omega: G::Scalar, log_n: u32, log_threads: u32) {
+    assert!(log_n >= log_threads);
 
-    let num_cpus = 1 << log_cpus;
-    let log_new_n = log_n - log_cpus;
-    let mut tmp = vec![vec![G::group_zero(); 1 << log_new_n]; num_cpus];
-    let new_omega = omega.pow(&[num_cpus as u64, 0, 0, 0]);
+    let num_threads = 1 << log_threads;
+    let log_new_n = log_n - log_threads;
+    let mut tmp = vec![vec![G::group_zero(); 1 << log_new_n]; num_threads];
+    let new_omega = omega.pow(&[num_threads as u64, 0, 0, 0]);
 
     multicore::scope(|scope| {
         let a = &*a;
@@ -277,7 +277,7 @@ fn parallel_fft<G: Group>(a: &mut [G], omega: G::Scalar, log_n: u32, log_cpus: u
                 let mut elt = G::Scalar::one();
 
                 for (i, tmp) in tmp.iter_mut().enumerate() {
-                    for s in 0..num_cpus {
+                    for s in 0..num_threads {
                         let idx = (i + (s << log_new_n)) % (1 << log_n);
                         let mut t = a[idx];
                         t.group_scale(&elt);
@@ -294,9 +294,9 @@ fn parallel_fft<G: Group>(a: &mut [G], omega: G::Scalar, log_n: u32, log_cpus: u
     });
 
     // Unshuffle
-    let mask = (1 << log_cpus) - 1;
+    let mask = (1 << log_threads) - 1;
     for (idx, a) in a.iter_mut().enumerate() {
-        *a = tmp[idx & mask][idx >> log_cpus];
+        *a = tmp[idx & mask][idx >> log_threads];
     }
 }
 
@@ -350,9 +350,9 @@ where
 /// performed over a mutable slice.
 pub fn parallelize<T: Send, F: Fn(&mut [T], usize) + Send + Sync + Clone>(v: &mut [T], f: F) {
     let n = v.len();
-    let num_cpus = multicore::current_num_threads();
-    let mut chunk = (n as usize) / num_cpus;
-    if chunk < num_cpus {
+    let num_threads = multicore::current_num_threads();
+    let mut chunk = (n as usize) / num_threads;
+    if chunk < num_threads {
         chunk = n as usize;
     }