/*
|
* 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 bounded_fifo_queue.hpp
|
* \author Andrey Semashev
|
* \date 04.01.2012
|
*
|
* The header contains implementation of bounded FIFO queueing strategy for
|
* the asynchronous sink frontend.
|
*/
|
|
#ifndef BOOST_LOG_SINKS_BOUNDED_FIFO_QUEUE_HPP_INCLUDED_
|
#define BOOST_LOG_SINKS_BOUNDED_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 <cstddef>
|
#include <queue>
|
#include <boost/thread/locks.hpp>
|
#include <boost/thread/mutex.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 Bounded FIFO log record queueing strategy
|
*
|
* The \c bounded_fifo_queue class is intended to be used with
|
* the \c asynchronous_sink frontend as a log record queueing strategy.
|
*
|
* This strategy describes log record queueing logic.
|
* The queue has a limited capacity, upon reaching which the enqueue operation will
|
* invoke the overflow handling strategy specified in the \c OverflowStrategyT
|
* template parameter to handle the situation. The library provides overflow handling
|
* strategies for most common cases: \c drop_on_overflow will silently discard the log record,
|
* and \c block_on_overflow will put the enqueueing thread to wait until there is space
|
* in the queue.
|
*
|
* The log record queue imposes no ordering over the queued
|
* elements aside from the order in which they are enqueued.
|
*/
|
template< std::size_t MaxQueueSizeV, typename OverflowStrategyT >
|
class bounded_fifo_queue :
|
private OverflowStrategyT
|
{
|
private:
|
typedef OverflowStrategyT overflow_strategy;
|
typedef std::queue< record_view > queue_type;
|
typedef boost::mutex mutex_type;
|
|
private:
|
//! Synchronization primitive
|
mutex_type m_mutex;
|
//! Condition to block the consuming thread on
|
condition_variable m_cond;
|
//! Log record queue
|
queue_type m_queue;
|
//! Interruption flag
|
bool m_interruption_requested;
|
|
protected:
|
//! Default constructor
|
bounded_fifo_queue() : m_interruption_requested(false)
|
{
|
}
|
//! Initializing constructor
|
template< typename ArgsT >
|
explicit bounded_fifo_queue(ArgsT const&) : m_interruption_requested(false)
|
{
|
}
|
|
//! Enqueues log record to the queue
|
void enqueue(record_view const& rec)
|
{
|
unique_lock< mutex_type > lock(m_mutex);
|
std::size_t size = m_queue.size();
|
for (; size >= MaxQueueSizeV; size = m_queue.size())
|
{
|
if (!overflow_strategy::on_overflow(rec, lock))
|
return;
|
}
|
|
m_queue.push(rec);
|
if (size == 0)
|
m_cond.notify_one();
|
}
|
|
//! Attempts to enqueue log record to the queue
|
bool try_enqueue(record_view const& rec)
|
{
|
unique_lock< mutex_type > lock(m_mutex, try_to_lock);
|
if (lock.owns_lock())
|
{
|
const std::size_t size = m_queue.size();
|
|
// Do not invoke the bounding strategy in case of overflow as it may block
|
if (size < MaxQueueSizeV)
|
{
|
m_queue.push(rec);
|
if (size == 0)
|
m_cond.notify_one();
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
//! 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 try_dequeue(rec);
|
}
|
|
//! Attempts to dequeue log record from the queue, does not block if the queue is empty
|
bool try_dequeue(record_view& rec)
|
{
|
lock_guard< mutex_type > lock(m_mutex);
|
const std::size_t size = m_queue.size();
|
if (size > 0)
|
{
|
rec.swap(m_queue.front());
|
m_queue.pop();
|
overflow_strategy::on_queue_space_available();
|
return true;
|
}
|
|
return false;
|
}
|
|
//! Dequeues log record from the queue, blocks if the queue is empty
|
bool dequeue_ready(record_view& rec)
|
{
|
unique_lock< mutex_type > lock(m_mutex);
|
|
while (!m_interruption_requested)
|
{
|
const std::size_t size = m_queue.size();
|
if (size > 0)
|
{
|
rec.swap(m_queue.front());
|
m_queue.pop();
|
overflow_strategy::on_queue_space_available();
|
return true;
|
}
|
else
|
{
|
m_cond.wait(lock);
|
}
|
}
|
m_interruption_requested = false;
|
|
return false;
|
}
|
|
//! Wakes a thread possibly blocked in the \c dequeue method
|
void interrupt_dequeue()
|
{
|
lock_guard< mutex_type > lock(m_mutex);
|
m_interruption_requested = true;
|
overflow_strategy::interrupt();
|
m_cond.notify_one();
|
}
|
};
|
|
} // namespace sinks
|
|
BOOST_LOG_CLOSE_NAMESPACE // namespace log
|
|
} // namespace boost
|
|
#include <boost/log/detail/footer.hpp>
|
|
#endif // BOOST_LOG_SINKS_BOUNDED_FIFO_QUEUE_HPP_INCLUDED_
|
