// | |
// detail/epoll_reactor.hpp | |
// ~~~~~~~~~~~~~~~~~~~~~~~~ | |
// | |
// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com) | |
// | |
// 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) | |
// | |
#ifndef BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP | |
#define BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP | |
#if defined(_MSC_VER) && (_MSC_VER >= 1200) | |
# pragma once | |
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) | |
#include <boost/asio/detail/config.hpp> | |
#if defined(BOOST_ASIO_HAS_EPOLL) | |
#include <boost/asio/io_service.hpp> | |
#include <boost/asio/detail/epoll_reactor_fwd.hpp> | |
#include <boost/asio/detail/mutex.hpp> | |
#include <boost/asio/detail/object_pool.hpp> | |
#include <boost/asio/detail/op_queue.hpp> | |
#include <boost/asio/detail/reactor_op.hpp> | |
#include <boost/asio/detail/select_interrupter.hpp> | |
#include <boost/asio/detail/socket_types.hpp> | |
#include <boost/asio/detail/timer_op.hpp> | |
#include <boost/asio/detail/timer_queue_base.hpp> | |
#include <boost/asio/detail/timer_queue_fwd.hpp> | |
#include <boost/asio/detail/timer_queue_set.hpp> | |
#include <boost/asio/detail/push_options.hpp> | |
namespace boost { | |
namespace asio { | |
namespace detail { | |
class epoll_reactor | |
: public boost::asio::detail::service_base<epoll_reactor> | |
{ | |
public: | |
enum op_types { read_op = 0, write_op = 1, | |
connect_op = 1, except_op = 2, max_ops = 3 }; | |
// Per-descriptor queues. | |
class descriptor_state | |
{ | |
friend class epoll_reactor; | |
friend class object_pool_access; | |
mutex mutex_; | |
op_queue<reactor_op> op_queue_[max_ops]; | |
bool shutdown_; | |
descriptor_state* next_; | |
descriptor_state* prev_; | |
}; | |
// Per-descriptor data. | |
typedef descriptor_state* per_descriptor_data; | |
// Constructor. | |
BOOST_ASIO_DECL epoll_reactor(boost::asio::io_service& io_service); | |
// Destructor. | |
BOOST_ASIO_DECL ~epoll_reactor(); | |
// Destroy all user-defined handler objects owned by the service. | |
BOOST_ASIO_DECL void shutdown_service(); | |
// Initialise the task. | |
BOOST_ASIO_DECL void init_task(); | |
// Register a socket with the reactor. Returns 0 on success, system error | |
// code on failure. | |
BOOST_ASIO_DECL int register_descriptor(socket_type descriptor, | |
per_descriptor_data& descriptor_data); | |
// Post a reactor operation for immediate completion. | |
void post_immediate_completion(reactor_op* op) | |
{ | |
io_service_.post_immediate_completion(op); | |
} | |
// Start a new operation. The reactor operation will be performed when the | |
// given descriptor is flagged as ready, or an error has occurred. | |
BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, | |
per_descriptor_data& descriptor_data, | |
reactor_op* op, bool allow_speculative); | |
// Cancel all operations associated with the given descriptor. The | |
// handlers associated with the descriptor will be invoked with the | |
// operation_aborted error. | |
BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, | |
per_descriptor_data& descriptor_data); | |
// Cancel any operations that are running against the descriptor and remove | |
// its registration from the reactor. | |
BOOST_ASIO_DECL void close_descriptor(socket_type descriptor, | |
per_descriptor_data& descriptor_data); | |
// Add a new timer queue to the reactor. | |
template <typename Time_Traits> | |
void add_timer_queue(timer_queue<Time_Traits>& timer_queue); | |
// Remove a timer queue from the reactor. | |
template <typename Time_Traits> | |
void remove_timer_queue(timer_queue<Time_Traits>& timer_queue); | |
// Schedule a new operation in the given timer queue to expire at the | |
// specified absolute time. | |
template <typename Time_Traits> | |
void schedule_timer(timer_queue<Time_Traits>& queue, | |
const typename Time_Traits::time_type& time, | |
typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op); | |
// Cancel the timer operations associated with the given token. Returns the | |
// number of operations that have been posted or dispatched. | |
template <typename Time_Traits> | |
std::size_t cancel_timer(timer_queue<Time_Traits>& queue, | |
typename timer_queue<Time_Traits>::per_timer_data& timer); | |
// Run epoll once until interrupted or events are ready to be dispatched. | |
BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops); | |
// Interrupt the select loop. | |
BOOST_ASIO_DECL void interrupt(); | |
private: | |
// The hint to pass to epoll_create to size its data structures. | |
enum { epoll_size = 20000 }; | |
// Create the epoll file descriptor. Throws an exception if the descriptor | |
// cannot be created. | |
BOOST_ASIO_DECL static int do_epoll_create(); | |
// Helper function to add a new timer queue. | |
BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); | |
// Helper function to remove a timer queue. | |
BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); | |
// Called to recalculate and update the timeout. | |
BOOST_ASIO_DECL void update_timeout(); | |
// Get the timeout value for the epoll_wait call. The timeout value is | |
// returned as a number of milliseconds. A return value of -1 indicates | |
// that epoll_wait should block indefinitely. | |
BOOST_ASIO_DECL int get_timeout(); | |
#if defined(BOOST_ASIO_HAS_TIMERFD) | |
// Get the timeout value for the timer descriptor. The return value is the | |
// flag argument to be used when calling timerfd_settime. | |
BOOST_ASIO_DECL int get_timeout(itimerspec& ts); | |
#endif // defined(BOOST_ASIO_HAS_TIMERFD) | |
// The io_service implementation used to post completions. | |
io_service_impl& io_service_; | |
// Mutex to protect access to internal data. | |
mutex mutex_; | |
// The epoll file descriptor. | |
int epoll_fd_; | |
// The timer file descriptor. | |
int timer_fd_; | |
// The interrupter is used to break a blocking epoll_wait call. | |
select_interrupter interrupter_; | |
// The timer queues. | |
timer_queue_set timer_queues_; | |
// Whether the service has been shut down. | |
bool shutdown_; | |
// Mutex to protect access to the registered descriptors. | |
mutex registered_descriptors_mutex_; | |
// Keep track of all registered descriptors. | |
object_pool<descriptor_state> registered_descriptors_; | |
}; | |
} // namespace detail | |
} // namespace asio | |
} // namespace boost | |
#include <boost/asio/detail/pop_options.hpp> | |
#include <boost/asio/detail/impl/epoll_reactor.hpp> | |
#if defined(BOOST_ASIO_HEADER_ONLY) | |
# include <boost/asio/detail/impl/epoll_reactor.ipp> | |
#endif // defined(BOOST_ASIO_HEADER_ONLY) | |
#endif // defined(BOOST_ASIO_HAS_EPOLL) | |
#endif // BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP |