blob: 5bfcda2bcd516fdb28ffd20343b8560308d27c86 (
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
143
144
145
146
147
|
/*
* 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 block_on_overflow.hpp
* \author Andrey Semashev
* \date 04.01.2012
*
* The header contains implementation of \c block_on_overflow strategy for handling
* queue overflows in bounded queues for the asynchronous sink frontend.
*/
#ifndef BOOST_LOG_SINKS_BLOCK_ON_OVERFLOW_HPP_INCLUDED_
#define BOOST_LOG_SINKS_BLOCK_ON_OVERFLOW_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/intrusive/options.hpp>
#include <boost/intrusive/list.hpp>
#include <boost/intrusive/list_hook.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/log/core/record_view.hpp>
#include <boost/log/detail/header.hpp>
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
namespace sinks {
/*!
* \brief Blocking strategy for handling log record queue overflows
*
* This strategy will cause enqueueing threads to block when the
* log record queue overflows. The blocked threads will be woken as
* soon as there appears free space in the queue, in the same order
* they attempted to enqueue records.
*/
class block_on_overflow
{
#ifndef BOOST_LOG_DOXYGEN_PASS
private:
typedef intrusive::list_base_hook<
intrusive::link_mode< intrusive::auto_unlink >
> thread_context_hook_t;
struct thread_context :
public thread_context_hook_t
{
condition_variable cond;
bool result;
thread_context() : result(true) {}
};
typedef intrusive::list<
thread_context,
intrusive::base_hook< thread_context_hook_t >,
intrusive::constant_time_size< false >
> thread_contexts;
private:
//! Blocked threads
thread_contexts m_thread_contexts;
public:
/*!
* Default constructor.
*/
BOOST_DEFAULTED_FUNCTION(block_on_overflow(), {})
/*!
* This method is called by the queue when overflow is detected.
*
* \param lock An internal lock that protects the queue
*
* \retval true Attempt to enqueue the record again.
* \retval false Discard the record.
*/
template< typename LockT >
bool on_overflow(record_view const&, LockT& lock)
{
thread_context context;
m_thread_contexts.push_back(context);
do
{
context.cond.wait(lock);
}
while (context.is_linked());
return context.result;
}
/*!
* This method is called by the queue when there appears a free space.
* The internal lock protecting the queue is locked when calling this method.
*/
void on_queue_space_available()
{
if (!m_thread_contexts.empty())
{
m_thread_contexts.front().cond.notify_one();
m_thread_contexts.pop_front();
}
}
/*!
* This method is called by the queue to interrupt any possible waits in \c on_overflow.
* The internal lock protecting the queue is locked when calling this method.
*/
void interrupt()
{
while (!m_thread_contexts.empty())
{
thread_context& context = m_thread_contexts.front();
context.result = false;
context.cond.notify_one();
m_thread_contexts.pop_front();
}
}
// Copying prohibited
BOOST_DELETED_FUNCTION(block_on_overflow(block_on_overflow const&))
BOOST_DELETED_FUNCTION(block_on_overflow& operator= (block_on_overflow const&))
#endif // BOOST_LOG_DOXYGEN_PASS
};
} // namespace sinks
BOOST_LOG_CLOSE_NAMESPACE // namespace log
} // namespace boost
#include <boost/log/detail/footer.hpp>
#endif // BOOST_LOG_SINKS_BLOCK_ON_OVERFLOW_HPP_INCLUDED_
|
