Modernize C++ code by clang-tidy (pytorch#4415)

Summary:
Pull Request resolved: pytorch#4415

X-link: facebookresearch/FBGEMM#1486

Apply several modernize checks.

Pull Request resolved: pytorch#4413

Reviewed By: cthi, spcyppt

Differential Revision: D77493248

Pulled By: q10

fbshipit-source-id: fd3c05913d1db5919ab37e2dc9141c72f11240c8

Author: cyyever

src/EmbeddingSpMDM.cc

@@ -91,7 +91,7 @@ template <
     bool THREAD_LOCAL = false>
 class GenEmbeddingSpMDMLookup {
  public:
-  GenEmbeddingSpMDMLookup() {}
+  GenEmbeddingSpMDMLookup() = default;
   typename ReturnFunctionSignature<
       inType,
       indxType,
@@ -235,15 +235,15 @@ GenEmbeddingSpMDMLookup<
                 offsetType,
                 outType,
                 ROWWISE_SPARSE>::jit_embedding_kernel {
-        bool is_8bit_in = std::is_same<inType, uint8_t>::value;
-        bool is_16bit_in = std::is_same<inType, uint16_t>::value;
-        bool is_16bit_out = std::is_same<outType, uint16_t>::value;
+        bool is_8bit_in = std::is_same_v<inType, uint8_t>;
+        bool is_16bit_in = std::is_same_v<inType, uint16_t>;
+        bool is_16bit_out = std::is_same_v<outType, uint16_t>;
         bool is_fp16_in = is_16bit_in && !is_bf16_in;
         bool is_fp16_out = is_16bit_out && !is_bf16_out;
 
         // TODO: Make this tunable
         int pref_dist = prefetch;
-        bool areIndices64b = std::is_same<indxType, int64_t>::value;
+        bool areIndices64b = std::is_same_v<indxType, int64_t>;
 
         asmjit::CodeHolder code;
         code.init(runtime().environment());
@@ -410,7 +410,7 @@ GenEmbeddingSpMDMLookup<
         constexpr int NUM_VEC_REG = simd_info<instSet>::NUM_VEC_REGS;
         int unroll_factor = NUM_VEC_REG;
 
-        typedef typename simd_info<instSet>::vec_reg_t vec_reg_t;
+        using vec_reg_t = typename simd_info<instSet>::vec_reg_t;
 
         int num_vec_regs_per_block = (block_size + vlen - 1) / vlen;
         int remainder = block_size % vlen;
@@ -862,7 +862,7 @@ GenEmbeddingSpMDMLookup<
               a->vmulps(out_vreg, out_vreg, vlen_inv_vreg);
             }
 
-            if (std::is_same<outType, float>::value) {
+            if (std::is_same_v<outType, float>) {
               if (remainder && vec_idx + v == num_vec_regs_per_block - 1) {
                 if (instSet == inst_set_t::avx2) {
                   a->vmaskmovps(dst_addr, mask_vreg, out_vreg.ymm());
@@ -1042,7 +1042,7 @@ typename EmbeddingSpMDMKernelSignature<inType, indxType, offsetType, outType>::
     output_stride = block_size;
   }
   if (input_stride == -1) {
-    if (std::is_same<inType, uint8_t>::value) {
+    if (std::is_same_v<inType, uint8_t>) {
       const auto scale_bias_offset =
           2 * (scale_bias_last ? sizeof(float) : sizeof(uint16_t));
       input_stride = block_size + scale_bias_offset;
@@ -1057,10 +1057,9 @@ typename EmbeddingSpMDMKernelSignature<inType, indxType, offsetType, outType>::
       throw std::runtime_error("Failed to initialize cpuinfo!");
     }
     const inst_set_t isa = fbgemmInstructionSet();
-    if ((std::is_same<inType, float>::value ||
-         std::is_same<inType, uint16_t>::value) &&
+    if ((std::is_same_v<inType, float> || std::is_same_v<inType, uint16_t>) &&
         block_size == 1 && isYmm(isa) && output_stride == block_size &&
-        input_stride == block_size && std::is_same<outType, float>::value &&
+        input_stride == block_size && std::is_same_v<outType, float> &&
         !is_asmjit_disabled()) {
       return [=](int64_t output_size,
                  int64_t index_size,
@@ -1352,7 +1351,7 @@ GenerateEmbeddingSpMDMRowWiseSparse(
     bool use_offsets) {
 #if CPUINFO_ARCH_X86 || CPUINFO_ARCH_X86_64
   int64_t input_stride = block_size;
-  if (std::is_same<inType, uint8_t>::value) {
+  if (std::is_same_v<inType, uint8_t>) {
     const auto scale_bias_offset = 2 * sizeof(float);
     input_stride = block_size + scale_bias_offset;
   }

src/EmbeddingSpMDMAutovec.cc

@@ -54,11 +54,11 @@ static inline void fill_output(
     const float* src,
     const int64_t block_size,
     const bool is_bf16_out) {
-  if (std::is_same<OutType, float>::value) {
+  if (std::is_same_v<OutType, float>) {
     for (int j = 0; j < block_size; ++j) {
       out[j] = src[j];
     }
-  } else if (std::is_same<OutType, uint16_t>::value && is_bf16_out) {
+  } else if (std::is_same_v<OutType, uint16_t> && is_bf16_out) {
     for (int j = 0; j < block_size; ++j) {
       out[j] = cpu_float2bfloat16(src[j]);
     }
@@ -72,9 +72,9 @@ static inline void fill_output(
 template <typename OutType>
 static inline EmbeddingStatsTracker::DataType get_output_type(
     const bool is_bf16_out) {
-  if (std::is_same<OutType, float>::value) {
+  if (std::is_same_v<OutType, float>) {
     return EmbeddingStatsTracker::DataType::FP32;
-  } else if (std::is_same<OutType, uint16_t>::value && is_bf16_out) {
+  } else if (std::is_same_v<OutType, uint16_t> && is_bf16_out) {
     return EmbeddingStatsTracker::DataType::BF16;
   } else {
     return EmbeddingStatsTracker::DataType::FP16;
@@ -100,7 +100,7 @@ static bool ALWAYS_INLINE EmbeddingSpMDM8Bit_autovec(
     const bool scale_bias_last,
     const bool no_bag,
     const bool is_bf16_out) {
-  constexpr bool isOutput8bit = std::is_same<OutType, uint8_t>::value;
+  constexpr bool isOutput8bit = std::is_same_v<OutType, uint8_t>;
   if (data_size < 0) {
     return false;
   }
@@ -736,7 +736,7 @@ static bool ALWAYS_INLINE EmbeddingSpMDMRowWiseSparse_autovec(
     float* out,
     const bool is_weight_positional,
     const bool use_offsets) {
-  bool is8bit = std::is_same<InType, uint8_t>::value;
+  bool is8bit = std::is_same_v<InType, uint8_t>;
 
   if (is8bit) {
     // block_size is the number of elements and fused_block_size is the size
@@ -860,17 +860,15 @@ static bool ALWAYS_INLINE EmbeddingSpMDMRowWiseSparse_autovec(
           const InType* inptr = input_row++;
           out[j] = std::fma(
               weight,
-              std::is_same<InType, float16>::value ? cpu_half2float(*inptr)
-                                                   : *inptr,
+              std::is_same_v<InType, float16> ? cpu_half2float(*inptr) : *inptr,
               out[j]);
         }
 #endif
         for (; j < block_size; ++j) {
           const InType* inptr = input_row++;
           out[j] = std::fma(
               weight,
-              std::is_same<InType, float16>::value ? cpu_half2float(*inptr)
-                                                   : *inptr,
+              std::is_same_v<InType, float16> ? cpu_half2float(*inptr) : *inptr,
               out[j]);
         }
       }
@@ -1141,7 +1139,7 @@ template <typename InType>
 static int64_t stride_SpMDMWithStrides(
     int64_t block_size,
     bool scale_bias_last) {
-  if (std::is_same<InType, uint8_t>::value) {
+  if (std::is_same_v<InType, uint8_t>) {
     const size_t scale_bias_offset =
         2 * (scale_bias_last ? sizeof(float) : sizeof(uint16_t));
     return block_size + scale_bias_offset;

src/EmbeddingSpMDMAvx2.cc

@@ -11,8 +11,7 @@
 #include "RefImplementations.h"
 #include "fbgemm/FbgemmEmbedding.h"
 
-namespace fbgemm {
-namespace internal {
+namespace fbgemm::internal {
 
 template <typename InType, typename IndexType, typename OffsetType>
 bool EmbeddingSpMDMBlockSize1_(
@@ -158,5 +157,4 @@ INSTANTIATE_SPMDM_INDEX_T(std::uint8_t)
 #undef INSTANTIATE_SPMDM_OFFSET_T
 #undef INSTANTIATE_SPMDM_BASE
 
-} // namespace internal
-} // namespace fbgemm
+} // namespace fbgemm::internal