Make matrices hold a single allocation of limbs

ext/crates/algebra/src/module/homomorphism/full_module_homomorphism.rs

@@ -69,7 +69,7 @@ impl<S: Module, T: Module<Algebra = S::Algebra>> ModuleHomomorphism
     ) {
         let output_degree = input_degree - self.degree_shift;
         if let Some(matrix) = self.matrices.get(output_degree) {
-            result.add(matrix[input_idx].as_slice(), coeff);
+            result.add(matrix.row(input_idx), coeff);
         }
     }
 
@@ -224,7 +224,7 @@ impl<S: Module> IdentityHomomorphism<S> for FullModuleHomomorphism<S, S> {
             let dim = source.dimension(i);
             let mut matrix = Matrix::new(p, dim, dim);
             for k in 0..dim {
-                matrix[k].set_entry(k, 1);
+                matrix.row_mut(k).set_entry(k, 1);
             }
             matrices.push(matrix);
         }

ext/crates/algebra/src/module/homomorphism/mod.rs

@@ -147,9 +147,7 @@ pub trait ModuleHomomorphism: Send + Sync {
         matrix
             .maybe_par_iter_mut()
             .enumerate()
-            .for_each(|(i, row)| {
-                self.apply_to_basis_element(row.as_slice_mut(), 1, degree, inputs[i])
-            });
+            .for_each(|(i, row)| self.apply_to_basis_element(row, 1, degree, inputs[i]));
 
         matrix
     }

ext/crates/fp/src/limb.rs

@@ -8,6 +8,43 @@ pub(crate) struct LimbBitIndexPair {
     pub(crate) bit_index: usize,
 }
 
+/// Read an array of `Limb`s.
+pub(crate) fn from_bytes(limbs: &mut [Limb], data: &mut impl std::io::Read) -> std::io::Result<()> {
+    if cfg!(target_endian = "little") {
+        let num_bytes = std::mem::size_of_val(limbs);
+        unsafe {
+            let buf: &mut [u8] =
+                std::slice::from_raw_parts_mut(limbs.as_mut_ptr() as *mut u8, num_bytes);
+            data.read_exact(buf).unwrap();
+        }
+    } else {
+        for entry in limbs {
+            let mut bytes: [u8; size_of::<Limb>()] = [0; size_of::<Limb>()];
+            data.read_exact(&mut bytes)?;
+            *entry = Limb::from_le_bytes(bytes);
+        }
+    };
+    Ok(())
+}
+
+/// Store an array of `Limb`s.
+pub(crate) fn to_bytes(limbs: &[Limb], data: &mut impl std::io::Write) -> std::io::Result<()> {
+    let num_limbs = limbs.len();
+
+    if cfg!(target_endian = "little") {
+        let num_bytes = std::mem::size_of_val(limbs);
+        let buf: &[u8] =
+            unsafe { std::slice::from_raw_parts(limbs.as_ptr() as *const u8, num_bytes) };
+        data.write_all(buf)?;
+    } else {
+        for limb in &limbs[0..num_limbs] {
+            let bytes = limb.to_le_bytes();
+            data.write_all(&bytes)?;
+        }
+    }
+    Ok(())
+}
+
 pub(crate) fn sign_rule(mut target: Limb, mut source: Limb) -> u32 {
     let mut result = 0;
     let mut n = 1;

ext/crates/fp/src/matrix/m4ri.rs

@@ -82,16 +82,16 @@ impl M4riTable {
     /// Generates the table from the known data
     /// `num` is the number of the vector being added.
     pub fn generate(&mut self, matrix: &Matrix) {
-        let num_limbs = matrix[0].limbs().len();
+        let num_limbs = matrix.row(0).limbs().len();
         self.min_limb = usize::MAX;
         for (n, (c, &r)) in self.columns.iter().zip_eq(&self.rows).enumerate() {
             let old_len = self.data.len();
-            self.data.extend_from_slice(matrix[r].limbs());
+            self.data.extend_from_slice(matrix.row(r).limbs());
             self.data.extend_from_within(..old_len);
             for i in 1 << n..2 * (1 << n) - 1 {
                 simd::add_simd(
                     &mut self.data[i * num_limbs..(i + 1) * num_limbs],
-                    matrix[r].limbs(),
+                    matrix.row(r).limbs(),
                     c.limb,
                 );
             }
@@ -103,9 +103,9 @@ impl M4riTable {
         for (&row, col) in self.rows.iter().zip_eq(&self.columns) {
             assert!(target != row);
             unsafe {
-                let coef = (matrix[target].limbs()[col.limb] >> col.bit_index) & 1;
+                let coef = (matrix.row(target).limbs()[col.limb] >> col.bit_index) & 1;
                 if coef != 0 {
-                    let (target, source) = matrix.split_borrow(target, row);
+                    let (mut target, source) = matrix.split_borrow(target, row);
                     simd::add_simd(target.limbs_mut(), source.limbs(), col.limb)
                 }
             }