mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2025-03-29 09:22:41 +08:00
Code

clang format

Browse Source
This commit is contained in:
gabime 2018-07-10 23:53:00 +03:00
parent d409e5367b
commit 16ee72da7c
8 changed files with 200 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
bench/bench.cpp
View File

@ -32,7 +32,6 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
int howmany = 1000000; int howmany = 1000000;
int queue_size = howmany + 2; int queue_size = howmany + 2;
int threads = 10; int threads = 10;
@ -76,7 +75,7 @@ int main(int argc, char *argv[])
auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log"); auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
bench_mt(howmany, daily_mt, threads); bench_mt(howmany, daily_mt, threads);
bench_mt(howmany, spdlog::create<null_sink_mt>("null_mt"), threads); bench_mt(howmany, spdlog::create<null_sink_mt>("null_mt"), threads);
cout << "\n*******************************************************************************\n"; cout << "\n*******************************************************************************\n";
cout << "async logging.. " << threads << " threads sharing same logger, " << format(howmany) << " iterations " << endl; cout << "async logging.. " << threads << " threads sharing same logger, " << format(howmany) << " iterations " << endl;
@ -112,7 +111,7 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
auto delta = high_resolution_clock::now() - start; auto delta = high_resolution_clock::now() - start;
auto delta_d = duration_cast<duration<double>>(delta).count(); auto delta_d = duration_cast<duration<double>>(delta).count();
cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl; cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
spdlog::drop(log->name()); spdlog::drop(log->name());
} }
void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count) void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)

16
bench/latency.cpp
View File

@ -29,9 +29,9 @@ using namespace utils;
void bench(int howmany, std::shared_ptr<spdlog::logger> log); void bench(int howmany, std::shared_ptr<spdlog::logger> log);
void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count); void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
int main(int , char *[]) int main(int, char *[])
{ {
std::srand(static_cast<unsigned>(std::time(nullptr))); // use current time as seed for random generator std::srand(static_cast<unsigned>(std::time(nullptr))); // use current time as seed for random generator
int howmany = 1000000; int howmany = 1000000;
int queue_size = howmany + 2; int queue_size = howmany + 2;
int threads = 10; int threads = 10;
@ -91,7 +91,6 @@ int main(int , char *[])
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
void bench(int howmany, std::shared_ptr<spdlog::logger> log) void bench(int howmany, std::shared_ptr<spdlog::logger> log)
{ {
using namespace std::chrono; using namespace std::chrono;
@ -106,10 +105,10 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
auto start = high_resolution_clock::now(); auto start = high_resolution_clock::now();
log->info("Hello logger: msg number {}", i); log->info("Hello logger: msg number {}", i);
auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start); auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
total_nanos+= delta_nanos; total_nanos += delta_nanos;
} }
auto avg = total_nanos.count()/howmany; auto avg = total_nanos.count() / howmany;
cout << format(avg) << " ns/call" << endl; cout << format(avg) << " ns/call" << endl;
} }
@ -131,7 +130,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
auto start = high_resolution_clock::now(); auto start = high_resolution_clock::now();
log->info("Hello logger: msg number {}", j); log->info("Hello logger: msg number {}", j);
auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start); auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
total_nanos+= delta_nanos.count(); total_nanos += delta_nanos.count();
} }
})); }));
} }
@ -141,9 +140,6 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
t.join(); t.join();
}; };
auto avg = total_nanos/howmany; auto avg = total_nanos / howmany;
cout << format(avg) << " ns/call" << endl; cout << format(avg) << " ns/call" << endl;
} }

10
include/spdlog/details/fmt_helper.h
View File

@ -9,14 +9,14 @@ namespace spdlog {
namespace details { namespace details {
namespace fmt_helper { namespace fmt_helper {
template <size_t Buffer_Size> template<size_t Buffer_Size>
inline void append_str(const std::string &str, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void append_str(const std::string &str, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{ {
auto *str_ptr = str.data(); auto *str_ptr = str.data();
dest.append(str_ptr, str_ptr + str.size()); dest.append(str_ptr, str_ptr + str.size());
} }
template <size_t Buffer_Size> template<size_t Buffer_Size>
inline void append_c_str(const char *c_str, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void append_c_str(const char *c_str, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{ {
char ch; char ch;
@ -41,7 +41,7 @@ inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
dest.append(i.data(), i.data() + i.size()); dest.append(i.data(), i.data() + i.size());
} }
template <size_t Buffer_Size> template<size_t Buffer_Size>
inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{ {
if (n > 99) if (n > 99)
@ -65,7 +65,7 @@ inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
fmt::format_to(dest, "{:02}", n); fmt::format_to(dest, "{:02}", n);
} }
template <size_t Buffer_Size> template<size_t Buffer_Size>
inline void pad3(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void pad3(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{ {
if (n > 99) if (n > 99)
@ -91,7 +91,7 @@ inline void pad3(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
fmt::format_to(dest, "{:03}", n); fmt::format_to(dest, "{:03}", n);
} }
template <size_t Buffer_Size> template<size_t Buffer_Size>
inline void pad6(size_t n, fmt::basic_memory_buffer<char, Buffer_Size> &dest) inline void pad6(size_t n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{ {
// todo: maybe replace this implementation with // todo: maybe replace this implementation with

32
include/spdlog/details/logger_impl.h
View File

@ -175,23 +175,23 @@ inline void spdlog::logger::critical(const T &msg)
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template<typename... Args>
inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const Args &... args) inline void spdlog::logger::log(level::level_enum lvl, const wchar_t *fmt, const Args &... args)
{ {
if (!should_log(lvl)) if (!should_log(lvl))
{ {
return; return;
} }
decltype(wstring_converter_)::byte_string utf8_string;
try decltype(wstring_converter_)::byte_string utf8_string;
{
{ try
std::lock_guard<std::mutex> lock(wstring_converter_mutex_); {
utf8_string = wstring_converter_.to_bytes(fmt); {
} std::lock_guard<std::mutex> lock(wstring_converter_mutex_);
log(lvl, utf8_string.c_str(), args...); utf8_string = wstring_converter_.to_bytes(fmt);
} }
SPDLOG_CATCH_AND_HANDLE log(lvl, utf8_string.c_str(), args...);
}
SPDLOG_CATCH_AND_HANDLE
} }
template<typename... Args> template<typename... Args>

8
include/spdlog/details/pattern_formatter.h
View File

@ -120,7 +120,7 @@ class c_formatter SPDLOG_FINAL : public flag_formatter
{ {
void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{ {
//fmt::format_to(dest, "{} {} {} ", days[tm_time.tm_wday], months[tm_time.tm_mon], tm_time.tm_mday); // fmt::format_to(dest, "{} {} {} ", days[tm_time.tm_wday], months[tm_time.tm_mon], tm_time.tm_mday);
// date // date
fmt_helper::append_str(days[tm_time.tm_wday], dest); fmt_helper::append_str(days[tm_time.tm_wday], dest);
dest.push_back(' '); dest.push_back(' ');
@ -496,7 +496,7 @@ class full_formatter SPDLOG_FINAL : public flag_formatter
// cache the millis part for the next milli. // cache the millis part for the next milli.
auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000; auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
if(millis != millis_cache_timestamp_ || cached_millis_.size() == 0) if (millis != millis_cache_timestamp_ || cached_millis_.size() == 0)
{ {
cached_millis_.resize(0); cached_millis_.resize(0);
fmt_helper::pad3(static_cast<int>(millis), cached_millis_); fmt_helper::pad3(static_cast<int>(millis), cached_millis_);
@ -528,8 +528,8 @@ class full_formatter SPDLOG_FINAL : public flag_formatter
} }
private: private:
std::chrono::seconds cache_timestamp_ {0}; std::chrono::seconds cache_timestamp_{0};
std::chrono::milliseconds::rep millis_cache_timestamp_ {0}; std::chrono::milliseconds::rep millis_cache_timestamp_{0};
fmt::basic_memory_buffer<char, 128> cached_datetime_; fmt::basic_memory_buffer<char, 128> cached_datetime_;
fmt::basic_memory_buffer<char, 8> cached_millis_; fmt::basic_memory_buffer<char, 8> cached_millis_;
}; };

310
include/spdlog/details/thread_pool.h
View File

@ -10,37 +10,39 @@
#include <vector> #include <vector>
namespace spdlog { namespace spdlog {
namespace details { namespace details {
using async_logger_ptr = std::shared_ptr<spdlog::async_logger>; using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
enum class async_msg_type enum class async_msg_type
{ {
log, log,
flush, flush,
terminate terminate
}; };
// Async msg to move to/from the queue // Async msg to move to/from the queue
// Movable only. should never be copied // Movable only. should never be copied
struct async_msg struct async_msg
{ {
async_msg_type msg_type; async_msg_type msg_type;
level::level_enum level; level::level_enum level;
log_clock::time_point time; log_clock::time_point time;
size_t thread_id; size_t thread_id;
fmt::basic_memory_buffer<char, 176> raw; fmt::basic_memory_buffer<char, 176> raw;
size_t msg_id; size_t msg_id;
async_logger_ptr worker_ptr; async_logger_ptr worker_ptr;
async_msg() = default; async_msg() = default;
~async_msg() = default; ~async_msg() = default;
// should only be moved in or out of the queue.. // should only be moved in or out of the queue..
async_msg(const async_msg &) = delete; async_msg(const async_msg &) = delete;
#if defined(_MSC_VER) && _MSC_VER <= 1800 // support for vs2013 move
async_msg(async_msg &&other) SPDLOG_NOEXCEPT : msg_type(other.msg_type), // support for vs2013 move
#if defined(_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&other) SPDLOG_NOEXCEPT : msg_type(other.msg_type),
level(other.level), level(other.level),
time(other.time), time(other.time),
thread_id(other.thread_id), thread_id(other.thread_id),
@ -59,161 +61,159 @@ namespace spdlog {
raw = std::move(other.raw); raw = std::move(other.raw);
msg_id = other.msg_id; msg_id = other.msg_id;
worker_ptr = std::move(other.worker_ptr); worker_ptr = std::move(other.worker_ptr);
return *this; return *this;
} }
#else #else // (_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&other) = default; async_msg(async_msg &&other) = default;
async_msg &operator=(async_msg &&other) = default; async_msg &operator=(async_msg &&other) = default;
#endif #endif
// construct from log_msg with given type // construct from log_msg with given type
async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &&m) async_msg(async_logger_ptr &&worker, async_msg_type the_type, details::log_msg &&m)
: msg_type(the_type) : msg_type(the_type)
, level(m.level) , level(m.level)
, time(m.time) , time(m.time)
, thread_id(m.thread_id) , thread_id(m.thread_id)
, msg_id(m.msg_id) , msg_id(m.msg_id)
, worker_ptr(std::forward<async_logger_ptr>(worker)) , worker_ptr(std::forward<async_logger_ptr>(worker))
{ {
fmt_helper::append_buf(m.raw, raw); fmt_helper::append_buf(m.raw, raw);
} }
async_msg(async_logger_ptr &&worker, async_msg_type the_type) async_msg(async_logger_ptr &&worker, async_msg_type the_type)
: async_msg(std::forward<async_logger_ptr>(worker), the_type, details::log_msg()) : async_msg(std::forward<async_logger_ptr>(worker), the_type, details::log_msg())
{ {
} }
async_msg(async_msg_type the_type) async_msg(async_msg_type the_type)
: async_msg(nullptr, the_type, details::log_msg()) : async_msg(nullptr, the_type, details::log_msg())
{ {
} }
// copy into log_msg // copy into log_msg
void to_log_msg(log_msg &msg) void to_log_msg(log_msg &msg)
{ {
msg.logger_name = &worker_ptr->name(); msg.logger_name = &worker_ptr->name();
msg.level = level; msg.level = level;
msg.time = time; msg.time = time;
msg.thread_id = thread_id; msg.thread_id = thread_id;
fmt_helper::append_buf(raw, msg.raw); fmt_helper::append_buf(raw, msg.raw);
msg.msg_id = msg_id; msg.msg_id = msg_id;
msg.color_range_start = 0; msg.color_range_start = 0;
msg.color_range_end = 0; msg.color_range_end = 0;
} }
}; };
class thread_pool class thread_pool
{
public:
using item_type = async_msg;
using q_type = details::mpmc_blocking_queue<item_type>;
using clock_type = std::chrono::steady_clock;
thread_pool(size_t q_max_items, size_t threads_n)
: q_(q_max_items)
{
// std::cout << "thread_pool() q_size_bytes: " << q_size_bytes << "\tthreads_n: " << threads_n << std::endl;
if (threads_n == 0 || threads_n > 1000)
{ {
public: throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid range is 1-1000)");
using item_type = async_msg; }
using q_type = details::mpmc_blocking_queue<item_type>; for (size_t i = 0; i < threads_n; i++)
using clock_type = std::chrono::steady_clock; {
threads_.emplace_back(std::bind(&thread_pool::worker_loop_, this));
}
}
thread_pool(size_t q_max_items, size_t threads_n) // message all threads to terminate gracefully join them
: q_(q_max_items) ~thread_pool()
{
try
{
for (size_t i = 0; i < threads_.size(); i++)
{ {
// std::cout << "thread_pool() q_size_bytes: " << q_size_bytes << "\tthreads_n: " << threads_n << std::endl; post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
if (threads_n == 0 || threads_n > 1000)
{
throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid range is 1-1000)");
}
for (size_t i = 0; i < threads_n; i++)
{
threads_.emplace_back(std::bind(&thread_pool::worker_loop_, this));
}
} }
// message all threads to terminate gracefully join them for (auto &t : threads_)
~thread_pool()
{ {
try t.join();
{
for (size_t i = 0; i < threads_.size(); i++)
{
post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
}
for (auto &t : threads_)
{
t.join();
}
}
catch (...)
{
}
} }
}
catch (...)
{
}
}
void post_log(async_logger_ptr &&worker_ptr, details::log_msg &&msg, async_overflow_policy overflow_policy) void post_log(async_logger_ptr &&worker_ptr, details::log_msg &&msg, async_overflow_policy overflow_policy)
{ {
async_msg async_m(std::forward<async_logger_ptr>(worker_ptr), async_msg_type::log, std::forward<log_msg>(msg)); async_msg async_m(std::forward<async_logger_ptr>(worker_ptr), async_msg_type::log, std::forward<log_msg>(msg));
post_async_msg_(std::move(async_m), overflow_policy); post_async_msg_(std::move(async_m), overflow_policy);
} }
void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy) void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
{ {
post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy); post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
} }
private: private:
q_type q_; q_type q_;
std::vector<std::thread> threads_; std::vector<std::thread> threads_;
void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy) void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
{ {
if (overflow_policy == async_overflow_policy::block) if (overflow_policy == async_overflow_policy::block)
{ {
q_.enqueue(std::move(new_msg)); q_.enqueue(std::move(new_msg));
} }
else else
{ {
q_.enqueue_nowait(std::move(new_msg)); q_.enqueue_nowait(std::move(new_msg));
} }
} }
void worker_loop_() void worker_loop_()
{ {
while (process_next_msg_()) while (process_next_msg_()) {};
{ }
};
}
// process next message in the queue // process next message in the queue
// return true if this thread should still be active (while no terminate msg was received) // return true if this thread should still be active (while no terminate msg was received)
bool process_next_msg_() bool process_next_msg_()
{ {
async_msg incoming_async_msg; async_msg incoming_async_msg;
bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10)); bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
if (!dequeued) if (!dequeued)
{ {
return true; return true;
} }
switch (incoming_async_msg.msg_type) switch (incoming_async_msg.msg_type)
{ {
case async_msg_type::flush: case async_msg_type::flush:
{ {
incoming_async_msg.worker_ptr->backend_flush_(); incoming_async_msg.worker_ptr->backend_flush_();
return true; return true;
} }
case async_msg_type::terminate: case async_msg_type::terminate:
{ {
return false; return false;
} }
default: default:
{ {
log_msg msg; log_msg msg;
incoming_async_msg.to_log_msg(msg); incoming_async_msg.to_log_msg(msg);
incoming_async_msg.worker_ptr->backend_log_(msg); incoming_async_msg.worker_ptr->backend_log_(msg);
return true; return true;
} }
} }
assert(false); assert(false);
return true; // should not be reached return true; // should not be reached
} }
}; };
} // namespace details } // namespace details
} // namespace spdlog } // namespace spdlog

6
include/spdlog/logger.h
View File

@ -63,7 +63,7 @@ public:
template<typename... Args> template<typename... Args>
void critical(const char *fmt, const Args &... args); void critical(const char *fmt, const Args &... args);
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template<typename... Args>
void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args); void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args);
@ -151,8 +151,8 @@ protected:
std::atomic<size_t> msg_counter_; std::atomic<size_t> msg_counter_;
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
std::wstring_convert<std::codecvt_utf8<wchar_t>> wstring_converter_; std::wstring_convert<std::codecvt_utf8<wchar_t>> wstring_converter_;
std::mutex wstring_converter_mutex_; std::mutex wstring_converter_mutex_;
#endif #endif
}; };
} // namespace spdlog } // namespace spdlog

17
include/spdlog/sinks/rotating_file_sink.h
View File

@ -95,14 +95,15 @@ private:
} }
if (details::file_helper::file_exists(src) && details::os::rename(src, target) != 0) if (details::file_helper::file_exists(src) && details::os::rename(src, target) != 0)
{ {
// if failed try again after small delay. // if failed try again after small delay.
// this is a workaround to a windows issue, where very high rotation rates sometimes fail (because of antivirus?). // this is a workaround to a windows issue, where very high rotation rates sometimes fail (because of antivirus?).
details::os::sleep_for_millis(20); details::os::sleep_for_millis(20);
details::os::remove(target); details::os::remove(target);
if (details::os::rename(src, target) != 0) if (details::os::rename(src, target) != 0)
{ {
throw spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno); throw spdlog_ex(
} "rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno);
}
} }
} }
file_helper_.reopen(true); file_helper_.reopen(true);