Reformat

src/engine.rs

@@ -1,11 +1,11 @@
 pub mod block;
-pub mod port_buffer;
-pub mod regressor;
+pub mod buffer_handler;
 pub mod graph;
-pub mod optimizer;
 pub mod hogwild;
+pub mod multithread_helpers;
+pub mod optimizer;
 pub mod persistence;
+pub mod port_buffer;
 pub mod quantization;
-pub mod buffer_handler;
-pub mod multithread_helpers;
+pub mod regressor;
 pub mod serving;

src/engine/block.rs

@@ -1,4 +1,5 @@
 pub mod ffm;
+pub mod file;
 pub mod iterators;
 pub mod loss_functions;
 pub mod lr;
@@ -8,4 +9,3 @@ pub mod normalize;
 pub mod relu;
 #[cfg(test)]
 pub mod test;
-pub mod file;

src/engine/block/ffm.rs

@@ -12,18 +12,18 @@ use merand48::*;
 
 use optimizer::OptimizerTrait;
 
-use crate::engine::block::{file, iterators};
 use crate::engine::block::iterators::OptimizerData;
-use crate::namespace::feature_buffer;
-use crate::namespace::feature_buffer::{FeatureBuffer, HashAndValueAndSeq};
+use crate::engine::block::{file, iterators};
 use crate::engine::graph;
-use crate::model_instance;
 use crate::engine::optimizer;
 use crate::engine::port_buffer;
 use crate::engine::port_buffer::PortBuffer;
 use crate::engine::quantization;
 use crate::engine::regressor;
 use crate::engine::regressor::{BlockCache, BlockTrait, FFM_CONTRA_BUF_LEN};
+use crate::model_instance;
+use crate::namespace::feature_buffer;
+use crate::namespace::feature_buffer::{FeatureBuffer, HashAndValueAndSeq};
 
 const FFM_STACK_BUF_LEN: usize = 170393;
 const STEP: usize = 4;
@@ -294,7 +294,7 @@ impl<L: OptimizerTrait + 'static> BlockTrait for BlockFFM<L> {
                 fb.ffm_buffer.len() * (self.ffm_k * self.ffm_num_fields) as usize;
             if local_data_ffm_len < FFM_STACK_BUF_LEN {
                 // Fast-path - using on-stack data structures
-                let local_data_ffm_values: [f32; FFM_STACK_BUF_LEN ] =
+                let local_data_ffm_values: [f32; FFM_STACK_BUF_LEN] =
                     MaybeUninit::uninit().assume_init();
                 core_macro!(local_data_ffm_values);
             } else {
@@ -1203,11 +1203,11 @@ impl<L: OptimizerTrait + 'static> BlockFFM<L> {
 #[cfg(test)]
 mod tests {
     use crate::assert_epsilon;
-    use crate::engine::block::test::{slearn2, spredict2, spredict2_with_cache, ssetup_cache2};
     use crate::engine::block::loss_functions;
-    use crate::namespace::feature_buffer::HashAndValueAndSeq;
+    use crate::engine::block::test::{slearn2, spredict2, spredict2_with_cache, ssetup_cache2};
     use crate::engine::graph::BlockGraph;
     use crate::model_instance::Optimizer;
+    use crate::namespace::feature_buffer::HashAndValueAndSeq;
 
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;

src/engine/block/file.rs

@@ -1,15 +1,14 @@
-use std::error::Error;
-use std::{io, mem, slice};
-use std::cmp::min;
-use std::io::{Read, Write};
 use crate::engine::block::iterators::WeightAndOptimizerData;
 use crate::engine::optimizer::{OptimizerSGD, OptimizerTrait};
-
+use std::cmp::min;
+use std::error::Error;
+use std::io::{Read, Write};
+use std::{io, mem, slice};
 
 pub fn read_weights_from_buf<L>(
     weights: &mut Vec<L>,
     input_bufreader: &mut dyn Read,
-    _use_quantization: bool
+    _use_quantization: bool,
 ) -> Result<(), Box<dyn Error>> {
     if weights.is_empty() {
         return Err("Loading weights to unallocated weighs buffer".to_string())?;
@@ -39,7 +38,7 @@ pub fn skip_weights_from_buf<L>(
 pub fn write_weights_to_buf<L>(
     weights: &Vec<L>,
     output_bufwriter: &mut dyn Write,
-    _use_quantization: bool
+    _use_quantization: bool,
 ) -> Result<(), Box<dyn Error>> {
     if weights.is_empty() {
         assert!(false);
@@ -85,4 +84,4 @@ pub fn read_weights_only_from_buf2<L: OptimizerTrait>(
         }
     }
     Ok(())
-}
+}

src/engine/block/iterators.rs

@@ -1,9 +1,8 @@
 use crate::engine::optimizer::OptimizerTrait;
 
-use crate::namespace::feature_buffer;
 use crate::engine::port_buffer;
 use crate::engine::regressor::{BlockCache, BlockTrait};
-
+use crate::namespace::feature_buffer;
 
 #[derive(Clone, Debug)]
 #[repr(C)]

src/engine/block/loss_functions.rs

@@ -2,14 +2,14 @@ use std::any::Any;
 use std::error::Error;
 
 use crate::engine::block::iterators;
-use crate::namespace::feature_buffer;
-use crate::namespace::feature_buffer::FeatureBuffer;
 use crate::engine::graph;
 use crate::engine::port_buffer;
 use crate::engine::port_buffer::PortBuffer;
 use crate::engine::regressor;
 use crate::engine::regressor::BlockCache;
 use crate::engine::regressor::BlockTrait;
+use crate::namespace::feature_buffer;
+use crate::namespace::feature_buffer::FeatureBuffer;
 
 #[inline(always)]
 pub fn logistic(t: f32) -> f32 {
@@ -42,11 +42,7 @@ pub fn new_logloss_block(
 
 impl BlockSigmoid {
     #[inline(always)]
-    fn internal_forward(
-        &self,
-        fb: &FeatureBuffer,
-        pb: &mut PortBuffer,
-    ) {
+    fn internal_forward(&self, fb: &FeatureBuffer, pb: &mut PortBuffer) {
         unsafe {
             debug_assert!(self.input_offset != usize::MAX);
             debug_assert!(self.output_offset != usize::MAX);

src/engine/block/lr.rs

@@ -1,9 +1,9 @@
 use std::any::Any;
 
 use crate::engine::graph;
-use crate::model_instance;
 use crate::engine::optimizer;
 use crate::engine::regressor;
+use crate::model_instance;
 use crate::namespace::{feature_buffer, parser};
 
 use std::error::Error;
@@ -12,9 +12,9 @@ use std::io;
 use crate::engine::block::{file, iterators};
 use crate::engine::port_buffer;
 use crate::engine::regressor::BlockCache;
+use crate::engine::regressor::BlockTrait;
 use iterators::WeightAndOptimizerData;
 use optimizer::OptimizerTrait;
-use crate::engine::regressor::BlockTrait;
 
 pub struct BlockLR<L: OptimizerTrait> {
     pub weights: Vec<WeightAndOptimizerData<L>>,

src/engine/block/misc.rs

@@ -3,10 +3,10 @@ use std::error::Error;
 
 use crate::engine::block::iterators;
 use crate::engine::graph;
-use crate::namespace::feature_buffer::FeatureBuffer;
 use crate::engine::port_buffer::PortBuffer;
 use crate::engine::regressor::BlockCache;
 use crate::engine::regressor::BlockTrait;
+use crate::namespace::feature_buffer::FeatureBuffer;
 
 #[derive(PartialEq)]
 pub enum Observe {
@@ -941,12 +941,7 @@ mod tests {
         let triangle_block = new_triangle_block(&mut bg, observe_block_backward).unwrap();
         let observe_block_forward =
             new_observe_block(&mut bg, triangle_block, Observe::Forward, None).unwrap();
-        new_sink_block(
-            &mut bg,
-            observe_block_forward,
-            SinkType::Untouched,
-        )
-        .unwrap();
+        new_sink_block(&mut bg, observe_block_forward, SinkType::Untouched).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 
@@ -972,11 +967,9 @@ mod tests {
         let (copy_block_1, copy_block_2) =
             new_copy_block_2(&mut bg, observe_block_backward).unwrap();
         let _observe_block_1_forward =
-            new_observe_block(&mut bg, copy_block_1, Observe::Forward, Some(5.0))
-                .unwrap();
+            new_observe_block(&mut bg, copy_block_1, Observe::Forward, Some(5.0)).unwrap();
         let _observe_block_2_forward =
-            new_observe_block(&mut bg, copy_block_2, Observe::Forward, Some(6.0))
-                .unwrap();
+            new_observe_block(&mut bg, copy_block_2, Observe::Forward, Some(6.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 
@@ -1015,14 +1008,11 @@ mod tests {
         let (copy_block_3, copy_block_4) = new_copy_block_2(&mut bg, copy_block_1).unwrap();
 
         let _observe_block_1_forward =
-            new_observe_block(&mut bg, copy_block_2, Observe::Forward, Some(5.0))
-                .unwrap();
+            new_observe_block(&mut bg, copy_block_2, Observe::Forward, Some(5.0)).unwrap();
         let _observe_block_2_forward =
-            new_observe_block(&mut bg, copy_block_3, Observe::Forward, Some(6.0))
-                .unwrap();
+            new_observe_block(&mut bg, copy_block_3, Observe::Forward, Some(6.0)).unwrap();
         let _observe_block_3_forward =
-            new_observe_block(&mut bg, copy_block_4, Observe::Forward, Some(7.0))
-                .unwrap();
+            new_observe_block(&mut bg, copy_block_4, Observe::Forward, Some(7.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 
@@ -1057,8 +1047,7 @@ mod tests {
         let input_block_1 = new_const_block(&mut bg, vec![2.0, 3.0]).unwrap();
         let join_block = new_join_block(&mut bg, vec![input_block_1]).unwrap();
         let _observe_block =
-            new_observe_block(&mut bg, join_block, Observe::Forward, Some(6.0))
-                .unwrap();
+            new_observe_block(&mut bg, join_block, Observe::Forward, Some(6.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 
@@ -1079,8 +1068,7 @@ mod tests {
         let input_block_2 = new_const_block(&mut bg, vec![4.0, 5.0, 6.0]).unwrap();
         let join_block = new_join_block(&mut bg, vec![input_block_1, input_block_2]).unwrap();
         let _observe_block =
-            new_observe_block(&mut bg, join_block, Observe::Forward, Some(6.0))
-                .unwrap();
+            new_observe_block(&mut bg, join_block, Observe::Forward, Some(6.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 
@@ -1103,8 +1091,7 @@ mod tests {
         let join_block =
             new_join_block(&mut bg, vec![input_block_1, input_block_2, input_block_3]).unwrap();
         let _observe_block =
-            new_observe_block(&mut bg, join_block, Observe::Forward, Some(6.0))
-                .unwrap();
+            new_observe_block(&mut bg, join_block, Observe::Forward, Some(6.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 
@@ -1128,8 +1115,7 @@ mod tests {
         let input_block_3 = new_const_block(&mut bg, vec![6.0, 7.0]).unwrap();
         let join_block_2 = new_join_block(&mut bg, vec![input_block_3, join_block_1]).unwrap();
         let _observe_block =
-            new_observe_block(&mut bg, join_block_2, Observe::Forward, Some(6.0))
-                .unwrap();
+            new_observe_block(&mut bg, join_block_2, Observe::Forward, Some(6.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 
@@ -1151,12 +1137,10 @@ mod tests {
         let input_block_1 = new_const_block(&mut bg, vec![2.0, 3.0]).unwrap();
         let observe_block_backward =
             new_observe_block(&mut bg, input_block_1, Observe::Backward, None).unwrap();
-        let (copy_1, copy_2) =
-            new_copy_block_2(&mut bg, observe_block_backward).unwrap();
+        let (copy_1, copy_2) = new_copy_block_2(&mut bg, observe_block_backward).unwrap();
         let join_block = new_join_block(&mut bg, vec![copy_1, copy_2]).unwrap();
         let _observe_block =
-            new_observe_block(&mut bg, join_block, Observe::Forward, Some(6.0))
-                .unwrap();
+            new_observe_block(&mut bg, join_block, Observe::Forward, Some(6.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 

src/engine/block/neural.rs

@@ -7,18 +7,18 @@ use std::io;
 use std::io::Error as IOError;
 use std::io::ErrorKind;
 
-use crate::engine::block::{file, iterators};
 use crate::engine::block::misc;
+use crate::engine::block::{file, iterators};
 use crate::engine::graph;
-use crate::model_instance;
 use crate::engine::optimizer;
 use crate::engine::regressor::BlockCache;
+use crate::engine::regressor::BlockTrait;
+use crate::model_instance;
 use iterators::OptimizerData;
 use optimizer::OptimizerTrait;
-use crate::engine::regressor::BlockTrait;
 
-use crate::namespace::feature_buffer::FeatureBuffer;
 use crate::engine::port_buffer::PortBuffer;
+use crate::namespace::feature_buffer::FeatureBuffer;
 use blas::*;
 
 const MAX_NUM_INPUTS: usize = 16000;
@@ -483,11 +483,11 @@ mod tests {
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
     use crate::assert_epsilon;
-    use crate::engine:: block::misc;
+    use crate::engine::block::misc;
     use crate::engine::block::misc::Observe;
+    use crate::engine::block::test::slearn2;
     use crate::engine::graph::BlockGraph;
     use crate::model_instance::Optimizer;
-    use crate::engine::block::test::slearn2;
 
     fn fb_vec() -> FeatureBuffer {
         FeatureBuffer {
@@ -521,8 +521,7 @@ mod tests {
         )
         .unwrap();
         let _observe_block =
-            misc::new_observe_block(&mut bg, neuron_block, Observe::Forward, Some(1.0))
-                .unwrap();
+            misc::new_observe_block(&mut bg, neuron_block, Observe::Forward, Some(1.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 
@@ -556,8 +555,7 @@ mod tests {
         )
         .unwrap();
         let _observe_block =
-            misc::new_observe_block(&mut bg, neuron_block, Observe::Forward, Some(1.0))
-                .unwrap();
+            misc::new_observe_block(&mut bg, neuron_block, Observe::Forward, Some(1.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);
 

src/engine/block/normalize.rs

@@ -2,12 +2,12 @@ use std::any::Any;
 use std::error::Error;
 
 use crate::engine::block::iterators;
-use crate::namespace::feature_buffer::FeatureBuffer;
 use crate::engine::graph;
-use crate::model_instance;
 use crate::engine::port_buffer::PortBuffer;
 use crate::engine::regressor::BlockCache;
 use crate::engine::regressor::BlockTrait;
+use crate::model_instance;
+use crate::namespace::feature_buffer::FeatureBuffer;
 
 const EPS: f32 = 1e-2;
 

src/engine/block/relu.rs

@@ -2,12 +2,12 @@ use std::any::Any;
 use std::error::Error;
 
 use crate::engine::block::iterators;
-use crate::namespace::feature_buffer::FeatureBuffer;
 use crate::engine::graph::{BlockGraph, BlockPtrOutput, InputSlot, OutputSlot};
-use crate::model_instance;
 use crate::engine::port_buffer::PortBuffer;
 use crate::engine::regressor::BlockCache;
 use crate::engine::regressor::BlockTrait;
+use crate::model_instance;
+use crate::namespace::feature_buffer::FeatureBuffer;
 
 pub struct BlockRELU {
     pub num_inputs: usize,
@@ -136,8 +136,8 @@ mod tests {
     use crate::assert_epsilon;
     use crate::engine::block::misc;
     use crate::engine::block::test;
-    use test::slearn2;
     use misc::Observe;
+    use test::slearn2;
 
     fn fb_vec() -> FeatureBuffer {
         FeatureBuffer {
@@ -156,8 +156,7 @@ mod tests {
         let input_block = misc::new_const_block(&mut bg, vec![2.0]).unwrap();
         let relu_block = new_relu_block(&mut bg, &mi, input_block).unwrap();
         let _observe_block =
-            misc::new_observe_block(&mut bg, relu_block, Observe::Forward, Some(1.0))
-                .unwrap();
+            misc::new_observe_block(&mut bg, relu_block, Observe::Forward, Some(1.0)).unwrap();
         bg.finalize();
         bg.allocate_and_init_weights(&mi);