Merge pull request #13 from lita-xyz/carlo/SyncSend

Sync and Send trait implementation

Author: morganthomas

challenger/src/duplex_challenger.rs

@@ -18,6 +18,21 @@ where
     permutation: P,
 }
 
+impl<F, P, const WIDTH: usize> Default for DuplexChallenger<F, P, WIDTH>
+where
+    F: Field,
+    P: CryptographicPermutation<[F; WIDTH]> + Default,
+{
+    fn default() -> Self {
+        Self {
+            sponge_state: [F::zero(); WIDTH],
+            input_buffer: Vec::new(),
+            output_buffer: Vec::new(),
+            permutation: P::default(),
+        }
+    }
+}
+
 impl<F, P, const WIDTH: usize> DuplexChallenger<F, P, WIDTH>
 where
     F: Copy,

commit/src/adapters/extension_mmcs.rs

@@ -13,6 +13,20 @@ pub struct ExtensionMmcs<F, EF, InnerMmcs> {
     _phantom: PhantomData<(F, EF)>,
 }
 
+impl<F, EF, InnerMmcs> Default for ExtensionMmcs<F, EF, InnerMmcs>
+where
+    F: Field,
+    EF: ExtensionField<F>,
+    InnerMmcs: Mmcs<F> + Default,
+{
+    fn default() -> Self {
+        Self {
+            inner: InnerMmcs::default(),
+            _phantom: PhantomData::<(F, EF)>,
+        }
+    }
+}
+
 impl<F, EF, InnerMmcs> ExtensionMmcs<F, EF, InnerMmcs> {
     pub fn new(inner: InnerMmcs) -> Self {
         Self {

commit/src/mmcs.rs

@@ -20,9 +20,9 @@ use serde::Serialize;
 /// matrices. Other MMCSs may be virtual combinations of child MMCSs, or may be constructed in a
 /// streaming manner.
 pub trait Mmcs<T>: Clone {
-    type ProverData;
+    type ProverData: Clone;
     type Commitment: Clone + Serialize + DeserializeOwned;
-    type Proof: Serialize + DeserializeOwned;
+    type Proof: Serialize + DeserializeOwned + Clone;
     type Error: Debug;
     type Mat<'a>: MatrixRows<T> + Sync
     where

commit/src/pcs.rs

@@ -22,10 +22,10 @@ pub trait Pcs<Val: Field, In: MatrixRows<Val>> {
     type Commitment: Clone + Serialize + DeserializeOwned;
 
     /// Data that the prover stores for committed polynomials, to help the prover with opening.
-    type ProverData;
+    type ProverData: Clone;
 
     /// The opening argument.
-    type Proof: Serialize + DeserializeOwned;
+    type Proof: Serialize + DeserializeOwned + Clone;
 
     type Error: Debug;
 

field-testing/src/bench_func.rs

@@ -13,7 +13,7 @@ where
 {
     let mut rng = rand::thread_rng();
     let x = rng.gen::<F>();
-    c.bench_function(&format!("{} square", name), |b| {
+    c.bench_function(&format!("{name} square"), |b| {
         b.iter(|| black_box(black_box(x).square()))
     });
 }
@@ -24,7 +24,7 @@ where
 {
     let mut rng = rand::thread_rng();
     let x = rng.gen::<F>();
-    c.bench_function(&format!("{} inv", name), |b| {
+    c.bench_function(&format!("{name} inv"), |b| {
         b.iter(|| black_box(black_box(x)).inverse())
     });
 }
@@ -36,7 +36,7 @@ where
     let mut rng = rand::thread_rng();
     let x = rng.gen::<F>();
     let y = rng.gen::<F>();
-    c.bench_function(&format!("{} mul", name), |b| {
+    c.bench_function(&format!("{name} mul"), |b| {
         b.iter(|| black_box(black_box(x) * black_box(y)))
     });
 }
@@ -55,7 +55,7 @@ pub fn benchmark_iter_sum<F: Field, const N: usize, const REPS: usize>(
         input.push(rng.gen::<[F; N]>())
     }
     let mut output = [F::zero(); REPS];
-    c.bench_function(&format!("{} sum/{}, {}", name, REPS, N), |b| {
+    c.bench_function(&format!("{name} sum/{REPS}, {N}"), |b| {
         b.iter(|| {
             for i in 0..REPS {
                 output[i] = input[i].iter().cloned().sum()
@@ -69,7 +69,7 @@ pub fn benchmark_add_latency<F: Field, const N: usize>(c: &mut Criterion, name:
 where
     Standard: Distribution<F>,
 {
-    c.bench_function(&format!("{} add-latency/{}", name, N), |b| {
+    c.bench_function(&format!("{name} add-latency/{N}"), |b| {
         b.iter_batched(
             || {
                 let mut rng = rand::thread_rng();
@@ -89,7 +89,7 @@ pub fn benchmark_add_throughput<F: Field, const N: usize>(c: &mut Criterion, nam
 where
     Standard: Distribution<F>,
 {
-    c.bench_function(&format!("{} add-throughput/{}", name, N), |b| {
+    c.bench_function(&format!("{name} add-throughput/{N}"), |b| {
         b.iter_batched(
             || {
                 let mut rng = rand::thread_rng();
@@ -132,7 +132,7 @@ pub fn benchmark_sub_latency<F: Field, const N: usize>(c: &mut Criterion, name:
 where
     Standard: Distribution<F>,
 {
-    c.bench_function(&format!("{} sub-latency/{}", name, N), |b| {
+    c.bench_function(&format!("{name} sub-latency/{N}"), |b| {
         b.iter_batched(
             || {
                 let mut rng = rand::thread_rng();
@@ -152,7 +152,7 @@ pub fn benchmark_sub_throughput<F: Field, const N: usize>(c: &mut Criterion, nam
 where
     Standard: Distribution<F>,
 {
-    c.bench_function(&format!("{} sub-throughput/{}", name, N), |b| {
+    c.bench_function(&format!("{name} sub-throughput/{N}"), |b| {
         b.iter_batched(
             || {
                 let mut rng = rand::thread_rng();

field/src/extension/binomial_extension.rs

@@ -237,7 +237,7 @@ where
                     (_, false) => format!("{x} X^{i}"),
                 })
                 .join(" + ");
-            write!(f, "{}", str)
+            write!(f, "{str}")
         }
     }
 }

fri/src/config.rs

@@ -1,3 +1,4 @@
+#[derive(Clone, Default)]
 pub struct FriConfig<M> {
     pub log_blowup: usize,
     pub num_queries: usize,

fri/src/proof.rs

@@ -4,12 +4,18 @@ use p3_commit::Mmcs;
 use p3_field::Field;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 #[serde(bound(
     serialize = "Witness: Serialize",
     deserialize = "Witness: Deserialize<'de>"
 ))]
-pub struct FriProof<F: Field, M: Mmcs<F>, Witness> {
+pub struct FriProof<F: Field, M: Mmcs<F>, Witness>
+where
+    F: Send + Sync,
+    M::Commitment: Send + Sync,
+    M::Proof: Send + Sync,
+    Witness: Send + Sync,
+{
     pub(crate) commit_phase_commits: Vec<M::Commitment>,
     pub(crate) query_proofs: Vec<QueryProof<F, M>>,
     // This could become Vec<FC::Challenge> if this library was generalized to support non-constant
@@ -18,22 +24,62 @@ pub struct FriProof<F: Field, M: Mmcs<F>, Witness> {
     pub(crate) pow_witness: Witness,
 }
 
-#[derive(Serialize, Deserialize)]
+unsafe impl<F: Field + Send + Sync, M: Mmcs<F>, Witness: Send + Sync> Send
+    for FriProof<F, M, Witness>
+where
+    M::Commitment: Send + Sync,
+    M::Proof: Send + Sync,
+{
+}
+
+unsafe impl<F: Field + Send + Sync, M: Mmcs<F>, Witness: Send + Sync> Sync
+    for FriProof<F, M, Witness>
+where
+    M::Commitment: Send + Sync,
+    M::Proof: Send + Sync,
+{
+}
+
+/// For each commit phase commitment, this contains openings of a commit phase codeword at the
+/// queried location, along with an opening proof.
+#[derive(Serialize, Deserialize, Clone)]
 #[serde(bound = "")]
-pub struct QueryProof<F: Field, M: Mmcs<F>> {
-    /// For each commit phase commitment, this contains openings of a commit phase codeword at the
-    /// queried location, along with an opening proof.
+pub struct QueryProof<F: Field, M: Mmcs<F>>
+where
+    F: Send + Sync,
+    M::Proof: Send + Sync,
+{
     pub(crate) commit_phase_openings: Vec<CommitPhaseProofStep<F, M>>,
 }
 
-#[derive(Serialize, Deserialize)]
+unsafe impl<F: Field + Send + Sync, M: Mmcs<F>> Send for QueryProof<F, M> where M::Proof: Send + Sync
+{}
+
+unsafe impl<F: Field + Send + Sync, M: Mmcs<F>> Sync for QueryProof<F, M> where M::Proof: Send + Sync
+{}
+
+// The opening of the commit phase codeword at the sibling location.
+// This may change to Vec<FC::Challenge> if the library is generalized to support other FRI
+// folding arities besides 2, meaning that there can be multiple siblings.
+#[derive(Serialize, Deserialize, Clone)]
 // #[serde(bound(serialize = "F: Serialize"))]
 #[serde(bound = "")]
-pub struct CommitPhaseProofStep<F: Field, M: Mmcs<F>> {
-    /// The opening of the commit phase codeword at the sibling location.
-    // This may change to Vec<FC::Challenge> if the library is generalized to support other FRI
-    // folding arities besides 2, meaning that there can be multiple siblings.
+pub struct CommitPhaseProofStep<F: Field, M: Mmcs<F>>
+where
+    F: Send + Sync,
+    M::Proof: Send + Sync,
+{
     pub(crate) sibling_value: F,
 
     pub(crate) opening_proof: M::Proof,
 }
+
+unsafe impl<F: Field + Send + Sync, M: Mmcs<F>> Send for CommitPhaseProofStep<F, M> where
+    M::Proof: Send + Sync
+{
+}
+
+unsafe impl<F: Field + Send + Sync, M: Mmcs<F>> Sync for CommitPhaseProofStep<F, M> where
+    M::Proof: Send + Sync
+{
+}

fri/src/prover.rs

@@ -19,11 +19,13 @@ pub fn prove<F, M, Challenger>(
     challenger: &mut Challenger,
 ) -> (FriProof<F, M, Challenger::Witness>, Vec<usize>)
 where
-    F: TwoAdicField,
+    F: TwoAdicField + Send + Sync,
     M: DirectMmcs<F> + Send + Sync,
-    Challenger: GrindingChallenger + CanObserve<M::Commitment> + CanSample<F>,
-    <M as Mmcs<F>>::Proof: Send,
-    <M as Mmcs<F>>::ProverData: Send + Sync,
+    M::Commitment: Send + Sync,
+    M::Proof: Send + Sync,
+    M::ProverData: Send + Sync,
+    Challenger: GrindingChallenger + CanObserve<M::Commitment> + CanSample<F> + Send + Sync,
+    Challenger::Witness: Send + Sync,
 {
     let log_max_height = input.iter().rposition(Option::is_some).unwrap();
 
@@ -61,6 +63,7 @@ fn answer_query<F, M>(
 where
     F: Field,
     M: Mmcs<F>,
+    M::Proof: Send + Sync,
 {
     let commit_phase_openings = commit_phase_commits
         .iter()
@@ -98,6 +101,7 @@ fn commit_phase<F, M, Challenger>(
 where
     F: TwoAdicField,
     M: DirectMmcs<F>,
+    M::Commitment: Send + Sync,
     Challenger: CanObserve<M::Commitment> + CanSample<F>,
 {
     let mut current = input[log_max_height].as_ref().unwrap().clone();