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>
createasync_factory_impl38 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>
create_async(std::string logger_name,SinkArgs &&...sink_args)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>
create_async_nb(std::string logger_name,SinkArgs &&...sink_args)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.
init_thread_pool(size_t q_size,size_t thread_count,std::function<void ()> on_thread_start)76 inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
77 {
78 auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start);
79 details::registry::instance().set_tp(std::move(tp));
80 }
81
82 // set global thread pool.
init_thread_pool(size_t q_size,size_t thread_count)83 inline void init_thread_pool(size_t q_size, size_t thread_count)
84 {
85 init_thread_pool(q_size, thread_count, [] {});
86 }
87
88 // get the global thread pool.
thread_pool()89 inline std::shared_ptr<spdlog::details::thread_pool> thread_pool()
90 {
91 return details::registry::instance().get_tp();
92 }
93 } // namespace spdlog
94