Replace more std::endl with '\n' (#4471)

Summary:
X-link: facebookresearch/FBGEMM#1536

The bench/**/*.cc files were missing in previous changes.

Pull Request resolved: #4471

Reviewed By: gchalump, spcyppt

Differential Revision: D78177481

Pulled By: q10

fbshipit-source-id: 6ac413c4282f30f1e91c1c38632b0c9d540dc5b8

Author: cyyever

bench/ConvUnifiedBenchmark.cc

@@ -285,7 +285,7 @@ static void performance_test(
        << "Postprocessing (ms), " << "fbgemmPacked (ms), " << "Total (ms), "
        << "GOPS" << endl;
 #else
-  cout << setw(6) << header << setw(5) << "GOPS" << endl;
+  cout << setw(6) << header << setw(5) << "GOPS" << '\n';
 #endif
 
   chrono::time_point<chrono::high_resolution_clock> begin, end;
@@ -493,7 +493,7 @@ static void performance_test(
          << total_run_time / (double)NITER / 1e6 << ", "
          << ttot / (double)NITER / 1e6 << ", ";
 #endif
-    cout << setprecision(2) << nops / ttot << endl;
+    cout << setprecision(2) << nops / ttot << '\n';
 
     compare_buffers(
         Cint8_ref.data(),

bench/ConvertBenchmark.cc

@@ -29,7 +29,7 @@ static void performance_test() {
   default_random_engine engine;
 
   cout << setw(4) << "M" << " elements_per_ns_ref" << " elements_per_ns_simd"
-       << endl;
+       << '\n';
 
   array<int, 8> dims{1, 10, 32, 40, 129, 256, 1024, 8000};
 
@@ -59,7 +59,7 @@ static void performance_test() {
     duration_simd *= 1e9; // convert to ns
 
     cout << setw(4) << M << setw(10) << setprecision(3) << M / duration_ref
-         << setw(10) << setprecision(3) << M / duration_simd << endl;
+         << setw(10) << setprecision(3) << M / duration_simd << '\n';
 
     compare_buffers(b_ref.data(), b.data(), M, 1, 1, 5);
   } // M

bench/Depthwise3DBenchmark.cc

@@ -212,7 +212,7 @@ int main() {
               if (expected != actual) {
                 cerr << "Depthwise 3x3x3 results differ at (" << n << ", " << t
                      << ", " << h << ", " << w << ", " << g << "). expected "
-                     << (int)expected << " actual " << (int)actual << endl;
+                     << (int)expected << " actual " << (int)actual << '\n';
                 return -1;
               }
               assert(expected == actual);

bench/DepthwiseBenchmark.cc

@@ -334,7 +334,7 @@ int main() {
             if (expected != actual) {
               cerr << "Depthwise 3x3 results differ at (" << n << ", " << h
                    << ", " << w << ", " << k << "). expected " << (int)expected
-                   << " actual " << (int)actual << endl;
+                   << " actual " << (int)actual << '\n';
               return -1;
             }
             assert(expected == actual);

bench/EmbeddingIndexRemappingBenchmark.cc

@@ -129,7 +129,7 @@ static int run_benchmark(
       NWARMUP,
       NITER);
   cout << "reference:" << duration_ref * 1e6 << " (us), ";
-  cout << "Opt:" << duration * 1e6 << " (us) " << endl;
+  cout << "Opt:" << duration * 1e6 << " (us) " << '\n';
 
   return 0;
 }
@@ -149,13 +149,13 @@ int main() {
 
     cout << "batch size" << setw(6) << batch_size << setw(10) << "num rows"
          << setw(14) << num_rows << setw(16) << "avg length" << setw(6)
-         << average_len << endl;
+         << average_len << '\n';
     cout << "64 bit indices, ";
     run_benchmark(batch_size, num_rows, average_len);
 
     cout << "32 bit indices, ";
     run_benchmark(batch_size, num_rows, average_len, true);
-    cout << endl;
+    cout << '\n';
   }
   return 0;
 }

bench/EmbeddingQuantizeBenchmark.cc

@@ -30,13 +30,13 @@ static void performance_test() {
   constexpr int NITER = 256;
 
   if constexpr (is_same_v<T, float16>) {
-    cout << "With scale and bias as float16" << endl;
+    cout << "With scale and bias as float16" << '\n';
   } else {
-    cout << "With scale and bias as float" << endl;
+    cout << "With scale and bias as float" << '\n';
   }
   cout << setw(8) << "bit_rate" << ", " << setw(6) << "rows" << "," << setw(6)
        << "cols" << "," << setw(16) << "elems_per_usec" << "," << setw(10)
-       << "GB/Sec" << endl;
+       << "GB/Sec" << '\n';
   std::vector<int> bit_rates;
   if constexpr (is_same_v<T, float16>) {
     bit_rates = {2, 4, 8};
@@ -91,7 +91,7 @@ static void performance_test() {
         cout << setw(16) << std::fixed << std::setprecision(2)
              << elements_per_usec << ", ";
         cout << setw(10) << std::fixed << std::setprecision(2)
-             << gigabyes_per_sec << endl;
+             << gigabyes_per_sec << '\n';
       } // for each cols
     } // for each rows
   } // for each bit_rate

bench/EmbeddingQuantizeFloatToFloatOrHalfBenchmark.cc

@@ -30,12 +30,12 @@ static void performance_test() {
   constexpr int NITER = 256;
 
   if constexpr (is_same_v<T, float16>) {
-    cout << "With result as float16" << endl;
+    cout << "With result as float16" << '\n';
   } else {
-    cout << "With result as float" << endl;
+    cout << "With result as float" << '\n';
   }
   cout << setw(6) << "rows" << "," << setw(6) << "cols" << "," << setw(16)
-       << "elems_per_usec" << "," << setw(10) << "GB/Sec" << endl;
+       << "elems_per_usec" << "," << setw(10) << "GB/Sec" << '\n';
 
   for (int rowSize : {100, 120, 1000}) {
     for (int colSize : {16, 64, 128, 256, 512, 1024, 2048}) {
@@ -79,7 +79,7 @@ static void performance_test() {
       cout << setw(16) << std::fixed << std::setprecision(2)
            << elements_per_usec << ", ";
       cout << setw(10) << std::fixed << std::setprecision(2) << gigabyes_per_sec
-           << endl;
+           << '\n';
     } // for each cols
   } // for each rows
 } // performance_test

bench/EmbeddingSpMDM8BitBenchmark.cc

@@ -102,7 +102,7 @@ static int run_benchmark(
   // Compute the number of indices
   int lengths_sum = offsets[batch_size];
   if (fbgemm_get_thread_num() == 0) {
-    cout << "lengths_sum " << lengths_sum << endl;
+    cout << "lengths_sum " << lengths_sum << '\n';
   }
 
   // Generate indices
@@ -274,11 +274,11 @@ static int run_benchmark(
               }
             } else {
               assert(false && "ERROR: unsupported output type");
-              cout << "ERROR: unsupported output type" << endl;
+              cout << "ERROR: unsupported output type" << '\n';
             }
             assert(fabs(tmp1 - tmp2) < 1e-3);
             if (fabs(tmp1 - tmp2) >= 1e-3) {
-              cout << i << " " << tmp1 << " " << tmp2 << endl;
+              cout << i << " " << tmp1 << " " << tmp2 << '\n';
             }
           }
         }
@@ -298,7 +298,7 @@ static int run_benchmark(
           }
         } else {
           assert(false && "ERROR: unsupported output type");
-          cout << "ERROR: unsupported output type" << endl;
+          cout << "ERROR: unsupported output type" << '\n';
         }
 
         if (has_weight) {
@@ -331,7 +331,7 @@ static int run_benchmark(
              << " GB/s" << setw(20) << "effective b/w: " << setw(16)
              << bytes_padded / 1e9 / max_time << "GB/s" << setw(8) << " time "
              << setw(16) << max_time << " load_imbalance " << load_imbalance
-             << endl;
+             << '\n';
       }
     } // flush_cache
   } // has_weight
@@ -354,7 +354,7 @@ int main() {
     cout << "batch size" << setw(6) << batch_size << setw(10) << "num rows"
          << setw(16) << num_rows << setw(10) << "emb dim" << setw(6)
          << embedding_dim << setw(16) << "avg length" << setw(6) << average_len
-         << endl;
+         << '\n';
     // args: batch sz, num rows, emb dim, avg len, normalize, use 32b,
     // prefetch
     cout << "64 bit indices, ";

bench/EmbeddingSpMDMBenchmark.cc

@@ -94,7 +94,7 @@ static void run_benchmark(
 
   // Compute the number of indices
   int lengths_sum = offsets[batch_size];
-  cout << "lengths_sum " << lengths_sum << endl;
+  cout << "lengths_sum " << lengths_sum << '\n';
 
   // Generate indices
   vector<int64_t> indices;
@@ -353,7 +353,7 @@ static void run_benchmark(
           for (size_t i = 0; i < output.size(); ++i) {
             assert(output[i] == output_ref[i]);
             if (output[i] != output_ref[i]) {
-              cout << i << " " << output[i] << " " << output_ref[i] << endl;
+              cout << i << " " << output[i] << " " << output_ref[i] << '\n';
             }
           }
         }
@@ -378,7 +378,7 @@ static void run_benchmark(
       cout << setw(8) << "b/w" << setw(10) << bytes / 1e9 / t << " GB/s"
            << setw(20) << "effective b/w: " << setw(16)
            << bytes_padded / 1e9 / t << "GB/s" << setw(8) << " time "
-           << setw(16) << t << endl;
+           << setw(16) << t << '\n';
     } // flush_cache
   } // has_weight
 }
@@ -396,7 +396,7 @@ int main() {
     cout << "batch size" << setw(6) << batch_size << setw(10) << "num rows"
          << setw(16) << num_rows << setw(10) << "emb dim" << setw(6)
          << embedding_dim << setw(16) << "avg length" << setw(6) << average_len
-         << endl;
+         << '\n';
 
     for (bool normalize_by_lengths : {false, true}) {
       for (std::string input_dtype : {"bf16", "fp16", "fp32"}) {

bench/EmbeddingSpMDMNBit2Benchmark.cc

@@ -142,7 +142,7 @@ static void print_benchmark_results() {
       << "asmjit b/w (GB/s), asmjit effective b/w (GB/s), asmjit time, "
       << "autovec b/w (GB/s), autovec effective b/w (GB/s), autovec time, "
       << "ref b/w (GB/s), ref effective b/w (GB/s), ref time, "
-      << "asmjit speedup ratio, autovec speedup ratio" << endl;
+      << "asmjit speedup ratio, autovec speedup ratio" << '\n';
   for (auto& benchmark : benchmarks) {
     BenchmarkSpec& spec = benchmark.first;
     BenchmarkResult& res = benchmark.second;
@@ -157,7 +157,7 @@ static void print_benchmark_results() {
               << res.asmjit_time << ", " << res.autovec_bw << ", "
               << res.autovec_eff_bw << ", " << res.autovec_time << ", "
               << res.ref_bw << ", " << res.ref_eff_bw << ", " << res.ref_time
-              << ", " << asmjit_speedup << ", " << autovec_speedup << endl;
+              << ", " << asmjit_speedup << ", " << autovec_speedup << '\n';
   }
 }
 
@@ -456,7 +456,7 @@ static int run_benchmark(
         find_benchmark_record(spec).set_asmjit_result(
             bytes / 1e9 / t, bytes_padded / 1e9 / t, t);
       } else {
-        std::cerr << "Bad kern_type parameter: " << kern_type << endl;
+        std::cerr << "Bad kern_type parameter: " << kern_type << '\n';
         assert(false);
       }
       if (!success) {