Update CMakeLists.txt

CMakeLists.txt

@@ -70,7 +70,7 @@ option(SPDLOG_BUILD_EXAMPLE "Build example" ${SPDLOG_MASTER_PROJECT})
 option(SPDLOG_BUILD_EXAMPLE_HO "Build header only example" OFF)
 
 # testing options
-option(SPDLOG_BUILD_TESTS "Build tests" ${SPDLOG_MASTER_PROJECT})
+option(SPDLOG_BUILD_TESTS "Build tests" OFF)
 option(SPDLOG_BUILD_TESTS_HO "Build tests using the header only version" OFF)
 
 # bench options
@@ -80,7 +80,7 @@ option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/
 option(SPDLOG_SANITIZE_ADDRESS "Enable address sanitizer in tests" OFF)
 
 # warning options
-option(SPDLOG_ENABLE_WARNINGS "Enable compiler warnings" OFF)
+option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
 
 # install options
 option(SPDLOG_INSTALL "Generate the install target" ${SPDLOG_MASTER_PROJECT})

bench/bench.cpp

@@ -120,7 +120,7 @@ int main(int argc, char *argv[])
             threads = std::stoi(argv[2]);
         }
 
-        if(threads > max_threads)
+        if (threads > max_threads)
         {
             throw std::runtime_error(fmt::format("Number of threads exceeds maximum({}})", max_threads));
         }
@@ -139,9 +139,9 @@ int main(int argc, char *argv[])
 
 void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 {
-    using std::chrono::high_resolution_clock;
     using std::chrono::duration;
     using std::chrono::duration_cast;
+    using std::chrono::high_resolution_clock;
 
     auto start = high_resolution_clock::now();
     for (auto i = 0; i < howmany; ++i)
@@ -158,9 +158,9 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 
 void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
 {
-    using std::chrono::high_resolution_clock;
     using std::chrono::duration;
     using std::chrono::duration_cast;
+    using std::chrono::high_resolution_clock;
 
     std::vector<std::thread> threads;
     threads.reserve(thread_count);

bench/latency.cpp

@@ -51,11 +51,21 @@ void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logge
     }
 }
 
+#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();
+    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();
+    spdlog::drop("/dev/null_mt");
+}
+#endif // __linux__
+
 int main(int argc, char *argv[])
 {
-
-    using spdlog::sinks::basic_file_sink_mt;
-    using spdlog::sinks::basic_file_sink_st;
     using spdlog::sinks::null_sink_mt;
     using spdlog::sinks::null_sink_st;
 
@@ -63,6 +73,8 @@ int main(int argc, char *argv[])
     size_t rotating_files = 5;
     int n_threads = benchmark::CPUInfo::Get().num_cpus;
 
+    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>());
     disabled_logger->set_level(spdlog::level::off);
@@ -81,54 +93,61 @@ int main(int argc, char *argv[])
     tracing_null_logger_st->enable_backtrace(64);
     benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);
 
-    // basic_st
-    auto basic_st = spdlog::basic_logger_st("basic_st", "latency_logs/basic_st.log", true);
-    benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
-    spdlog::drop("basic_st");
-    // with backtrace of 64
-    auto tracing_basic_st = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
-    tracing_basic_st->enable_backtrace(64);
-    benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime();
-    spdlog::drop("tracing_basic_st");
+#ifdef __linux
+    bench_dev_null();
+#endif // __linux__
 
-    // 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();
-    spdlog::drop("rotating_st");
-    // with backtrace of 64
-    auto tracing_rotating_st =
-        spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files);
-    benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime();
-    spdlog::drop("tracing_rotating_st");
+    if (full_bench)
+    {
+        // basic_st
+        auto basic_st = spdlog::basic_logger_st("basic_st", "latency_logs/basic_st.log", true);
+        benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
+        spdlog::drop("basic_st");
+        // with backtrace of 64
+        auto tracing_basic_st = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
+        tracing_basic_st->enable_backtrace(64);
+        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime();
+        spdlog::drop("tracing_basic_st");
 
-    // daily st
-    auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
-    benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
-    spdlog::drop("daily_st");
-    auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
-    benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger, std::move(tracing_daily_st))->UseRealTime();
-    spdlog::drop("tracing_daily_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();
+        spdlog::drop("rotating_st");
+        // with backtrace of 64
+        auto tracing_rotating_st =
+            spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files);
+        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime();
+        spdlog::drop("tracing_rotating_st");
 
-    //
-    // 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();
+        // daily st
+        auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
+        benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
+        spdlog::drop("daily_st");
+        auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
+        benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger, std::move(tracing_daily_st))->UseRealTime();
+        spdlog::drop("tracing_daily_st");
 
-    // 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();
-    spdlog::drop("basic_mt");
+        //
+        // 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();
 
-    // rotating mt
-    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();
-    spdlog::drop("rotating_mt");
+        // 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();
+        spdlog::drop("basic_mt");
 
-    // 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();
-    spdlog::drop("daily_mt");
+        // rotating mt
+        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();
+        spdlog::drop("rotating_mt");
+
+        // 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();
+        spdlog::drop("daily_mt");
+    }
 
     // async
     auto queue_size = 1024 * 1024 * 3;

cmake/utils.cmake

@@ -28,7 +28,7 @@ endfunction()
 
 # Turn on warnings on the given target
 function(spdlog_enable_warnings target_name)
-    if(SPDLOG_ENABLE_WARNINGS)
+    if(SPDLOG_BUILD_WARNINGS)
         if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
             list(APPEND MSVC_OPTIONS "/W3")
             if(MSVC_VERSION GREATER  1900)  #Allow non fatal security wanrnings for msvc 2015

include/spdlog/cfg/argv.h

@@ -38,7 +38,7 @@ void load_argv_levels(int argc, const char **argv)
 
 void load_argv_levels(int argc, char **argv)
 {
-    load_argv_levels(argc, const_cast<const char**>(argv));
+    load_argv_levels(argc, const_cast<const char **>(argv));
 }
 
 } // namespace cfg

include/spdlog/details/fmt_helper.h

@@ -63,7 +63,7 @@ template<typename T>
 inline void pad_uint(T n, unsigned int width, memory_buf_t &dest)
 {
     static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
-    for(auto digits = count_digits(n); digits < width; digits++)
+    for (auto digits = count_digits(n); digits < width; digits++)
     {
         dest.push_back('0');
     }

tests/test_daily_logger.cpp

@@ -113,7 +113,7 @@ static void test_rotate(int days_to_run, uint16_t max_days, uint16_t expected_n_
     using spdlog::log_clock;
     using spdlog::details::log_msg;
     using spdlog::sinks::daily_file_sink_st;
-    
+
     prepare_logdir();
 
     std::string basename = "test_logs/daily_rotate.txt";

tests/test_mpmc_q.cpp

@@ -86,7 +86,7 @@ TEST_CASE("full_queue", "[mpmc_blocking_q]")
     spdlog::details::mpmc_blocking_queue<int> q(q_size);
     for (int i = 0; i < static_cast<int>(q_size); i++)
     {
-        q.enqueue(i+0); // i+0 to force rvalue and avoid tidy warnings on the same time if we std::move(i) instead
+        q.enqueue(i + 0); // i+0 to force rvalue and avoid tidy warnings on the same time if we std::move(i) instead
     }
 
     q.enqueue_nowait(123456);

tests/test_pattern_formatter.cpp

@@ -308,7 +308,7 @@ TEST_CASE("clone-formatter-2", "[pattern_formatter]")
 class custom_test_flag : public spdlog::custom_flag_formatter
 {
 public:
-     explicit custom_test_flag(std::string txt)
+    explicit custom_test_flag(std::string txt)
         : some_txt{std::move(txt)}
     {}
 
@@ -359,7 +359,7 @@ TEST_CASE("clone-custom_formatter", "[pattern_formatter]")
 #ifdef _WIN32
 static const char *const test_path = "\\a\\b\\myfile.cpp";
 #else
-static const char * const test_path = "/a/b//myfile.cpp";
+static const char *const test_path = "/a/b//myfile.cpp";
 #endif
 
 TEST_CASE("short filename formatter-1", "[pattern_formatter]")

tests/test_registry.cpp

@@ -1,7 +1,7 @@
 #include "includes.h"
 
-static const char * const tested_logger_name = "null_logger";
-static const char * const tested_logger_name2 = "null_logger2";
+static const char *const tested_logger_name = "null_logger";
+static const char *const tested_logger_name2 = "null_logger2";
 
 #ifndef SPDLOG_NO_EXCEPTIONS
 TEST_CASE("register_drop", "[registry]")