update the toolchain (#17)

.github/workflows/ci.yaml

@@ -25,7 +25,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@master
         with:
           components: rustfmt
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2024-11-06
       - uses: Swatinem/rust-cache@v2
       - run: scripts/rust_fmt.sh --check
 
@@ -36,7 +36,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@master
         with:
           components: clippy
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2024-11-06
       - uses: Swatinem/rust-cache@v2
       - run: scripts/clippy.sh
 
@@ -46,17 +46,17 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2024-11-06
       - uses: Swatinem/rust-cache@v2
-      - run: cargo +nightly-2024-01-04 doc
+      - run: cargo +nightly-2024-11-06 doc
 
   run-wasm32-wasi-tests:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2024-11-06
           targets: wasm32-wasi
       - uses: taiki-e/install-action@v2
         with:
@@ -73,19 +73,19 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2024-11-06
       - uses: Swatinem/rust-cache@v2
-      - run: cargo +nightly-2024-01-04 test
+      - run: cargo +nightly-2024-11-06 test
 
   run-slow-tests:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2024-11-06
       - uses: Swatinem/rust-cache@v2
-      - run: cargo +nightly-2024-01-04 test --release -- --ignored
+      - run: cargo +nightly-2024-11-06 test --release -- --ignored
 
   udeps:
     runs-on: ubuntu-latest
@@ -94,7 +94,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@master
         name: "Rust Toolchain Setup"
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2024-11-06
       - uses: Swatinem/rust-cache@v2
         id: "cache-cargo"
       - if: ${{ steps.cache-cargo.outputs.cache-hit != 'true' }}
@@ -103,7 +103,7 @@ jobs:
           wget -O - -c https://github.com/est31/cargo-udeps/releases/download/v0.1.49/cargo-udeps-v0.1.49-x86_64-unknown-linux-gnu.tar.gz | tar -xz
           cargo-udeps-*/cargo-udeps udeps
         env:
-          RUSTUP_TOOLCHAIN: nightly-2024-01-04
+          RUSTUP_TOOLCHAIN: nightly-2024-11-06
 
   all-tests:
     runs-on: ubuntu-latest

crates/prover/Cargo.toml

@@ -14,7 +14,6 @@ tiny_blowup = []
 [dependencies]
 bytemuck = { workspace = true, features = ["derive", "extern_crate_alloc"] }
 cfg-if = "1.0.0"
-downcast-rs = "1.2"
 educe.workspace = true
 hex.workspace = true
 itertools.workspace = true

crates/prover/benches/fft.rs

@@ -29,7 +29,7 @@ pub fn simd_ifft(c: &mut Criterion) {
                 || values.clone().data,
                 |mut data| unsafe {
                     ifft(
-                        transmute(data.as_mut_ptr()),
+                        transmute::<*mut PackedBaseField, *mut u32>(data.as_mut_ptr()),
                         black_box(&twiddle_dbls_refs),
                         black_box(log_size as usize),
                     );
@@ -58,7 +58,7 @@ pub fn simd_ifft_parts(c: &mut Criterion) {
             || values.clone().data,
             |mut values| unsafe {
                 ifft_vecwise_loop(
-                    transmute(values.as_mut_ptr()),
+                    transmute::<*mut PackedBaseField, *mut u32>(values.as_mut_ptr()),
                     black_box(&twiddle_dbls_refs),
                     black_box(9),
                     black_box(0),
@@ -72,7 +72,7 @@ pub fn simd_ifft_parts(c: &mut Criterion) {
             || values.clone().data,
             |mut values| unsafe {
                 ifft3_loop(
-                    transmute(values.as_mut_ptr()),
+                    transmute::<*mut PackedBaseField, *mut u32>(values.as_mut_ptr()),
                     black_box(&twiddle_dbls_refs[3..]),
                     black_box(7),
                     black_box(4),
@@ -91,7 +91,7 @@ pub fn simd_ifft_parts(c: &mut Criterion) {
             || transpose_values.clone().data,
             |mut values| unsafe {
                 transpose_vecs(
-                    transmute(values.as_mut_ptr()),
+                    transmute::<*mut PackedBaseField, *mut u32>(values.as_mut_ptr()),
                     black_box(TRANSPOSE_LOG_SIZE as usize - 4),
                 )
             },
@@ -115,8 +115,10 @@ pub fn simd_rfft(c: &mut Criterion) {
             target.set_len(values.data.len());
 
             fft(
-                black_box(transmute(values.data.as_ptr())),
-                transmute(target.as_mut_ptr()),
+                black_box(transmute::<*const PackedBaseField, *const u32>(
+                    values.data.as_ptr(),
+                )),
+                transmute::<*mut PackedBaseField, *mut u32>(target.as_mut_ptr()),
                 black_box(&twiddle_dbls_refs),
                 black_box(LOG_SIZE as usize),
             )

crates/prover/benches/merkle.rs

@@ -21,7 +21,7 @@ fn bench_sha256_merkle<B: MerkleOps<Sha256MerkleHasher>>(c: &mut Criterion, id:
     let n_elements = 1 << (LOG_N_COLS + LOG_N_ROWS);
     group.throughput(Throughput::Elements(n_elements));
     group.throughput(Throughput::Bytes(N_BYTES_FELT as u64 * n_elements));
-    group.bench_function(&format!("{id} merkle"), |b| {
+    group.bench_function(format!("{id} merkle"), |b| {
         b.iter_with_large_drop(|| B::commit_on_layer(LOG_N_ROWS, None, &col_refs))
     });
 }

crates/prover/src/constraint_framework/assert.rs

@@ -24,7 +24,7 @@ impl<'a> AssertEvaluator<'a> {
         }
     }
 }
-impl<'a> EvalAtRow for AssertEvaluator<'a> {
+impl EvalAtRow for AssertEvaluator<'_> {
     type F = BaseField;
     type EF = SecureField;
 

crates/prover/src/constraint_framework/logup.rs

@@ -236,7 +236,7 @@ pub struct LogupColGenerator<'a> {
     /// Numerator expressions (i.e. multiplicities) being generated for the current lookup.
     numerator: SecureColumnByCoords<SimdBackend>,
 }
-impl<'a> LogupColGenerator<'a> {
+impl LogupColGenerator<'_> {
     /// Write a fraction to the column at a row.
     pub fn write_frac(
         &mut self,

crates/prover/src/constraint_framework/point.rs

@@ -31,7 +31,7 @@ impl<'a> PointEvaluator<'a> {
         }
     }
 }
-impl<'a> EvalAtRow for PointEvaluator<'a> {
+impl EvalAtRow for PointEvaluator<'_> {
     type F = SecureField;
     type EF = SecureField;
 

crates/prover/src/constraint_framework/simd_domain.rs

@@ -51,7 +51,7 @@ impl<'a> SimdDomainEvaluator<'a> {
         }
     }
 }
-impl<'a> EvalAtRow for SimdDomainEvaluator<'a> {
+impl EvalAtRow for SimdDomainEvaluator<'_> {
     type F = VeryPackedBaseField;
     type EF = VeryPackedSecureField;
 

crates/prover/src/core/air/accumulation.rs

@@ -161,7 +161,7 @@ pub struct ColumnAccumulator<'a, B: Backend> {
     pub random_coeff_powers: Vec<SecureField>,
     pub col: &'a mut SecureColumnByCoords<B>,
 }
-impl<'a> ColumnAccumulator<'a, CpuBackend> {
+impl ColumnAccumulator<'_, CpuBackend> {
     pub fn accumulate(&mut self, index: usize, evaluation: SecureField) {
         let val = self.col.at(index) + evaluation;
         self.col.set(index, val);

crates/prover/src/core/air/components.rs

@@ -12,7 +12,7 @@ use crate::core::{ColumnVec, InteractionElements, LookupValues};
 
 pub struct Components<'a>(pub Vec<&'a dyn Component>);
 
-impl<'a> Components<'a> {
+impl Components<'_> {
     pub fn composition_log_degree_bound(&self) -> u32 {
         self.0
             .iter()
@@ -60,7 +60,7 @@ impl<'a> Components<'a> {
 
 pub struct ComponentProvers<'a, B: Backend>(pub Vec<&'a dyn ComponentProver<B>>);
 
-impl<'a, B: Backend> ComponentProvers<'a, B> {
+impl<B: Backend> ComponentProvers<'_, B> {
     pub fn components(&self) -> Components<'_> {
         Components(self.0.iter().map(|c| *c as &dyn Component).collect_vec())
     }

crates/prover/src/core/backend/cpu/lookups/gkr.rs

@@ -290,7 +290,7 @@ enum MleExpr<'a, F: Field> {
     Mle(&'a Mle<CpuBackend, F>),
 }
 
-impl<'a, F: Field> Index<usize> for MleExpr<'a, F> {
+impl<F: Field> Index<usize> for MleExpr<'_, F> {
     type Output = F;
 
     fn index(&self, index: usize) -> &F {

crates/prover/src/core/backend/simd/bit_reverse.rs

@@ -168,7 +168,7 @@ mod tests {
 
         let res = bit_reverse16(values.data.try_into().unwrap());
 
-        assert_eq!(res.map(PackedM31::to_array).flatten(), expected);
+        assert_eq!(res.map(PackedM31::to_array).as_flattened(), expected);
     }
 
     #[test]

crates/prover/src/core/backend/simd/circle.rs

@@ -85,10 +85,7 @@ impl SimdBackend {
 
     // Generates twiddle steps for efficiently computing the twiddles.
     // steps[i] = t_i/(t_0*t_1*...*t_i-1).
-    fn twiddle_steps<F: Field>(mappings: &[F]) -> Vec<F>
-    where
-        F: FieldExpOps,
-    {
+    fn twiddle_steps<F: Field + FieldExpOps>(mappings: &[F]) -> Vec<F> {
         let mut denominators: Vec<F> = vec![mappings[0]];
 
         for i in 1..mappings.len() {
@@ -151,7 +148,7 @@ impl PolyOps for SimdBackend {
         // Safe because [PackedBaseField] is aligned on 64 bytes.
         unsafe {
             ifft::ifft(
-                transmute(values.data.as_mut_ptr()),
+                transmute::<*mut PackedBaseField, *mut u32>(values.data.as_mut_ptr()),
                 &twiddles,
                 log_size as usize,
             );
@@ -254,8 +251,8 @@ impl PolyOps for SimdBackend {
             // FFT from the coefficients buffer to the values chunk.
             unsafe {
                 rfft::fft(
-                    transmute(poly.coeffs.data.as_ptr()),
-                    transmute(
+                    transmute::<*const PackedBaseField, *const u32>(poly.coeffs.data.as_ptr()),
+                    transmute::<*mut PackedBaseField, *mut u32>(
                         values[i << (fft_log_size - LOG_N_LANES)
                             ..(i + 1) << (fft_log_size - LOG_N_LANES)]
                             .as_mut_ptr(),

crates/prover/src/core/backend/simd/column.rs

@@ -200,7 +200,7 @@ impl FromIterator<PackedCM31> for CM31Column {
 /// A mutable slice of a BaseColumn.
 pub struct BaseColumnMutSlice<'a>(pub &'a mut [PackedBaseField]);
 
-impl<'a> BaseColumnMutSlice<'a> {
+impl BaseColumnMutSlice<'_> {
     pub fn at(&self, index: usize) -> BaseField {
         self.0[index / N_LANES].to_array()[index % N_LANES]
     }
@@ -292,7 +292,7 @@ impl FromIterator<PackedSecureField> for SecureColumn {
 /// A mutable slice of a SecureColumnByCoords.
 pub struct SecureColumnByCoordsMutSlice<'a>(pub [BaseColumnMutSlice<'a>; SECURE_EXTENSION_DEGREE]);
 
-impl<'a> SecureColumnByCoordsMutSlice<'a> {
+impl SecureColumnByCoordsMutSlice<'_> {
     /// # Safety
     ///
     /// `vec_index` must be a valid index.

crates/prover/src/core/backend/simd/fft/ifft.rs

@@ -8,6 +8,7 @@ use super::{
     compute_first_twiddles, mul_twiddle, transpose_vecs, CACHED_FFT_LOG_SIZE, MIN_FFT_LOG_SIZE,
 };
 use crate::core::backend::simd::m31::{PackedBaseField, LOG_N_LANES};
+use crate::core::backend::simd::utils::UnsafeMut;
 use crate::core::circle::Coset;
 use crate::core::fields::FieldExpOps;
 use crate::core::utils::bit_reverse;
@@ -81,7 +82,9 @@ pub unsafe fn ifft_lower_with_vecwise(
 
     assert_eq!(twiddle_dbl[0].len(), 1 << (log_size - 2));
 
+    let values = UnsafeMut(values);
     for index_h in 0..1 << (log_size - fft_layers) {
+        let values = values.get();
         ifft_vecwise_loop(values, twiddle_dbl, fft_layers - VECWISE_FFT_BITS, index_h);
         for layer in (VECWISE_FFT_BITS..fft_layers).step_by(3) {
             match fft_layers - layer {
@@ -131,7 +134,9 @@ pub unsafe fn ifft_lower_without_vecwise(
 ) {
     assert!(log_size >= LOG_N_LANES as usize);
 
+    let values = UnsafeMut(values);
     for index_h in 0..1 << (log_size - fft_layers - LOG_N_LANES as usize) {
+        let values = values.get();
         for layer in (0..fft_layers).step_by(3) {
             let fixed_layer = layer + LOG_N_LANES as usize;
             match fft_layers - layer {
@@ -589,7 +594,7 @@ mod tests {
         let mut res = values;
         unsafe {
             ifft3(
-                transmute(res.as_mut_ptr()),
+                transmute::<*mut PackedBaseField, *mut u32>(res.as_mut_ptr()),
                 0,
                 LOG_N_LANES as usize,
                 twiddles0_dbl,
@@ -655,7 +660,7 @@ mod tests {
             [val0.to_array(), val1.to_array()].concat()
         };
 
-        assert_eq!(res, ground_truth_ifft(domain, values.flatten()));
+        assert_eq!(res, ground_truth_ifft(domain, values.as_flattened()));
     }
 
     #[test]
@@ -669,7 +674,7 @@ mod tests {
             let mut res = values.iter().copied().collect::<BaseColumn>();
             unsafe {
                 ifft_lower_with_vecwise(
-                    transmute(res.data.as_mut_ptr()),
+                    transmute::<*mut PackedBaseField, *mut u32>(res.data.as_mut_ptr()),
                     &twiddle_dbls.iter().map(|x| x.as_slice()).collect_vec(),
                     log_size as usize,
                     log_size as usize,
@@ -691,11 +696,14 @@ mod tests {
             let mut res = values.iter().copied().collect::<BaseColumn>();
             unsafe {
                 ifft(
-                    transmute(res.data.as_mut_ptr()),
+                    transmute::<*mut PackedBaseField, *mut u32>(res.data.as_mut_ptr()),
                     &twiddle_dbls.iter().map(|x| x.as_slice()).collect_vec(),
                     log_size as usize,
                 );
-                transpose_vecs(transmute(res.data.as_mut_ptr()), log_size as usize - 4);
+                transpose_vecs(
+                    transmute::<*mut PackedBaseField, *mut u32>(res.data.as_mut_ptr()),
+                    log_size as usize - 4,
+                );
             }
 
             assert_eq!(res.to_cpu(), ground_truth_ifft(domain, &values));

crates/prover/src/core/backend/simd/fft/mod.rs

@@ -102,19 +102,19 @@ fn mul_twiddle(v: PackedBaseField, twiddle_dbl: u32x16) -> PackedBaseField {
     // TODO: Come up with a better approach than `cfg`ing on target_feature.
     // TODO: Ensure all these branches get tested in the CI.
     cfg_if::cfg_if! {
-        if #[cfg(all(target_feature = "neon", target_arch = "aarch64"))] {
+        if #[cfg(all(target_arch = "aarch64", target_feature = "neon"))] {
             // TODO: For architectures that when multiplying require doubling then the twiddles
             // should be precomputed as double. For other architectures, the twiddle should be
             // precomputed without doubling.
-            crate::core::backend::simd::m31::_mul_doubled_neon(v, twiddle_dbl)
-        } else if #[cfg(all(target_feature = "simd128", target_arch = "wasm32"))] {
-            crate::core::backend::simd::m31::_mul_doubled_wasm(v, twiddle_dbl)
+            crate::core::backend::simd::m31::mul_doubled_neon(v, twiddle_dbl)
+        } else if #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))] {
+            crate::core::backend::simd::m31::mul_doubled_wasm(v, twiddle_dbl)
         } else if #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))] {
-            crate::core::backend::simd::m31::_mul_doubled_avx512(v, twiddle_dbl)
+            crate::core::backend::simd::m31::mul_doubled_avx512(v, twiddle_dbl)
         } else if #[cfg(all(target_arch = "x86_64", target_feature = "avx2"))] {
-            crate::core::backend::simd::m31::_mul_doubled_avx2(v, twiddle_dbl)
+            crate::core::backend::simd::m31::mul_doubled_avx2(v, twiddle_dbl)
         } else {
-            crate::core::backend::simd::m31::_mul_doubled_simd(v, twiddle_dbl)
+            crate::core::backend::simd::m31::mul_doubled_simd(v, twiddle_dbl)
         }
     }
 }