clang format

bench/async_bench.cpp

@@ -44,8 +44,7 @@ void verify_file(const char *filename, int expected_count) {
     spdlog::info("Verifying {} to contain {} line..", filename, expected_count);
     auto count = count_lines(filename);
     if (count != expected_count) {
-        spdlog::error("Test failed. {} has {} lines instead of {}", filename, count,
-                      expected_count);
+        spdlog::error("Test failed. {} has {} lines instead of {}", filename, count, expected_count);
         exit(1);
     }
     spdlog::info("Line count OK ({})\n", count);
@@ -85,8 +84,7 @@ int main(int argc, char *argv[]) {
         spdlog::info("Messages     : {:L}", howmany);
         spdlog::info("Threads      : {:L}", threads);
         spdlog::info("Queue        : {:L} slots", queue_size);
-        spdlog::info("Queue memory : {:L} x {:L} = {:L} KB ", queue_size, slot_size,
-                     (queue_size * slot_size) / 1024);
+        spdlog::info("Queue memory : {:L} x {:L} = {:L} KB ", queue_size, slot_size, (queue_size * slot_size) / 1024);
         spdlog::info("Total iters  : {:L}", iters);
         spdlog::info("-------------------------------------------------");
 
@@ -98,8 +96,8 @@ int main(int argc, char *argv[]) {
         for (int i = 0; i < iters; i++) {
             auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
             auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-            auto logger = std::make_shared<async_logger>(
-                "async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
+            auto logger = std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp),
+                                                         async_overflow_policy::block);
             bench_mt(howmany, std::move(logger), threads);
             // verify_file(filename, howmany);
         }
@@ -113,9 +111,8 @@ int main(int argc, char *argv[]) {
         for (int i = 0; i < iters; i++) {
             auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
             auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-            auto logger =
-                std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp),
-                                               async_overflow_policy::overrun_oldest);
+            auto logger = std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp),
+                                                         async_overflow_policy::overrun_oldest);
             bench_mt(howmany, std::move(logger), threads);
         }
         spdlog::shutdown();
@@ -142,8 +139,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_co
     int msgs_per_thread_mod = howmany % thread_count;
     for (int t = 0; t < thread_count; ++t) {
         if (t == 0 && msgs_per_thread_mod)
-            threads.push_back(
-                std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
+            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
         else
             threads.push_back(std::thread(thread_fun, logger, msgs_per_thread));
     }

bench/bench.cpp

@@ -38,16 +38,15 @@ static const int max_threads = 1000;
 
 void bench_threaded_logging(size_t threads, int iters) {
     spdlog::info("**************************************************************");
-    spdlog::info(spdlog::fmt_lib::format(
-        std::locale("en_US.UTF-8"), "Multi threaded: {:L} threads, {:L} messages", threads, iters));
+    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "Multi threaded: {:L} threads, {:L} messages",
+                                         threads, iters));
     spdlog::info("**************************************************************");
 
     auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
     bench_mt(iters, std::move(basic_mt), threads);
 
     spdlog::info("");
-    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size,
-                                                  rotating_files);
+    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
     bench_mt(iters, std::move(rotating_mt), threads);
 
     spdlog::info("");
@@ -62,16 +61,14 @@ void bench_threaded_logging(size_t threads, int iters) {
 
 void bench_single_threaded(int iters) {
     spdlog::info("**************************************************************");
-    spdlog::info(
-        spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "Single threaded: {} messages", iters));
+    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "Single threaded: {} messages", iters));
     spdlog::info("**************************************************************");
 
     auto basic_st = spdlog::basic_logger_st("basic_st", "logs/basic_st.log", true);
     bench(iters, std::move(basic_st));
 
     spdlog::info("");
-    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size,
-                                                  rotating_files);
+    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
     bench(iters, std::move(rotating_st));
 
     spdlog::info("");
@@ -98,8 +95,7 @@ int main(int argc, char *argv[]) {
         }
 
         if (threads > max_threads) {
-            throw std::runtime_error(
-                spdlog::fmt_lib::format("Number of threads exceeds maximum({})", max_threads));
+            throw std::runtime_error(spdlog::fmt_lib::format("Number of threads exceeds maximum({})", max_threads));
         }
 
         bench_single_threaded(iters);
@@ -125,9 +121,8 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log) {
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
 
-    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"),
-                                         "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(),
-                                         delta_d, size_t(howmany / delta_d)));
+    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec",
+                                         log->name(), delta_d, size_t(howmany / delta_d)));
     spdlog::drop(log->name());
 }
 
@@ -153,9 +148,8 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_co
 
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"),
-                                         "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(),
-                                         delta_d, size_t(howmany / delta_d)));
+    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec",
+                                         log->name(), delta_d, size_t(howmany / delta_d)));
     spdlog::drop(log->name());
 }
 

bench/formatter-bench.cpp

@@ -11,8 +11,7 @@ void bench_formatter(benchmark::State &state, std::string pattern) {
     auto formatter = std::make_unique<spdlog::pattern_formatter>(pattern);
     spdlog::memory_buf_t dest;
     std::string logger_name = "logger-name";
-    const char *text =
-        "Hello. This is some message with length of 80                                   ";
+    const char *text = "Hello. This is some message with length of 80                                   ";
 
     spdlog::source_loc source_loc{"a/b/c/d/myfile.cpp", 123, "some_func()"};
     spdlog::details::log_msg msg(source_loc, logger_name, spdlog::level::info, text);
@@ -47,8 +46,7 @@ void bench_formatters() {
         "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] [%t] %v",
     };
     for (auto &pattern : patterns) {
-        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern)
-            ->Iterations(2500000);
+        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern)->Iterations(2500000);
     }
 }
 

bench/latency.cpp

@@ -55,8 +55,7 @@ void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logge
     }
 }
 
-void bench_disabled_macro_global_logger(benchmark::State &state,
-                                        std::shared_ptr<spdlog::logger> logger) {
+void bench_disabled_macro_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
     spdlog::set_default_logger(std::move(logger));
     int i = 0;
     benchmark::DoNotOptimize(i);       // prevent unused warnings
@@ -69,13 +68,11 @@ void bench_disabled_macro_global_logger(benchmark::State &state,
 #ifdef __linux__
 void bench_dev_null() {
     auto dev_null_st = spdlog::basic_logger_st("/dev/null_st", "/dev/null");
-    benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))
-        ->UseRealTime();
+    benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))->UseRealTime();
     spdlog::drop("/dev/null_st");
 
     auto dev_null_mt = spdlog::basic_logger_mt("/dev/null_mt", "/dev/null");
-    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))
-        ->UseRealTime();
+    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))->UseRealTime();
     spdlog::drop("/dev/null_mt");
 }
 #endif  // __linux__
@@ -91,23 +88,18 @@ int main(int argc, char *argv[]) {
     auto full_bench = argc > 1 && std::string(argv[1]) == "full";
 
     // disabled loggers
-    auto disabled_logger =
-        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+    auto disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
     disabled_logger->set_level(spdlog::level::off);
     benchmark::RegisterBenchmark("disabled-at-compile-time", bench_disabled_macro, disabled_logger);
-    benchmark::RegisterBenchmark("disabled-at-compile-time (global logger)",
-                                 bench_disabled_macro_global_logger, disabled_logger);
-    benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger);
-    benchmark::RegisterBenchmark("disabled-at-runtime (global logger)", bench_global_logger,
+    benchmark::RegisterBenchmark("disabled-at-compile-time (global logger)", bench_disabled_macro_global_logger,
                                  disabled_logger);
+    benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger);
+    benchmark::RegisterBenchmark("disabled-at-runtime (global logger)", bench_global_logger, disabled_logger);
 
-    auto null_logger_st =
-        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
-    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string,
-                                 std::move(null_logger_st));
+    auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
+    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st));
     benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
-    benchmark::RegisterBenchmark("null_sink_st (global logger)", bench_global_logger,
-                                 null_logger_st);
+    benchmark::RegisterBenchmark("null_sink_st (global logger)", bench_global_logger, null_logger_st);
 
 #ifdef __linux
     bench_dev_null();
@@ -120,10 +112,9 @@ int main(int argc, char *argv[]) {
         spdlog::drop("basic_st");
 
         // rotating st
-        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log",
-                                                      file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))
-            ->UseRealTime();
+        auto rotating_st =
+            spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
         spdlog::drop("rotating_st");
 
         // daily st
@@ -134,22 +125,17 @@ int main(int argc, char *argv[]) {
         //
         // Multi threaded bench, 10 loggers using same logger concurrently
         //
-        auto null_logger_mt =
-            std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-        benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)
-            ->Threads(n_threads)
-            ->UseRealTime();
+        auto null_logger_mt = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
+        benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)->Threads(n_threads)->UseRealTime();
 
         // basic_mt
         auto basic_mt = spdlog::basic_logger_mt("basic_mt", "latency_logs/basic_mt.log", true);
-        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))
-            ->Threads(n_threads)
-            ->UseRealTime();
+        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
         spdlog::drop("basic_mt");
 
         // rotating mt
-        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log",
-                                                      file_size, rotating_files);
+        auto rotating_mt =
+            spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
         benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))
             ->Threads(n_threads)
             ->UseRealTime();
@@ -157,9 +143,7 @@ int main(int argc, char *argv[]) {
 
         // daily mt
         auto daily_mt = spdlog::daily_logger_mt("daily_mt", "latency_logs/daily_mt.log");
-        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))
-            ->Threads(n_threads)
-            ->UseRealTime();
+        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))->Threads(n_threads)->UseRealTime();
         spdlog::drop("daily_mt");
     }
 
@@ -167,11 +151,8 @@ int main(int argc, char *argv[]) {
     auto queue_size = 1024 * 1024 * 3;
     auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
     auto async_logger = std::make_shared<spdlog::async_logger>(
-        "async_logger", std::make_shared<null_sink_mt>(), std::move(tp),
-        spdlog::async_overflow_policy::overrun_oldest);
-    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)
-        ->Threads(n_threads)
-        ->UseRealTime();
+        "async_logger", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
+    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)->Threads(n_threads)->UseRealTime();
     benchmark::Initialize(&argc, argv);
     benchmark::RunSpecifiedBenchmarks();
 }