chore(fflonk): allocator feature

crates/fflonk/Cargo.toml

@@ -12,7 +12,7 @@ description = "CUDA implementation of the fflonk prover"
 exclude = ["/data"]
 
 [dependencies]
-fflonk-cpu = {workspace = true}
+fflonk-cpu = {workspace = true, optional = true}
 circuit_definitions.workspace = true
 gpu-ffi.workspace = true
 rand = "0.4"
@@ -24,5 +24,6 @@ serde_json = "1"
 serde_derive = "1"
 
 [features]
-default = []
+default = ["fflonk-cpu"]
 sanity = []
+allocator = ["fflonk-cpu/allocator"]

crates/fflonk/src/convenience.rs

@@ -3,7 +3,7 @@ use bellman::{
     kate_commitment::{Crs, CrsForMonomialForm},
     plonk::{
         better_better_cs::cs::{
-            Circuit, SynthesisModeGenerateSetup, SynthesisModeProve, SynthesisModeTesting,
+            Circuit, SynthesisModeProve, SynthesisModeTesting,
         },
         commitments::transcript::keccak_transcript::RollingKeccakTranscript,
     },
@@ -14,7 +14,7 @@ use circuit_definitions::circuit_definitions::aux_layer::{
 };
 use fflonk::{FflonkAssembly, L1_VERIFIER_DOMAIN_SIZE_LOG};
 
-pub type FflonkSnarkVerifierCircuitDeviceSetup<A> =
+pub type FflonkSnarkVerifierCircuitDeviceSetup<A: HostAllocator = GlobalHost> =
     FflonkDeviceSetup<Bn256, FflonkSnarkVerifierCircuit, A>;
 
 use super::*;
@@ -190,7 +190,7 @@ pub fn precompute_and_save_setup_and_vk_for_fflonk_snark_circuit(
 
     println!("Generating fflonk setup data on the device");
     let device_setup =
-        FflonkSnarkVerifierCircuitDeviceSetup::create_setup_on_device(&circuit).unwrap();
+        FflonkSnarkVerifierCircuitDeviceSetup::<GlobalHost>::create_setup_on_device(&circuit).unwrap();
     let setup_file_path = format!("{}/final_snark_device_setup.bin", path);
     println!("Saving setup into file {setup_file_path}");
     let device_setup_file = std::fs::File::create(&setup_file_path).unwrap();

crates/fflonk/src/lib.rs

@@ -75,4 +75,4 @@ pub type FflonkSnarkVerifierCircuitVK = FflonkVerificationKey<Bn256, FflonkSnark
 pub type FflonkSnarkVerifierCircuitProof = FflonkProof<Bn256, FflonkSnarkVerifierCircuit>;
 pub type FflonkSnarkVerifierCircuitSetup = FflonkSetup<Bn256, FflonkSnarkVerifierCircuit>;
 
-pub use allocator::{GlobalHost, HostAllocator};
+pub use allocator::{HostAllocator, GlobalHost};

crates/fflonk/src/setup.rs

@@ -254,25 +254,24 @@ impl<E: Engine, C: Circuit<E>, A: HostAllocator> FflonkDeviceSetup<E, C, A> {
         assert_eq!(num_polys, 5);
         let mut main_gate_selector_monomials = vec![];
         for _ in 0..num_polys {
-            let num_values = reader.read_u64::<BigEndian>()?;
-            let mut coeffs = Vec::with_capacity_in(num_values as usize, A::default());
-            for _ in 0..num_values {
-                let el = read_fr(&mut reader)?;
-                coeffs.push(el);
-            }
+            let coeffs = read_raw_fr_vec::<_, _, A>(&mut reader)?;
             main_gate_selector_monomials.push(coeffs);
         }
 
         let num_polys = reader.read_u64::<BigEndian>()?;
         assert_eq!(num_polys, 3);
         let mut variable_indexes = vec![];
         for _ in 0..num_polys {
-            let num_values = reader.read_u64::<BigEndian>()?;
-            let mut indexes = Vec::with_capacity_in(num_values as usize, A::default());
-            for _ in 0..num_values {
-                let el = reader.read_u32::<BigEndian>()?;
-                indexes.push(el);
-            }
+            let num_values = reader.read_u64::<BigEndian>()? as usize;
+            let mut indexes = Vec::with_capacity_in(num_values, A::default());
+            let indexes_buf = unsafe {
+                indexes.set_len(num_values);
+                std::slice::from_raw_parts_mut(
+                    indexes.as_mut_ptr() as *mut u8,
+                    num_values * std::mem::size_of::<u32>(),
+                )
+            };
+            reader.read_exact(indexes_buf)?;
             variable_indexes.push(indexes);
         }
 
@@ -293,14 +292,18 @@ impl<E: Engine, C: Circuit<E>, A: HostAllocator> FflonkDeviceSetup<E, C, A> {
         use byteorder::{BigEndian, WriteBytesExt};
         writer.write_u64::<BigEndian>(self.main_gate_selector_monomials.len() as u64)?;
         for mon in self.main_gate_selector_monomials.iter() {
-            write_fr_vec(&mon, &mut writer)?;
+            write_raw_fr_slice(&mon, &mut writer)?;
         }
         writer.write_u64::<BigEndian>(self.variable_indexes.len() as u64)?;
         for col in self.variable_indexes.iter() {
             writer.write_u64::<BigEndian>(col.len() as u64)?;
-            for el in col {
-                writer.write_u32::<BigEndian>(*el)?;
-            }
+            let buf = unsafe {
+                std::slice::from_raw_parts(
+                    col.as_ptr() as *mut u8,
+                    col.len() * std::mem::size_of::<u32>(),
+                )
+            };
+            writer.write_all(buf)?;
         }
         write_curve_affine(&self.c0_commitment, &mut writer)?;
         write_curve_affine(&self.g2_elems[0], &mut writer)?;
@@ -320,9 +323,7 @@ pub fn read_raw_fr_vec<F: PrimeField, R: std::io::Read, A: Allocator + Default>(
             values.as_mut_ptr() as *mut u8,
             num_values * std::mem::size_of::<F>(),
         );
-        // src.read_exact(buf)?;
-        let mut dst = &mut buf[..];
-        std::io::copy(&mut src, &mut dst)?;
+        src.read_exact(buf)?;
     }
 
     Ok(values)
@@ -341,9 +342,7 @@ pub fn write_raw_fr_slice<F: PrimeField, W: std::io::Write>(
             src_values.as_ptr() as *mut u8,
             num_values * std::mem::size_of::<F>(),
         );
-        let mut reader = &buf[..];
-        // dst.write_all(buf)?;
-        std::io::copy(&mut reader, &mut dst)?;
+        dst.write_all(buf)?;
     }
 
     Ok(())