SparseLib Code format (#199)

* SparseLib code reformat

* workaround for benchmark code format

Author: airMeng

nlp_toolkit/backends/neural_engine/SparseLib/include/amx_utils.hpp

@@ -14,10 +14,10 @@
 
 #ifndef ENGINE_SPARSELIB_INCLUDE_AMX_UTILS_HPP_
 #define ENGINE_SPARSELIB_INCLUDE_AMX_UTILS_HPP_
+#include <omp.h>
 #include <immintrin.h>
 #include <mutex>  // NOLINT
 #include <cstdint>
-#include <omp.h>
 #include <vector>
 
 #include "jit_domain/jit_amx_configure.hpp"

nlp_toolkit/backends/neural_engine/SparseLib/include/benchmark_utils.hpp

@@ -21,17 +21,17 @@
 
 #include "interface.hpp"
 
-namespace jd{
+namespace jd {
 
 /*
  * @brief Run benchmark of kernel. Currently this mainly contains 3 parts:
  *            1. Run kernel for multiple iterations to get its execution time.
  *            2. Parse primitive and use execution time to calculate GFLOPS.
  *            3. Refresh some parts of runtime data for kernel before each execution.
- *        
+ *
  *        To enable benchmark for a new kernel xxxx, you just need 2 steps:
  *            1. Implement calc_flop_xxxx and get_refresh_data_idx_xxxx for it.
- *            2. Simply add a case for it in calc_flop and get_refresh_data_idx in benchmark_utils.cpp  
+ *            2. Simply add a case for it in calc_flop and get_refresh_data_idx in benchmark_utils.cpp
  */
 void benchmarkOrExecute(kernel_proxy* kp, const std::vector<const void*>& rt_data);
 
@@ -53,17 +53,19 @@ std::vector<int> get_refresh_data_idx(const kernel_kind ker_kind);
 /*
  * @brief Allocate new memory for some parts of runtime data for kernel.
  */
-bool alloc_new_mem(const std::vector<tensor_desc>& ts_descs, std::vector<const void*>& rt_data, std::vector<void*>& new_data, const std::vector<int>& idx);
+bool alloc_new_mem(const std::vector<tensor_desc>& ts_descs, std::vector<const void*>& rt_data,    // NOLINT
+                   std::vector<void*>& new_data, const std::vector<int>& idx);                     // NOLINT
 
 /*
  * @brief Free new memory for some parts of runtime data for kernel.
  */
-void free_new_mem(std::vector<void*>& new_data);
+void free_new_mem(std::vector<void*>& new_data);    // NOLINT
 
 /*
  * @brief Refresh some parts of runtime data for kernel.
  */
-void refresh_data(const std::vector<tensor_desc>& ts_descs, std::vector<void*>& new_data, const std::vector<int>& idx, const std::vector<float>& ranges = {-10.0, 10.0});
+void refresh_data(const std::vector<tensor_desc>& ts_descs, std::vector<void*>& new_data,  // NOLINT
+                  const std::vector<int>& idx, const std::vector<float>& ranges = {-10.0, 10.0});
 
 // Since different kernels use different info to calculate FLOP,
 // please implement calc_flop_xxxx for each kernel.
@@ -79,7 +81,6 @@ std::vector<int> get_refresh_data_idx_sparse_matmul();
 
 std::vector<int> get_refresh_data_idx_postop();
 
-} // namespace jd
+}  // namespace jd
 
 #endif  // ENGINE_SPARSELIB_INCLUDE_BENCHMARK_UTILS_HPP_
-

nlp_toolkit/backends/neural_engine/SparseLib/include/interface.hpp

@@ -103,23 +103,23 @@ class sparse_matmul_desc : public kernel_desc_proxy {
 
 class postop_desc : public kernel_desc_proxy {
  public:
-  postop_desc(){};
+  postop_desc() {}
   explicit postop_desc(const operator_desc& op_desc) : kernel_desc_proxy(op_desc) {}
   virtual ~postop_desc() {}
 };
 
 class eltwiseop_desc : public kernel_desc_proxy {
  public:
-  eltwiseop_desc(){};
+  eltwiseop_desc() {}
   explicit eltwiseop_desc(const operator_desc& op_desc) : kernel_desc_proxy(op_desc) {}
   virtual ~eltwiseop_desc() {}
 };
 
 class layernorm_ba_desc : public kernel_desc_proxy {
  public:
-  layernorm_ba_desc(){};
+  layernorm_ba_desc() {}
   explicit layernorm_ba_desc(const operator_desc& op_desc) : kernel_desc_proxy(op_desc) {}
-  virtual ~layernorm_ba_desc(){};
+  virtual ~layernorm_ba_desc() {}
 };
 
 /**

nlp_toolkit/backends/neural_engine/SparseLib/include/jit_domain/jit_eltwise_injector.hpp

@@ -15,11 +15,13 @@
 #ifndef ENGINE_SPARSELIB_INCLUDE_JIT_DOMAIN_JIT_ELTWISE_INJECTOR_HPP_
 #define ENGINE_SPARSELIB_INCLUDE_JIT_DOMAIN_JIT_ELTWISE_INJECTOR_HPP_
 
+#include <vector>
+#include <unordered_map>
+#include <map>
+#include <set>
 #include "jit_generator.hpp"
 #include "utils.hpp"
 #include "param_types.hpp"
-#include <map>
-#include <set>
 
 namespace jd {
 class jit_eltwise_injector {
@@ -28,7 +30,7 @@ class jit_eltwise_injector {
   using Xmm = Xbyak::Xmm;
 
  public:
-  explicit jit_eltwise_injector(){};
+  jit_eltwise_injector() {}
   virtual ~jit_eltwise_injector() {}
 
   void eltwise_injector_init(jit_generator* ptr, const std::vector<postop_attr>& postop_attrs);
@@ -37,9 +39,9 @@ class jit_eltwise_injector {
   void escape_regs(reg_type type, int reg_idx);
   void escape_erase(reg_type type, int reg_idx = -1);
   void init_tb_allocate_set(const std::vector<postop_attr>& postop_attrs);
-  int max_zmm_allocate_num() { return zmm_tb_allocate.size(); };
-  int max_mask_allocate_num() { return mask_tb_allocate.size(); };
-  int max_reg64_allocate_num() { return reg64_tb_allocate.size(); };
+  int max_zmm_allocate_num() { return zmm_tb_allocate.size(); }
+  int max_mask_allocate_num() { return mask_tb_allocate.size(); }
+  int max_reg64_allocate_num() { return reg64_tb_allocate.size(); }
   void prepare_table();
 
  private:
@@ -53,7 +55,7 @@ class jit_eltwise_injector {
   void linear_compute_vector_fwd(const Xbyak::Zmm& zmm_src);
   void register_table_entries(const std::vector<postop_attr>& postop_attrs);
   void assert_check(const std::vector<postop_attr>& postop_attrs);
-  void load_table_addr() { h->mov(p_table, l_table); };
+  void load_table_addr() { h->mov(p_table, l_table); }
 
  private:
   postop_attr cur_postop_attr_;
@@ -147,4 +149,4 @@ class jit_eltwise_injector {
   mapped_table_t entry_map;
 };
 }  // namespace jd
-#endif
+#endif

nlp_toolkit/backends/neural_engine/SparseLib/include/jit_domain/jit_eltwiseop.hpp

@@ -15,11 +15,11 @@
 #ifndef ENGINE_SPARSELIB_INCLUDE_JIT_DOMAIN_JIT_ELTWISEOP_HPP_
 #define ENGINE_SPARSELIB_INCLUDE_JIT_DOMAIN_JIT_ELTWISEOP_HPP_
 
-#include "../jit_generator.hpp"
+#include <map>
+#include "jit_generator.hpp"
 #include "utils.hpp"
 #include "kernels/eltwiseop_types.hpp"
-#include "jit_eltwise_injector.hpp"
-#include <map>
+#include "jit_domain/jit_eltwise_injector.hpp"
 
 #define ELT_GET_OFF(field) offsetof(ssd::eltwiseop_data_t, field)
 
@@ -77,7 +77,7 @@ class jit_eltwiseop_t : public jit_generator {
       case data_type::bf16:
         return 2u;
     }
-  };
+  }
 
   size_t load_offset() {
     auto head_dt = param_.postop_attrs.front().dt;
@@ -120,4 +120,4 @@ class jit_eltwiseop_t : public jit_generator {
   }
 };
 }  // namespace jd
-#endif
+#endif

nlp_toolkit/backends/neural_engine/SparseLib/include/jit_domain/jit_layernorm_ba.hpp

@@ -15,10 +15,14 @@
 #ifndef ENGINE_SPARSELIB_INCLUDE_JIT_DOMAIN_JIT_LAYERNORM_BA_HPP_
 #define ENGINE_SPARSELIB_INCLUDE_JIT_DOMAIN_JIT_LAYERNORM_BA_HPP_
 
-#include "../jit_generator.hpp"
+#include <utility>
+#include <vector>
+#include <map>
+#include <set>
+#include "jit_generator.hpp"
 #include "utils.hpp"
 #include "kernels/layernorm_ba_types.hpp"
-#include "jit_eltwise_injector.hpp"
+#include "jit_domain/jit_eltwise_injector.hpp"
 
 #define LNBA_GET_OFF(field) offsetof(ssd::layernorm_ba_data_t, field)
 
@@ -64,7 +68,7 @@ class jit_layernorm_ba_t : public jit_generator {
     mov(one_div_n, ptr[reg_param + LNBA_GET_OFF(one_div_n)]);
     mov(one, ptr[reg_param + LNBA_GET_OFF(one)]);
     mov(eps, ptr[reg_param + LNBA_GET_OFF(eps)]);
-  };
+  }
 
  private:
   ssd::layernorm_ba_param_t param_;
@@ -85,4 +89,4 @@ class jit_layernorm_ba_t : public jit_generator {
   Opmask remain_task_mask;
 };  // namespace jd
 }  // namespace jd
-#endif
+#endif

nlp_toolkit/backends/neural_engine/SparseLib/include/jit_domain/jit_postop_default.hpp

@@ -15,10 +15,10 @@
 #ifndef ENGINE_SPARSELIB_INCLUDE_JIT_DOMAIN_JIT_POSTOP_DEFAULT_HPP_
 #define ENGINE_SPARSELIB_INCLUDE_JIT_DOMAIN_JIT_POSTOP_DEFAULT_HPP_
 
+#include <map>
 #include "jit_generator.hpp"
 #include "utils.hpp"
 #include "kernels/postop_types.hpp"
-#include <map>
 
 #define GET_OFF(field) offsetof(ssd::postop_data_t, field)
 
@@ -48,7 +48,7 @@ class jit_postop_default_t : public jit_generator {
   bool is_bf16() {
     if (param_.dt == ssd::data_type::bf16) return true;
     return false;
-  };
+  }
 
   size_t vlen() {
     switch (param_.dt) {
@@ -58,7 +58,7 @@ class jit_postop_default_t : public jit_generator {
         return 32u;
     }
     return 0;
-  };
+  }
 
   size_t dtype_size() {
     switch (param_.dt) {
@@ -68,7 +68,7 @@ class jit_postop_default_t : public jit_generator {
         return 2u;
     }
     return 0;
-  };
+  }
 
  private:
   ssd::postop_param_t param_;
@@ -161,7 +161,7 @@ class jit_postop_default_t : public jit_generator {
   };
   using table_t = std::multimap<key_t, table_entry_t>;
   using mapped_table_t = std::multimap<key_t, mapped_table_entry_t>;
-  void load_table_addr() { mov(p_table, l_table); };
+  void load_table_addr() { mov(p_table, l_table); }
   void register_table_entries();
   void prepare_table();
   void prepare_bf16_mask();
@@ -175,4 +175,4 @@ class jit_postop_default_t : public jit_generator {
   mapped_table_t entry_map;
 };
 }  // namespace jd
-#endif
+#endif

nlp_toolkit/backends/neural_engine/SparseLib/include/jit_domain/jit_spmm_amx_bf16_x16.hpp

@@ -99,8 +99,8 @@ class jit_spmm_amx_bf16_x16_t : public jit_generator {
   dim_t tileM;
   bool bf16_out;
   dim_t size_of_dst_t;
-  dim_t size_of_src_t = sizeof(src_t); // size of bfloat16
-  dim_t size_of_out_t = sizeof(dst_t); // size of float since bf16 x bd16 = fp32
+  dim_t size_of_src_t = sizeof(src_t);  // size of bfloat16
+  dim_t size_of_out_t = sizeof(dst_t);  // size of float since bf16 x bd16 = fp32
 
   static constexpr int stack_space_needed_ = 5120;
 

nlp_toolkit/backends/neural_engine/SparseLib/include/jit_domain/jit_spmm_avx512f.hpp

@@ -68,7 +68,7 @@ class jit_spmm_avx512f_t : public jit_generator {
   // Register allocator of load activation. TW = 1
   Xbyak::Zmm TW_Vmm = Xbyak::Zmm(VREG_NUMS - 1 - USED_VREGS - TH_);
   // Reg alloc of DST tile.
-  Xbyak::Zmm dst_tile_Vmm(int i = 0) { return Xbyak::Zmm(i); };
+  Xbyak::Zmm dst_tile_Vmm(int i = 0) { return Xbyak::Zmm(i); }
 
   static constexpr int stack_space_needed_ = 256;
   static constexpr int BYTE8 = 8;

nlp_toolkit/backends/neural_engine/SparseLib/include/jit_domain/jit_spmm_vnni.hpp

@@ -32,7 +32,7 @@ namespace jd {
  */
 class jit_spmm_vnni_t : public jit_generator {
  public:
-  explicit jit_spmm_vnni_t(const ssd::vnni_param_t& param) : jit_generator(), param_(param){};
+  explicit jit_spmm_vnni_t(const ssd::vnni_param_t& param) : jit_generator(), param_(param) {}
   virtual ~jit_spmm_vnni_t() {}
 
  public:
@@ -80,7 +80,7 @@ class jit_spmm_vnni_t : public jit_generator {
   inline int mt_size() const { return TH(); }
   inline int n_tiles() const { return param_.BN / nt_size(); }
   inline int m_tiles() const { return param_.BM / mt_size(); }
-  inline data_type output_type() const { return param_.output_type; };
+  inline data_type output_type() const { return param_.output_type; }
   inline int ld_dst() const { return param_.BN; }  // leading dimension of dst matrix
 
  private: