boost::fibers::asio::round_robin Class Reference

#include <round_robin.hpp>

Inheritance diagram for boost::fibers::asio::round_robin:

Collaboration diagram for boost::fibers::asio::round_robin:

Classes
struct	service

Public Member Functions
	round_robin (boost::asio::io_service &io_svc)
void	awakened (context *ctx) noexcept
context *	pick_next () noexcept
bool	has_ready_fibers () const noexcept
void	suspend_until (std::chrono::steady_clock::time_point const &abs_time) noexcept
void	notify () noexcept

Detailed Description

Definition at line 35 of file round_robin.hpp.

Constructor & Destructor Documentation

round_robin()

boost::fibers::asio::round_robin::round_robin ( boost::asio::io_service & io_svc )

inline

Definition at line 89 of file round_robin.hpp.

                                               :
        io_svc_( io_svc),
        suspend_timer_( io_svc_) {
        // We use add_service() very deliberately. This will throw
        // service_already_exists if you pass the same io_service instance to
        // more than one round_robin instance.
        boost::asio::add_service( io_svc_, new service( io_svc_));
    }

Member Function Documentation

awakened()

void boost::fibers::asio::round_robin::awakened ( context * ctx )

inlinenoexcept

Definition at line 99 of file round_robin.hpp.

                                           {
        BOOST_ASSERT( nullptr != ctx);
        ctx->ready_link( rqueue_); /*< fiber, enqueue on ready queue >*/
    }

has_ready_fibers()

bool boost::fibers::asio::round_robin::has_ready_fibers ( ) const

inlinenoexcept

Definition at line 117 of file round_robin.hpp.

                                           {
        return ! rqueue_.empty();
    }

notify()

void boost::fibers::asio::round_robin::notify ( )

inlinenoexcept

Definition at line 156 of file round_robin.hpp.

                           {
        // Something has happened that should wake one or more fibers BEFORE
        // suspend_timer_ expires. Reset the timer to cause it to fire
        // immediately, causing the run_one() call to return. In theory we
        // could use cancel() because we don't care whether suspend_timer_'s
        // handler is called with operation_aborted or success. However --
        // cancel() doesn't change the expiration time, and we use
        // suspend_timer_'s expiration time to decide whether it's already
        // set. If suspend_until() set some specific wake time, then notify()
        // canceled it, then suspend_until() was called again with the same
        // wake time, it would match suspend_timer_'s expiration time and we'd
        // refrain from setting the timer. So instead of simply calling
        // cancel(), reset the timer, which cancels the pending sleep AND sets
        // a new expiration time. This will cause us to spin the loop twice --
        // once for the operation_aborted handler, once for timer expiration
        // -- but that shouldn't be a big problem.
        suspend_timer_.expires_at( std::chrono::steady_clock::now() );
    }

pick_next()

context * boost::fibers::asio::round_robin::pick_next ( )

inlinenoexcept

Definition at line 104 of file round_robin.hpp.

                                   {
        context * ctx( nullptr);
        if ( ! rqueue_.empty() ) { /*<
            pop an item from the ready queue
        >*/
            ctx = & rqueue_.front();
            rqueue_.pop_front();
            BOOST_ASSERT( nullptr != ctx);
            BOOST_ASSERT( context::active() != ctx);
        }
        return ctx;
    }

suspend_until()

void boost::fibers::asio::round_robin::suspend_until ( std::chrono::steady_clock::time_point const & abs_time )

inlinenoexcept

Definition at line 122 of file round_robin.hpp.

                                                                                  {
        // Set a timer so at least one handler will eventually fire, causing
        // run_one() to eventually return. Set a timer even if abs_time ==
        // time_point::max() so the timer can be canceled by our notify()
        // method -- which calls the handler.
        if ( suspend_timer_.expires_at() != abs_time) {
            // Each expires_at(time_point) call cancels any previous pending
            // call. We could inadvertently spin like this:
            // dispatcher calls suspend_until() with earliest wake time
            // suspend_until() sets suspend_timer_
            // lambda loop calls run_one()
            // some other asio handler runs before timer expires
            // run_one() returns to lambda loop
            // lambda loop yields to dispatcher
            // dispatcher finds no ready fibers
            // dispatcher calls suspend_until() with SAME wake time
            // suspend_until() sets suspend_timer_ to same time, canceling
            // previous async_wait()
            // lambda loop calls run_one()
            // asio calls suspend_timer_ handler with operation_aborted
            // run_one() returns to lambda loop... etc. etc.
            // So only actually set the timer when we're passed a DIFFERENT
            // abs_time value.
            suspend_timer_.expires_at( abs_time);
            // It really doesn't matter what the suspend_timer_ handler does,
            // or even whether it's called because the timer ran out or was
            // canceled. The whole point is to cause the run_one() call to
            // return. So just pass a no-op lambda with proper signature.
            suspend_timer_.async_wait([](boost::system::error_code const&){});
        }
    }

---

The documentation for this class was generated from the following file:

• libraries/fc/src/thread/asio/round_robin.hpp