mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2024-11-15 16:35:45 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Updated latency tests

Browse Source
This commit is contained in:
gabime 2018-10-30 00:08:49 +02:00
parent 7377bfcf07
commit 04d577262a
1 changed files with 44 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
bench/latency.cpp
View File

@ -15,44 +15,28 @@
#include "spdlog/sinks/daily_file_sink.h" #include "spdlog/sinks/daily_file_sink.h"
#include "spdlog/sinks/null_sink.h" #include "spdlog/sinks/null_sink.h"
#include "spdlog/sinks/rotating_file_sink.h" #include "spdlog/sinks/rotating_file_sink.h"
#include <chrono>
#include "utils.h"
#include <atomic>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
using namespace std;
using namespace std::chrono;
using namespace spdlog;
using namespace spdlog::sinks;
using namespace utils;
void prepare_logdir() void prepare_logdir()
{ {
spdlog::info("Preparing logs_bench directory.."); spdlog::info("Preparing latency_logs directory..");
#ifdef _WIN32 #ifdef _WIN32
system("if not exist logs mkdir logs_bench"); system("if not exist logs mkdir latency_logs");
system("del /F /Q logs\\*"); system("del /F /Q logs\\*");
#else #else
auto rv = system("mkdir -p logs_bench"); auto rv = system("mkdir -p latency_logs");
if (rv != 0) if (rv != 0)
{ {
throw std::runtime_error("Failed to mkdir -p logs_bench"); throw std::runtime_error("Failed to mkdir -p latency_logs");
} }
rv = system("rm -f logs_bench/*"); rv = system("rm -f latency_logs/*");
if (rv != 0) if (rv != 0)
{ {
throw std::runtime_error("Failed to rm -f logs_bench/*"); throw std::runtime_error("Failed to rm -f latency_logs/*");
} }
#endif #endif
} }
void bench_c_string(benchmark::State& state, std::shared_ptr<spdlog::logger> logger) void bench_c_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
{ {
const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus " const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
"lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem " "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
@ -60,15 +44,13 @@ void bench_c_string(benchmark::State& state, std::shared_ptr<spdlog::logger> log
"augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare " "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
"nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis."; "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
for (auto _ : state) for (auto _ : state)
{ {
logger->info(msg); logger->info(msg);
} }
} }
void bench_logger(benchmark::State& state, std::shared_ptr<spdlog::logger> logger) void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
{ {
int i = 0; int i = 0;
for (auto _ : state) for (auto _ : state)
@ -77,95 +59,74 @@ void bench_logger(benchmark::State& state, std::shared_ptr<spdlog::logger> logge
} }
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
using spdlog::sinks::null_sink_st ; spdlog::set_pattern("[tid %t] %v");
using spdlog::sinks::null_sink_mt ;
using spdlog::sinks::basic_file_sink_st;
using spdlog::sinks::basic_file_sink_mt; 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;
size_t file_size = 30 * 1024 * 1024; size_t file_size = 30 * 1024 * 1024;
size_t rotating_files = 5; size_t rotating_files = 5;
int n_threads = 10; int n_threads = benchmark::CPUInfo::Get().num_cpus;
int iters = 1000000;
prepare_logdir(); prepare_logdir();
// // Single threaded benchmarks
// Single threaded bench auto disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
// disabled_logger->set_level(spdlog::level::off);
auto null_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>()); benchmark::RegisterBenchmark("disabled-level", bench_logger, disabled_logger)->UseRealTime();
benchmark::RegisterBenchmark("null_sink_st-500_bytes_cstr", bench_c_string, null_logger) auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
->UseRealTime() benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st))->UseRealTime();
->Iterations(iters);
benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger) benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
->UseRealTime()
->Iterations(iters);
// basic_st // basic_st
auto basic_st = spdlog::basic_logger_st("basic_st", "logs_bench/basic_st.log", true); 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)) benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
->UseRealTime()
->Iterations(iters);
spdlog::drop("basic_st"); spdlog::drop("basic_st");
// rotating st // rotating st
auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs_bench/rotating_st.log", file_size, rotating_files); 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)) benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
->UseRealTime()
->Iterations(iters);
spdlog::drop("rotating_st"); spdlog::drop("rotating_st");
// daily st // daily st
auto daily_st = spdlog::daily_logger_mt("daily_st", "logs_bench/daily_st.log"); auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st)) benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
->UseRealTime()
->Iterations(iters);
spdlog::drop("daily_st"); spdlog::drop("daily_st");
// // //
// Multi threaded bench, 10 using same logger concurrently // // 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>()); 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) benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)->Threads(n_threads)->UseRealTime();
->Threads(n_threads)
->UseRealTime()
->Iterations(iters/n_threads);
// basic_mt // basic_mt
auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs_bench/basic_mt.log", true); 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)) benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
->Threads(n_threads)
->UseRealTime()
->Iterations(iters/n_threads);
spdlog::drop("basic_mt"); spdlog::drop("basic_mt");
// rotating mt // rotating mt
auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs_bench/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)) benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))->Threads(n_threads)->UseRealTime();
->Threads(n_threads)
->UseRealTime()
->Iterations(iters/n_threads);
spdlog::drop("rotating_mt"); spdlog::drop("rotating_mt");
// daily mt // daily mt
auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs_bench/daily_mt.log"); auto daily_mt = spdlog::daily_logger_mt("daily_mt", "latency_logs/daily_mt.log");
benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt)) benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))->Threads(n_threads)->UseRealTime();
->Threads(n_threads)
->UseRealTime()
->Iterations(iters/n_threads);
spdlog::drop("daily_mt"); spdlog::drop("daily_mt");
// async
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();
benchmark::Initialize(&argc, argv); benchmark::Initialize(&argc, argv);
benchmark::RunSpecifiedBenchmarks(); benchmark::RunSpecifiedBenchmarks();
} }