fix CI and parallelism

Author: maxscherbakov

src/chunkfs_sbc.rs

@@ -16,8 +16,8 @@ use std::time::Instant;
 
 const NUM_THREADS_FOR_HASHING: usize = 6;
 
-pub type ClusterPoint<'a, Hash: SBCHash> = (Hash, &'a mut &'a mut DataContainer<SBCKey<Hash>>);
-pub type Clusters<'a, Hash: SBCHash> = HashMap<Hash, Vec<ClusterPoint<'a, Hash>>>;
+pub type ClusterPoint<'a, Hash> = (Hash, &'a mut &'a mut DataContainer<SBCKey<Hash>>);
+pub type Clusters<'a, Hash> = HashMap<Hash, Vec<ClusterPoint<'a, Hash>>>;
 
 impl<D: Decoder, Hash: SBCHash> Database<SBCKey<Hash>, Vec<u8>> for SBCMap<D, Hash> {
     fn insert(&mut self, sbc_hash: SBCKey<Hash>, chunk: Vec<u8>) -> io::Result<()> {
@@ -72,7 +72,7 @@ impl<D: Decoder, Hash: SBCHash> IterableDatabase<SBCKey<Hash>, Vec<u8>> for SBCM
 pub struct SBCScrubber<Hash, H, C, E>
 where
     Hash: SBCHash,
-    H : Hasher<Hash = Hash>,
+    H: Hasher<Hash = Hash>,
     C: Clusterer<Hash>,
     E: Encoder,
 {
@@ -97,11 +97,13 @@ where
     }
 }
 
-impl<CDCHash, B, D, H, C, E, Hash> Scrub<CDCHash, B, SBCKey<Hash>, SBCMap<D, Hash>> for SBCScrubber<Hash, H, C, E>
+impl<CDCHash, B, D, H, C, E, Hash> Scrub<CDCHash, B, SBCKey<Hash>, SBCMap<D, Hash>>
+    for SBCScrubber<Hash, H, C, E>
 where
     CDCHash: ChunkHash,
-    for<'data> B: IterableDatabase<CDCHash, DataContainer<SBCKey<Hash>>> + IntoParallelRefMutIterator<'data>,
-    H : Hasher<Hash = Hash> + Sync,
+    for<'data> B:
+        IterableDatabase<CDCHash, DataContainer<SBCKey<Hash>>> + IntoParallelRefMutIterator<'data>,
+    H: Hasher<Hash = Hash> + Sync,
     C: Clusterer<Hash>,
     D: Decoder + Send,
     E: Encoder + Sync,

src/clusterer.rs

@@ -1,9 +1,10 @@
 mod graph;
 
 use crate::chunkfs_sbc::{ClusterPoint, Clusters};
-pub use graph::Graph;
 use crate::SBCHash;
+pub use graph::Graph;
 
 pub trait Clusterer<Hash: SBCHash> {
-    fn clusterize<'a>(&mut self, chunk_sbc_hash: Vec<ClusterPoint<'a, Hash>>) -> Clusters<'a, Hash>;
+    fn clusterize<'a>(&mut self, chunk_sbc_hash: Vec<ClusterPoint<'a, Hash>>)
+        -> Clusters<'a, Hash>;
 }

src/clusterer/graph.rs

@@ -1,6 +1,6 @@
 use crate::chunkfs_sbc::{ClusterPoint, Clusters};
 use crate::clusterer::Clusterer;
-use crate::{SBCHash};
+use crate::SBCHash;
 use std::collections::HashMap;
 
 const MAX_WEIGHT_EDGE: u32 = 1 << 5;
@@ -19,7 +19,10 @@ pub struct Graph {
     vertices: HashMap<u32, Vertex>,
 }
 impl<Hash: SBCHash> Clusterer<Hash> for Graph {
-    fn clusterize<'a>(&mut self, chunk_sbc_hash: Vec<ClusterPoint<'a, Hash>>) -> Clusters<'a, Hash> {
+    fn clusterize<'a>(
+        &mut self,
+        chunk_sbc_hash: Vec<ClusterPoint<'a, Hash>>,
+    ) -> Clusters<'a, Hash> {
         let mut clusters: Clusters<Hash> = HashMap::default();
         for (sbc_hash, data_container) in chunk_sbc_hash {
             let key = sbc_hash.get_key_for_graph_clusterer();

src/encoder.rs

@@ -63,7 +63,7 @@ pub trait Encoder {
         let processed_data = Mutex::new(0);
         let target_map_ref = Arc::new(Mutex::new(target_map));
         pool.install(|| {
-            let _ = clusters.par_iter_mut().for_each(|(parent_hash, cluster)| {
+            clusters.par_iter_mut().for_each(|(parent_hash, cluster)| {
                 let data_analyse = self.encode_cluster(
                     target_map_ref.clone(),
                     cluster.as_mut_slice(),
@@ -104,7 +104,10 @@ fn count_delta_chunks_with_hash<D: Decoder, Hash: SBCHash>(
     count as u16
 }
 
-fn find_empty_cell<D: Decoder, Hash: SBCHash>(target_map: &MutexGuard<&mut SBCMap<D, Hash>>, hash: &Hash) -> Hash {
+fn find_empty_cell<D: Decoder, Hash: SBCHash>(
+    target_map: &MutexGuard<&mut SBCMap<D, Hash>>,
+    hash: &Hash,
+) -> Hash {
     let mut left = hash.clone();
     let mut right = hash.next_hash();
     loop {

src/encoder/levenshtein_encoder.rs

@@ -236,8 +236,8 @@ fn encode_delta_action(action: Action, index: usize, byte_value: u8) -> u32 {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{AronovichHash, decoder};
-    use crate::SBCHash::Aronovich;
+    use crate::decoder;
+    use crate::hasher::AronovichHash;
 
     #[test]
     fn test_restore_similarity_chunk_1_byte_diff() {
@@ -365,11 +365,15 @@ mod test {
     fn create_map_and_key<'a>(
         data: &'a [u8],
         data2: &'a [u8],
-    ) -> (SBCMap<decoder::LevenshteinDecoder, AronovichHash>, SBCKey<AronovichHash>) {
+    ) -> (
+        SBCMap<decoder::LevenshteinDecoder, AronovichHash>,
+        SBCKey<AronovichHash>,
+    ) {
         let mut binding = SBCMap::new(decoder::LevenshteinDecoder);
         let sbc_map = Arc::new(Mutex::new(&mut binding));
 
-        let (_, sbc_key) = encode_simple_chunk(&mut sbc_map.lock().unwrap(), data, AronovichHash::new(0));
+        let (_, sbc_key) =
+            encode_simple_chunk(&mut sbc_map.lock().unwrap(), data, AronovichHash::new(0));
         let (_, _, sbc_key_2) = LevenshteinEncoder::encode_delta_chunk(
             sbc_map.clone(),
             data2,

src/hasher.rs

@@ -1,19 +1,17 @@
+pub use aronovich_hash::{AronovichHash, AronovichHasher};
 use std::hash;
-pub use aronovich_hash::{AronovichHasher, AronovichHash};
 mod aronovich_hash;
 
 pub trait Hasher {
     type Hash: SBCHash;
     fn calculate_hash(&self, chunk_data: &[u8]) -> Self::Hash;
-
 }
 
-
-pub trait SBCHash: hash::Hash + Clone + Eq + PartialEq + Default {
+pub trait SBCHash: hash::Hash + Clone + Eq + PartialEq + Default + Send + Sync {
     fn new(key: u32) -> Self;
     fn next_hash(&self) -> Self;
 
     fn last_hash(&self) -> Self;
 
     fn get_key_for_graph_clusterer(&self) -> u32;
-}
+}

src/hasher/aronovich_hash.rs

@@ -1,5 +1,5 @@
 use crate::hasher::Hasher;
-use crate::{SBCHash};
+use crate::SBCHash;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::ops::Range;
@@ -12,11 +12,11 @@ const SHIFT_FOR_PAIR: u8 = 3;
 const BLOCKS_FOR_P_SPECTRUM_INDEXES: Range<usize> = 5..9;
 const MIN_FREQUENCY_FOR_BYTE: u32 = 50;
 
+#[derive(Debug)]
 pub struct AronovichHash {
-    hash: u32
+    hash: u32,
 }
 
-
 impl Hash for AronovichHash {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.hash.hash(state)
@@ -44,20 +44,18 @@ impl Default for AronovichHash {
 }
 
 impl SBCHash for AronovichHash {
-
     fn new(hash: u32) -> Self {
-        AronovichHash {hash}
+        AronovichHash { hash }
     }
     fn next_hash(&self) -> Self {
         AronovichHash {
-            hash:
-            self.hash.saturating_add(1)
+            hash: self.hash.saturating_add(1),
         }
     }
 
     fn last_hash(&self) -> Self {
-        AronovichHash {hash:
-        self.hash.saturating_sub(1)
+        AronovichHash {
+            hash: self.hash.saturating_sub(1),
         }
     }
 

src/lib.rs

@@ -1,7 +1,7 @@
 use crate::decoder::Decoder;
 pub use chunkfs_sbc::SBCScrubber;
-use std::collections::HashMap;
 use hasher::SBCHash;
+use std::collections::HashMap;
 
 mod chunkfs_sbc;
 pub mod clusterer;
@@ -19,8 +19,6 @@ enum ChunkType<Hash: SBCHash> {
     Simple,
 }
 
-
-
 #[derive(Hash, PartialEq, Eq, Clone, Default)]
 pub struct SBCKey<H: SBCHash> {
     hash: H,