src: common: addressed clang-tidy warnings

Author: vpirogov

src/common/concat_pd.hpp

@@ -112,14 +112,14 @@ struct concat_pd_t : public primitive_desc_t {
         init_desc();
     }
 
-    concat_pd_t(const concat_pd_t &other) : primitive_desc_t(other) {
-        n_ = other.n_;
-        concat_dim_ = other.concat_dim_;
-        dst_md_ = other.dst_md_;
-        original_dst_ = other.original_dst_;
-        src_mds_ = other.src_mds_;
-        src_image_mds_ = other.src_image_mds_;
-
+    concat_pd_t(const concat_pd_t &other)
+        : primitive_desc_t(other)
+        , n_(other.n_)
+        , concat_dim_(other.concat_dim_)
+        , dst_md_(other.dst_md_)
+        , original_dst_(other.original_dst_)
+        , src_mds_(other.src_mds_)
+        , src_image_mds_(other.src_image_mds_) {
         init_desc();
     }
 

src/common/ittnotify.hpp

@@ -24,7 +24,9 @@ namespace dnnl {
 namespace impl {
 namespace itt {
 
-typedef enum {
+// GCC treats using and typedef diffently for enums and structs
+// https://stackoverflow.com/questions/48613758
+typedef enum { // NOLINT(modernize-use-using)
     __itt_task_level_none = 0,
     __itt_task_level_low,
     __itt_task_level_high

src/common/memory_desc_wrapper.hpp

@@ -34,6 +34,7 @@ namespace impl {
 
 /** thin wrapper class over \struct memory_desc_t which allows easy
  * manipulations with underlying C structure, which is taken by reference */
+// NOLINTNEXTLINE(readability-identifier-naming)
 struct memory_desc_wrapper : public c_compatible {
     const memory_desc_t *md_;
 

src/common/memory_tracking.hpp

@@ -428,8 +428,8 @@ struct registry_t {
     public:
         common_iterator_t(const void *base_ptr_,
                 const std::unordered_map<key_t, entry_t> &map,
-                bool is_begin = true) {
-            base_ptr = base_ptr_;
+                bool is_begin = true)
+            : base_ptr(base_ptr_) {
             if (is_begin) {
                 iter = map.cbegin();
             } else {

src/common/nstl.hpp

@@ -55,7 +55,7 @@ void *malloc(size_t size, int alignment);
 #endif
 void free(void *p);
 
-struct c_compatible {
+struct c_compatible { // NOLINT(readability-identifier-naming)
     enum { default_alignment = 64 };
     static void *operator new(size_t sz) {
         return MALLOC(sz, default_alignment);

src/common/reorder_pd.hpp

@@ -160,10 +160,10 @@ struct reorder_pd_t : public primitive_desc_t {
         init_desc(src_engine_kind, dst_engine_kind, false);
     }
 
-    reorder_pd_t(const reorder_pd_t &other) : primitive_desc_t(other) {
-        src_md_ = other.src_md_;
-        dst_md_ = other.dst_md_;
-
+    reorder_pd_t(const reorder_pd_t &other)
+        : primitive_desc_t(other)
+        , src_md_(other.src_md_)
+        , dst_md_(other.dst_md_) {
         init_desc(other.desc_.src_engine_kind, other.desc_.dst_engine_kind,
                 other.desc_.is_cross_engine);
     }

src/common/sum_pd.hpp

@@ -116,14 +116,14 @@ struct sum_pd_t : public primitive_desc_t {
         init_desc();
     }
 
-    sum_pd_t(const sum_pd_t &other) : primitive_desc_t(other) {
-        n_ = other.n_;
-        scales_ = other.scales_;
-        dst_md_ = other.dst_md_;
-        dst_acc_md_ = other.dst_acc_md_;
-        src_mds_ = other.src_mds_;
-        original_dst_md_ = other.original_dst_md_;
-
+    sum_pd_t(const sum_pd_t &other)
+        : primitive_desc_t(other)
+        , n_(other.n_)
+        , scales_(other.scales_)
+        , dst_md_(other.dst_md_)
+        , dst_acc_md_(other.dst_acc_md_)
+        , src_mds_(other.src_mds_)
+        , original_dst_md_(other.original_dst_md_) {
         init_desc();
     }
     sum_pd_t &operator=(const sum_pd_t &other) {

src/common/utils.hpp

@@ -124,7 +124,7 @@ struct conditional<false, T, F> {
 };
 
 template <bool, typename, bool, typename, typename>
-struct conditional3 {};
+struct conditional3 {}; // NOLINT(readability-identifier-naming)
 template <typename T, typename FT, typename FF>
 struct conditional3<true, T, false, FT, FF> {
     using type = T;
@@ -139,7 +139,7 @@ struct conditional3<false, T, false, FT, FF> {
 };
 
 template <bool, typename U, U, U>
-struct conditional_v {};
+struct conditional_v {}; // NOLINT(readability-identifier-naming)
 template <typename U, U t, U f>
 struct conditional_v<true, U, t, f> {
     static constexpr U value = t;
@@ -252,7 +252,7 @@ inline void array_set(T *arr, const U &val, size_t size) {
 
 namespace product_impl {
 template <size_t>
-struct int2type {};
+struct int2type {}; // NOLINT(readability-identifier-naming)
 
 template <typename T>
 constexpr int product_impl(const T *arr, int2type<0>) {
@@ -479,11 +479,10 @@ T pick_by_prop_kind(prop_kind_t prop_kind, const T &val_fwd, const T &val_bwd_d,
 }
 
 template <typename Telem, size_t Tdims>
-struct array_offset_calculator {
+struct array_offset_calculator { // NOLINT(readability-identifier-naming)
     template <typename... Targs>
-    array_offset_calculator(Telem *base, Targs... Fargs) : _dims {Fargs...} {
-        _base_ptr = base;
-    }
+    array_offset_calculator(Telem *base, Targs... Fargs)
+        : _base_ptr(base), _dims {Fargs...} {}
 
     template <typename... Targs>
     array_offset_calculator(std::nullptr_t, Targs... Fargs) = delete;
@@ -824,16 +823,10 @@ using maybe_unique_ptr = std::unique_ptr<T, nop_deleter_t>;
 struct nibble2_t {
 
     // constructs a nibble pair from a pair of uint8_t values
-    nibble2_t(uint8_t low_, uint8_t high_) {
-        low = low_;
-        high = high_;
-    }
+    nibble2_t(uint8_t low_, uint8_t high_) : low(low_), high(high_) {}
 
     // constructs a nibble pairs from an uin8_t, taking its low and high part
-    nibble2_t(uint8_t pack_) {
-        low = pack_ & 0xf;
-        high = (pack_ >> 4) & 0xf;
-    }
+    nibble2_t(uint8_t pack_) : low(pack_ & 0xf), high((pack_ >> 4) & 0xf) {}
 
     // sets low (idx=0) or high (idx=1)  nibble.
     inline void set(uint8_t val, int idx) {
@@ -869,7 +862,7 @@ static_assert(sizeof(nibble2_t) == 1, "nibble2_t must be 1 byte");
 ///     printf("%d\t", idx);
 /// }
 /// output: 0  2  3
-class mask_iterator {
+class mask_iterator { // NOLINT(readability-identifier-naming)
     int mask_;
     int index_;