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

wip backtracer

Browse Source
This commit is contained in:
gabime 2019-09-05 01:25:00 +03:00
parent 433785dc64
commit 5c2855e1c1
9 changed files with 193 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bench/bench.cpp
View File

@ -59,7 +59,6 @@ void bench_threaded_logging(int threads, int iters)
daily_mt_tracing->enable_backtrace(32);
bench_mt(iters, std::move(daily_mt_tracing), threads);
spdlog::info("");
auto empty_logger = std::make_shared<spdlog::logger>("level-off");
empty_logger->set_level(spdlog::level::off);
@ -68,7 +67,6 @@ void bench_threaded_logging(int threads, int iters)
empty_logger_tracing->set_level(spdlog::level::off);
empty_logger_tracing->enable_backtrace(32);
bench(iters, empty_logger_tracing);
}
void bench_single_threaded(int iters)
@ -77,7 +75,6 @@ void bench_single_threaded(int iters)
spdlog::info("Single threaded: {:n} messages", iters);
spdlog::info("**************************************************************");
auto basic_st = spdlog::basic_logger_st("basic_st", "logs/basic_st.log", true);
bench(iters, std::move(basic_st));

74
include/spdlog/details/backtracer-inl.h Normal file
View File

@ -0,0 +1,74 @@
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include "spdlog/details/backtracer.h"
#endif
namespace spdlog {
namespace details {
SPDLOG_INLINE backtracer::backtracer(const backtracer &other)
{
std::lock_guard<std::mutex> lock(other.mutex_);
enabled_ = other.enabled();
messages_ = other.messages_;
}
SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT
{
std::lock_guard<std::mutex> lock(other.mutex_);
enabled_ = other.enabled();
messages_ = std::move(other.messages_);
}
SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other)
{
std::lock_guard<std::mutex> lock(mutex_);
enabled_ = other.enabled();
messages_ = other.messages_;
return *this;
}
SPDLOG_INLINE void backtracer::enable(size_t size)
{
std::lock_guard<std::mutex> lock{mutex_};
enabled_.store(true, std::memory_order_relaxed);
messages_ = circular_q<log_msg_buffer>{size};
}
SPDLOG_INLINE void backtracer::disable()
{
std::lock_guard<std::mutex> lock{mutex_};
enabled_.store(false, std::memory_order_relaxed);
}
SPDLOG_INLINE bool backtracer::enabled() const
{
return enabled_.load(std::memory_order_relaxed);
}
SPDLOG_INLINE backtracer::operator bool() const
{
return enabled();
}
SPDLOG_INLINE void backtracer::push_back(const log_msg &msg)
{
std::lock_guard<std::mutex> lock{mutex_};
messages_.push_back(log_msg_buffer{msg});
}
// pop all items in the q and apply the given fun on each of them.
SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)
{
std::lock_guard<std::mutex> lock{mutex_};
while (!messages_.empty())
{
log_msg_buffer popped;
messages_.pop_front(popped);
fun(popped);
}
}
} // namespace details
} // namespace spdlog

94
include/spdlog/details/backtracer.h
View File

@ -12,80 +12,34 @@
// Useful for storing debug data in case of error/warning happens.
namespace spdlog {
namespace details {
class backtracer
{
mutable std::mutex mutex_;
std::atomic<bool> enabled_ {false};
circular_q<log_msg_buffer> messages_;
namespace details {
class backtracer
{
mutable std::mutex mutex_;
std::atomic<bool> enabled_{false};
circular_q<log_msg_buffer> messages_;
public:
backtracer() = default;
backtracer(const backtracer& other)
{
std::lock_guard<std::mutex> lock(other.mutex_);
enabled_ = other.enabled();
messages_ = other.messages_;
}
backtracer(backtracer&& other) SPDLOG_NOEXCEPT
{
std::lock_guard<std::mutex> lock(other.mutex_);
enabled_ = other.enabled();
messages_ = std::move(other.messages_);
}
backtracer& operator=(backtracer other)
{
std::lock_guard<std::mutex> lock(mutex_);
enabled_ = other.enabled();
messages_ = other.messages_;
return *this;
}
void enable(size_t size)
{
std::lock_guard<std::mutex> lock{ mutex_ };
enabled_.store(true, std::memory_order_relaxed);
messages_ = circular_q<log_msg_buffer>{ size };
}
public:
backtracer() = default;
backtracer(const backtracer &other);
void disable()
{
std::lock_guard<std::mutex> lock{ mutex_ };
enabled_.store(false, std::memory_order_relaxed);
}
backtracer(backtracer &&other) SPDLOG_NOEXCEPT;
backtracer &operator=(backtracer other);
void enable(size_t size);
void disable();
bool enabled() const;
explicit operator bool() const;
void push_back(const log_msg &msg);
// pop all items in the q and apply the given fun on each of them.
void foreach_pop(std::function<void(const details::log_msg &)> fun);
bool enabled() const
{
return enabled_.load(std::memory_order_relaxed);
}
};
explicit operator bool() const
{
return enabled();
}
void push_back(const log_msg &msg)
{
std::lock_guard<std::mutex> lock{ mutex_ };
messages_.push_back(log_msg_buffer{ msg });
}
// pop all items in the q and apply the given fun on each of them.
void foreach_pop(std::function<void(const details::log_msg &)> fun)
{
std::lock_guard<std::mutex> lock{ mutex_ };
while (!messages_.empty())
{
log_msg_buffer popped;
messages_.pop_front(popped);
fun(popped);
}
}
};
} // namespace details
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "backtracer-inl.h"
#endif

169
include/spdlog/details/circular_q.h
View File

@ -7,100 +7,95 @@
#include <vector>
namespace spdlog {
namespace details {
template<typename T>
class circular_q
namespace details {
template<typename T>
class circular_q
{
size_t max_items_ = 0;
typename std::vector<T>::size_type head_ = 0;
typename std::vector<T>::size_type tail_ = 0;
size_t overrun_counter_ = 0;
std::vector<T> v_;
public:
using item_type = T;
// empty cir
circular_q() = default;
explicit circular_q(size_t max_items)
: max_items_(max_items + 1) // one item is reserved as marker for full q
, v_(max_items_)
{}
circular_q(const circular_q &) = default;
circular_q &operator=(const circular_q &) = default;
// move cannot be default,
// since we need to reset head_, tail_, etc to zero in the moved object
circular_q(circular_q &&other) SPDLOG_NOEXCEPT
{
copy_moveable(std::move(other));
}
circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT
{
copy_moveable(std::move(other));
return *this;
}
// push back, overrun (oldest) item if no room left
void push_back(T &&item)
{
if (max_items_ > 0)
{
size_t max_items_ = 0;
typename std::vector<T>::size_type head_ = 0;
typename std::vector<T>::size_type tail_ = 0;
size_t overrun_counter_ = 0;
std::vector<T> v_;
v_[tail_] = std::move(item);
tail_ = (tail_ + 1) % max_items_;
public:
using item_type = T;
// empty cir
circular_q() = default;
explicit circular_q(size_t max_items)
: max_items_(max_items + 1) // one item is reserved as marker for full q
, v_(max_items_)
{}
circular_q(const circular_q&) = default;
circular_q& operator=(const circular_q&) = default;
// move cannot be default,
// since we need to reset head_, tail_, etc to zero in the moved object
circular_q(circular_q&& other) SPDLOG_NOEXCEPT
if (tail_ == head_) // overrun last item if full
{
copy_moveable(std::move(other));
head_ = (head_ + 1) % max_items_;
++overrun_counter_;
}
}
}
circular_q& operator=(circular_q&& other) SPDLOG_NOEXCEPT
{
copy_moveable(std::move(other));
return *this;
}
// Pop item from front.
// If there are no elements in the container, the behavior is undefined.
void pop_front(T &popped_item)
{
if (max_items_ > 0)
{
popped_item = std::move(v_[head_]);
head_ = (head_ + 1) % max_items_;
}
}
bool empty()
{
return tail_ == head_;
}
// push back, overrun (oldest) item if no room left
void push_back(T &&item)
{
if(max_items_ > 0)
{
v_[tail_] = std::move(item);
tail_ = (tail_ + 1) % max_items_;
bool full()
{
// head is ahead of the tail by 1
return ((tail_ + 1) % max_items_) == head_;
}
if (tail_ == head_) // overrun last item if full
{
head_ = (head_ + 1) % max_items_;
++overrun_counter_;
}
}
}
size_t overrun_counter() const
{
return overrun_counter_;
}
// Pop item from front.
// If there are no elements in the container, the behavior is undefined.
void pop_front(T &popped_item)
{
if(max_items_ > 0)
{
popped_item = std::move(v_[head_]);
head_ = (head_ + 1) % max_items_;
}
}
bool empty()
{
return tail_ == head_;
}
bool full()
{
// head is ahead of the tail by 1
return ((tail_ + 1) % max_items_) == head_;
}
size_t overrun_counter() const
{
return overrun_counter_;
}
private:
void copy_moveable(circular_q&& other) SPDLOG_NOEXCEPT
{
max_items_ = other.max_items_;
head_ = other.head_;
tail_ = other.tail_;
overrun_counter_ = other.overrun_counter_,
v_ = std::move(other.v_);
other.max_items_ = 0; // disable other
}
};
} // namespace details
private:
void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
{
max_items_ = other.max_items_;
head_ = other.head_;
tail_ = other.tail_;
overrun_counter_ = other.overrun_counter_, v_ = std::move(other.v_);
other.max_items_ = 0; // disable other
}
};
} // namespace details
} // namespace spdlog

3
include/spdlog/logger-inl.h
View File

@ -23,8 +23,7 @@ SPDLOG_INLINE logger::logger(const logger &other)
, flush_level_(other.flush_level_.load(std::memory_order_relaxed))
, custom_err_handler_(other.custom_err_handler_)
, tracer_(other.tracer_)
{
}
{}
SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)),
sinks_(std::move(other.sinks_)),

4
include/spdlog/sinks/daily_file_sink.h
View File

@ -30,8 +30,8 @@ struct daily_filename_calculator
{
filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
return fmt::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"),
basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext);
return fmt::format(
SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext);
}
};

10
include/spdlog/sinks/rotating_file_sink-inl.h
View File

@ -43,12 +43,12 @@ SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
template<typename Mutex>
SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename, std::size_t index)
{
if(index == 0u)
{
return filename;
}
if (index == 0u)
{
return filename;
}
filename_t basename, ext;
filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
return fmt::format(SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext);
}

2
src/spdlog.cpp
View File

@ -12,7 +12,7 @@
#include "spdlog/spdlog-inl.h"
#include "spdlog/common-inl.h"
#include "spdlog/details/backtracer-inl.h"
#include "spdlog/logger-inl.h"
template spdlog::logger::logger(std::string name, sinks_init_list::iterator begin, sinks_init_list::iterator end);

7
tests/test_misc.cpp
View File

@ -2,7 +2,6 @@
#include "test_sink.h"
#include "spdlog/fmt/bin_to_hex.h"
template<class T>
std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info)
{
@ -109,7 +108,7 @@ TEST_CASE("clone-logger", "[clone]")
logger->info("Some message 1");
cloned->info("Some message 2");
REQUIRE(test_sink->lines().size()==2);
REQUIRE(test_sink->lines().size() == 2);
REQUIRE(test_sink->lines()[0] == "Some message 1");
REQUIRE(test_sink->lines()[1] == "Some message 2");
@ -121,7 +120,7 @@ TEST_CASE("clone async", "[clone]")
using namespace spdlog;
spdlog::init_thread_pool(4, 1);
auto test_sink = std::make_shared<sinks::test_sink_st >();
auto test_sink = std::make_shared<sinks::test_sink_st>();
auto logger = std::make_shared<spdlog::async_logger>("orig", test_sink, spdlog::thread_pool());
logger->set_pattern("%v");
auto cloned = logger->clone("clone");
@ -136,7 +135,7 @@ TEST_CASE("clone async", "[clone]")
spdlog::details::os::sleep_for_millis(10);
REQUIRE(test_sink->lines().size()==2);
REQUIRE(test_sink->lines().size() == 2);
REQUIRE(test_sink->lines()[0] == "Some message 1");
REQUIRE(test_sink->lines()[1] == "Some message 2");