| // |
| // detail/win_iocp_io_service.hpp |
| // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| // |
| // Copyright (c) 2003-2010 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_WIN_IOCP_IO_SERVICE_HPP |
| #define BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_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_IOCP) |
| |
| #include <boost/scoped_ptr.hpp> |
| #include <boost/asio/io_service.hpp> |
| #include <boost/asio/detail/mutex.hpp> |
| #include <boost/asio/detail/op_queue.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/win_iocp_io_service_fwd.hpp> |
| #include <boost/asio/detail/win_iocp_operation.hpp> |
| #include <boost/asio/detail/thread.hpp> |
| |
| #include <boost/asio/detail/push_options.hpp> |
| |
| namespace boost { |
| namespace asio { |
| namespace detail { |
| |
| class timer_op; |
| |
| class win_iocp_io_service |
| : public boost::asio::detail::service_base<win_iocp_io_service> |
| { |
| public: |
| // Constructor. |
| BOOST_ASIO_DECL win_iocp_io_service(boost::asio::io_service& io_service); |
| |
| BOOST_ASIO_DECL void init(size_t concurrency_hint); |
| |
| // Destroy all user-defined handler objects owned by the service. |
| BOOST_ASIO_DECL void shutdown_service(); |
| |
| // Initialise the task. Nothing to do here. |
| void init_task() |
| { |
| } |
| |
| // Register a handle with the IO completion port. |
| BOOST_ASIO_DECL boost::system::error_code register_handle( |
| HANDLE handle, boost::system::error_code& ec); |
| |
| // Run the event loop until stopped or no more work. |
| BOOST_ASIO_DECL size_t run(boost::system::error_code& ec); |
| |
| // Run until stopped or one operation is performed. |
| BOOST_ASIO_DECL size_t run_one(boost::system::error_code& ec); |
| |
| // Poll for operations without blocking. |
| BOOST_ASIO_DECL size_t poll(boost::system::error_code& ec); |
| |
| // Poll for one operation without blocking. |
| BOOST_ASIO_DECL size_t poll_one(boost::system::error_code& ec); |
| |
| // Stop the event processing loop. |
| BOOST_ASIO_DECL void stop(); |
| |
| // Reset in preparation for a subsequent run invocation. |
| void reset() |
| { |
| ::InterlockedExchange(&stopped_, 0); |
| } |
| |
| // Notify that some work has started. |
| void work_started() |
| { |
| ::InterlockedIncrement(&outstanding_work_); |
| } |
| |
| // Notify that some work has finished. |
| void work_finished() |
| { |
| if (::InterlockedDecrement(&outstanding_work_) == 0) |
| stop(); |
| } |
| |
| // Request invocation of the given handler. |
| template <typename Handler> |
| void dispatch(Handler handler); |
| |
| // Request invocation of the given handler and return immediately. |
| template <typename Handler> |
| void post(Handler handler); |
| |
| // Request invocation of the given operation and return immediately. Assumes |
| // that work_started() has not yet been called for the operation. |
| void post_immediate_completion(win_iocp_operation* op) |
| { |
| work_started(); |
| post_deferred_completion(op); |
| } |
| |
| // Request invocation of the given operation and return immediately. Assumes |
| // that work_started() was previously called for the operation. |
| BOOST_ASIO_DECL void post_deferred_completion(win_iocp_operation* op); |
| |
| // Request invocation of the given operation and return immediately. Assumes |
| // that work_started() was previously called for the operations. |
| BOOST_ASIO_DECL void post_deferred_completions( |
| op_queue<win_iocp_operation>& ops); |
| |
| // Called after starting an overlapped I/O operation that did not complete |
| // immediately. The caller must have already called work_started() prior to |
| // starting the operation. |
| BOOST_ASIO_DECL void on_pending(win_iocp_operation* op); |
| |
| // Called after starting an overlapped I/O operation that completed |
| // immediately. The caller must have already called work_started() prior to |
| // starting the operation. |
| BOOST_ASIO_DECL void on_completion(win_iocp_operation* op, |
| DWORD last_error = 0, DWORD bytes_transferred = 0); |
| |
| // Called after starting an overlapped I/O operation that completed |
| // immediately. The caller must have already called work_started() prior to |
| // starting the operation. |
| BOOST_ASIO_DECL void on_completion(win_iocp_operation* op, |
| const boost::system::error_code& ec, DWORD bytes_transferred = 0); |
| |
| // Add a new timer queue to the service. |
| template <typename Time_Traits> |
| void add_timer_queue(timer_queue<Time_Traits>& timer_queue); |
| |
| // Remove a timer queue from the service. |
| 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 associated with the given token. Returns the number of |
| // handlers 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); |
| |
| private: |
| #if defined(WINVER) && (WINVER < 0x0500) |
| typedef DWORD dword_ptr_t; |
| typedef ULONG ulong_ptr_t; |
| #else // defined(WINVER) && (WINVER < 0x0500) |
| typedef DWORD_PTR dword_ptr_t; |
| typedef ULONG_PTR ulong_ptr_t; |
| #endif // defined(WINVER) && (WINVER < 0x0500) |
| |
| // Dequeues at most one operation from the I/O completion port, and then |
| // executes it. Returns the number of operations that were dequeued (i.e. |
| // either 0 or 1). |
| BOOST_ASIO_DECL size_t do_one(bool block, boost::system::error_code& ec); |
| |
| // 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(); |
| |
| // Helper class to call work_finished() on block exit. |
| struct work_finished_on_block_exit; |
| |
| // Helper class for managing a HANDLE. |
| struct auto_handle |
| { |
| HANDLE handle; |
| auto_handle() : handle(0) {} |
| ~auto_handle() { if (handle) ::CloseHandle(handle); } |
| }; |
| |
| // The IO completion port used for queueing operations. |
| auto_handle iocp_; |
| |
| // The count of unfinished work. |
| long outstanding_work_; |
| |
| // Flag to indicate whether the event loop has been stopped. |
| long stopped_; |
| |
| // Flag to indicate whether the service has been shut down. |
| long shutdown_; |
| |
| enum |
| { |
| // Timeout to use with GetQueuedCompletionStatus. Some versions of windows |
| // have a "bug" where a call to GetQueuedCompletionStatus can appear stuck |
| // even though there are events waiting on the queue. Using a timeout helps |
| // to work around the issue. |
| gqcs_timeout = 500, |
| |
| // Maximum waitable timer timeout, in milliseconds. |
| max_timeout_msec = 5 * 60 * 1000, |
| |
| // Maximum waitable timer timeout, in microseconds. |
| max_timeout_usec = max_timeout_msec * 1000, |
| |
| // Completion key value used to wake up a thread to dispatch timers or |
| // completed operations. |
| wake_for_dispatch = 1, |
| |
| // Completion key value to indicate that an operation has posted with the |
| // original last_error and bytes_transferred values stored in the fields of |
| // the OVERLAPPED structure. |
| overlapped_contains_result = 2 |
| }; |
| |
| // Function object for processing timeouts in a background thread. |
| struct timer_thread_function; |
| friend struct timer_thread_function; |
| |
| // Background thread used for processing timeouts. |
| boost::scoped_ptr<thread> timer_thread_; |
| |
| // A waitable timer object used for waiting for timeouts. |
| auto_handle waitable_timer_; |
| |
| // Non-zero if timers or completed operations need to be dispatched. |
| long dispatch_required_; |
| |
| // Mutex for protecting access to the timer queues and completed operations. |
| mutex dispatch_mutex_; |
| |
| // The timer queues. |
| timer_queue_set timer_queues_; |
| |
| // The operations that are ready to dispatch. |
| op_queue<win_iocp_operation> completed_ops_; |
| }; |
| |
| } // namespace detail |
| } // namespace asio |
| } // namespace boost |
| |
| #include <boost/asio/detail/pop_options.hpp> |
| |
| #include <boost/asio/detail/impl/win_iocp_io_service.hpp> |
| #if defined(BOOST_ASIO_HEADER_ONLY) |
| # include <boost/asio/detail/impl/win_iocp_io_service.ipp> |
| #endif // defined(BOOST_ASIO_HEADER_ONLY) |
| |
| #endif // defined(BOOST_ASIO_HAS_IOCP) |
| |
| #endif // BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP |