blob: 3cfaa187e1c6051e5f49c36e49cde0302d7c552d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
* Copyright Andrey Semashev 2007 - 2015.
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*/
/*!
* \file unbounded_fifo_queue.hpp
* \author Andrey Semashev
* \date 24.07.2011
*
* The header contains implementation of unbounded FIFO queueing strategy for
* the asynchronous sink frontend.
*/
#ifndef BOOST_LOG_SINKS_UNBOUNDED_FIFO_QUEUE_HPP_INCLUDED_
#define BOOST_LOG_SINKS_UNBOUNDED_FIFO_QUEUE_HPP_INCLUDED_
#include <boost/log/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#if defined(BOOST_LOG_NO_THREADS)
#error Boost.Log: This header content is only supported in multithreaded environment
#endif
#include <boost/log/detail/event.hpp>
#include <boost/log/detail/threadsafe_queue.hpp>
#include <boost/log/core/record_view.hpp>
#include <boost/log/detail/header.hpp>
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
namespace sinks {
/*!
* \brief Unbounded FIFO log record queueing strategy
*
* The \c unbounded_fifo_queue class is intended to be used with
* the \c asynchronous_sink frontend as a log record queueing strategy.
*
* This strategy implements the simplest logic of log record buffering between
* threads: the queue has no limits and imposes no ordering over the queued
* elements aside from the order in which they are enqueued.
* Because of this the queue provides decent performance and scalability,
* however if sink backends can't consume log records fast enough the queue
* may grow uncontrollably. When this is an issue, it is recommended to
* use one of the bounded strategies.
*/
class unbounded_fifo_queue
{
private:
typedef boost::log::aux::threadsafe_queue< record_view > queue_type;
private:
//! Thread-safe queue
queue_type m_queue;
//! Event object to block on
boost::log::aux::event m_event;
//! Interruption flag
volatile bool m_interruption_requested; // TODO: make it atomic
protected:
//! Default constructor
unbounded_fifo_queue() : m_interruption_requested(false)
{
}
//! Initializing constructor
template< typename ArgsT >
explicit unbounded_fifo_queue(ArgsT const&) : m_interruption_requested(false)
{
}
//! Enqueues log record to the queue
void enqueue(record_view const& rec)
{
m_queue.push(rec);
m_event.set_signalled();
}
//! Attempts to enqueue log record to the queue
bool try_enqueue(record_view const& rec)
{
// Assume the call never blocks
enqueue(rec);
return true;
}
//! Attempts to dequeue a log record ready for processing from the queue, does not block if the queue is empty
bool try_dequeue_ready(record_view& rec)
{
return m_queue.try_pop(rec);
}
//! Attempts to dequeue log record from the queue, does not block if the queue is empty
bool try_dequeue(record_view& rec)
{
return m_queue.try_pop(rec);
}
//! Dequeues log record from the queue, blocks if the queue is empty
bool dequeue_ready(record_view& rec)
{
// Try the fast way first
if (m_queue.try_pop(rec))
return true;
// Ok, we probably have to wait for new records
while (true)
{
m_event.wait();
if (m_interruption_requested)
{
m_interruption_requested = false;
return false;
}
if (m_queue.try_pop(rec))
return true;
}
}
//! Wakes a thread possibly blocked in the \c dequeue method
void interrupt_dequeue()
{
m_interruption_requested = true;
m_event.set_signalled();
}
};
} // namespace sinks
BOOST_LOG_CLOSE_NAMESPACE // namespace log
} // namespace boost
#include <boost/log/detail/footer.hpp>
#endif // BOOST_LOG_SINKS_UNBOUNDED_FIFO_QUEUE_HPP_INCLUDED_
|
