Remove array copy for vector multiplication

Author: Kunming Jiang

spartan_parallel/src/r1csinstance.rs

@@ -3,6 +3,7 @@ use rayon::prelude::*;
 use std::cmp::{max, min};
 use std::collections::HashMap;
 
+use crate::custom_dense_mlpoly::rev_bits;
 use crate::scalar::SpartanExtensionField;
 use crate::transcript::AppendToTranscript;
 
@@ -250,8 +251,13 @@ impl<S: SpartanExtensionField + Send + Sync> R1CSInstance<S> {
 
       Az[p] = (0..num_proofs[p])
         .into_par_iter()
-        .map(|q| {
+        .map(|q_rev| {
+          // Reverse the bits of q
+          let q_step = max_num_proofs / num_proofs[p];
+          let q = rev_bits(q_rev * q_step, max_num_proofs);
+
           vec![self.A_list[p_inst].multiply_vec_disjoint_rounds(
+            max_num_cons,
             num_cons[p_inst].clone(),
             max_num_inputs,
             num_inputs[p],
@@ -261,8 +267,13 @@ impl<S: SpartanExtensionField + Send + Sync> R1CSInstance<S> {
         .collect();
       Bz[p] = (0..num_proofs[p])
         .into_par_iter()
-        .map(|q| {
+        .map(|q_rev| {
+          // Reverse the bits of q
+          let q_step = max_num_proofs / num_proofs[p];
+          let q = rev_bits(q_rev * q_step, max_num_proofs);
+
           vec![self.B_list[p_inst].multiply_vec_disjoint_rounds(
+            max_num_cons,
             num_cons[p_inst].clone(),
             max_num_inputs,
             num_inputs[p],
@@ -272,8 +283,13 @@ impl<S: SpartanExtensionField + Send + Sync> R1CSInstance<S> {
         .collect();
       Cz[p] = (0..num_proofs[p])
         .into_par_iter()
-        .map(|q| {
+        .map(|q_rev| {
+          // Reverse the bits of q
+          let q_step = max_num_proofs / num_proofs[p];
+          let q = rev_bits(q_rev * q_step, max_num_proofs);
+          
           vec![self.C_list[p_inst].multiply_vec_disjoint_rounds(
+            max_num_cons,
             num_cons[p_inst].clone(),
             max_num_inputs,
             num_inputs[p],
@@ -284,22 +300,22 @@ impl<S: SpartanExtensionField + Send + Sync> R1CSInstance<S> {
     }
 
     (
-      DensePolynomialPqx::new_rev(
-        &Az,
+      DensePolynomialPqx::new(
+        Az,
         num_proofs.clone(),
         max_num_proofs,
         num_cons.clone(),
         max_num_cons,
       ),
-      DensePolynomialPqx::new_rev(
-        &Bz,
+      DensePolynomialPqx::new(
+        Bz,
         num_proofs.clone(),
         max_num_proofs,
         num_cons.clone(),
         max_num_cons,
       ),
-      DensePolynomialPqx::new_rev(
-        &Cz,
+      DensePolynomialPqx::new(
+        Cz,
         num_proofs,
         max_num_proofs,
         num_cons.clone(),

spartan_parallel/src/r1csproof.rs

@@ -4,7 +4,6 @@ use super::dense_mlpoly::{DensePolynomial, EqPolynomial};
 use super::errors::ProofVerifyError;
 use super::math::Math;
 use super::r1csinstance::R1CSInstance;
-use super::random::RandomTape;
 use super::sumcheck::SumcheckInstanceProof;
 use super::timer::Timer;
 use super::transcript::ProofTranscript;

spartan_parallel/src/sparse_mlpoly.rs

@@ -1,6 +1,7 @@
 #![allow(clippy::type_complexity)]
 #![allow(clippy::too_many_arguments)]
 #![allow(clippy::needless_range_loop)]
+use crate::custom_dense_mlpoly::rev_bits;
 use crate::scalar::SpartanExtensionField;
 
 use super::dense_mlpoly::DensePolynomial;
@@ -403,21 +404,27 @@ impl<S: SpartanExtensionField> SparseMatPolynomial<S> {
   // Z is consisted of vector segments
   // Z[i] contains entries i * max_num_cols ~ i * max_num_cols + num_cols
   pub fn multiply_vec_disjoint_rounds(
-    &self,
-    num_rows: usize,
-    max_num_cols: usize,
-    _num_cols: usize,
-    z: &Vec<Vec<S>>,
+    &self, 
+    max_num_rows: usize,
+    num_rows: usize, 
+    max_num_cols: usize, 
+    _num_cols: usize, 
+    z: &Vec<Vec<S>>
   ) -> Vec<S> {
+    let step_r = max_num_rows / num_rows;
     (0..self.M.len())
       .map(|i| {
         let row = self.M[i].row;
         let col = self.M[i].col;
-        let val = &self.M[i].val;
-        (row, *val * z[col / max_num_cols][col % max_num_cols])
+        let val = self.M[i].val.clone();
+        (row, val * z[col / max_num_cols][col % max_num_cols])
       })
       .fold(vec![S::field_zero(); num_rows], |mut Mz, (r, v)| {
-        Mz[r] = Mz[r] + v;
+        // Reverse the bits of r. r_rev is a multiple of step_r
+        let r_rev = rev_bits(r, max_num_rows);
+        // Now r_rev is between 0 to num_inputs[p]
+        let r_rev = r_rev / step_r;
+        Mz[r_rev] += v;
         Mz
       })
   }