1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. |
2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) |
3 | |
4 | #pragma once |
5 | |
6 | // |
7 | // Async logging using global thread pool |
8 | // All loggers created here share same global thread pool. |
9 | // Each log message is pushed to a queue along with a shared pointer to the |
10 | // logger. |
11 | // If a logger deleted while having pending messages in the queue, it's actual |
12 | // destruction will defer |
13 | // until all its messages are processed by the thread pool. |
14 | // This is because each message in the queue holds a shared_ptr to the |
15 | // originating logger. |
16 | |
17 | #include <spdlog/async_logger.h> |
18 | #include <spdlog/details/registry.h> |
19 | #include <spdlog/details/thread_pool.h> |
20 | |
21 | #include <memory> |
22 | #include <mutex> |
23 | #include <functional> |
24 | |
25 | namespace spdlog { |
26 | |
27 | namespace details { |
28 | static const size_t default_async_q_size = 8192; |
29 | } |
30 | |
31 | // async logger factory - creates async loggers backed with thread pool. |
32 | // if a global thread pool doesn't already exist, create it with default queue |
33 | // size of 8192 items and single thread. |
34 | template<async_overflow_policy OverflowPolicy = async_overflow_policy::block> |
35 | struct async_factory_impl |
36 | { |
37 | template<typename Sink, typename... SinkArgs> |
38 | static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args) |
39 | { |
40 | auto ®istry_inst = details::registry::instance(); |
41 | |
42 | // create global thread pool if not already exists.. |
43 | |
44 | auto &mutex = registry_inst.tp_mutex(); |
45 | std::lock_guard<std::recursive_mutex> tp_lock(mutex); |
46 | auto tp = registry_inst.get_tp(); |
47 | if (tp == nullptr) |
48 | { |
49 | tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U); |
50 | registry_inst.set_tp(tp); |
51 | } |
52 | |
53 | auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); |
54 | auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy); |
55 | registry_inst.initialize_logger(new_logger); |
56 | return new_logger; |
57 | } |
58 | }; |
59 | |
60 | using async_factory = async_factory_impl<async_overflow_policy::block>; |
61 | using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>; |
62 | |
63 | template<typename Sink, typename... SinkArgs> |
64 | inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args) |
65 | { |
66 | return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); |
67 | } |
68 | |
69 | template<typename Sink, typename... SinkArgs> |
70 | inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args) |
71 | { |
72 | return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); |
73 | } |
74 | |
75 | // set global thread pool. |
76 | inline void init_thread_pool( |
77 | size_t q_size, size_t thread_count, std::function<void()> on_thread_start, std::function<void()> on_thread_stop) |
78 | { |
79 | auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start, on_thread_stop); |
80 | details::registry::instance().set_tp(std::move(tp)); |
81 | } |
82 | |
83 | inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start) |
84 | { |
85 | init_thread_pool(q_size, thread_count, on_thread_start, [] {}); |
86 | } |
87 | |
88 | inline void init_thread_pool(size_t q_size, size_t thread_count) |
89 | { |
90 | init_thread_pool( |
91 | q_size, thread_count, [] {}, [] {}); |
92 | } |
93 | |
94 | // get the global thread pool. |
95 | inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() |
96 | { |
97 | return details::registry::instance().get_tp(); |
98 | } |
99 | } // namespace spdlog |
100 | |