llfio_v2_xxx::byte_io_multiplexer::awaitable< T > Struct Template Reference

A convenience coroutine awaitable type returned by .co_read(), .co_write() and .co_barrier(). Blocks execution if no i/o multiplexer has been set on this handle! More...

#include "byte_io_multiplexer.hpp"

Inheritance diagram for llfio_v2_xxx::byte_io_multiplexer::awaitable< T >:

Public Types
using	result_type = T
	The result type of this awaitable.
using	buffers_type = typename result_type::value_type
	The buffers type of this awaitable.

Public Member Functions
constexpr	awaitable ()
	Default constructor.
	awaitable (result_type &&res) noexcept
	Constructs an immediately finished awaitable.
	awaitable (const awaitable &)=delete
	awaitable (awaitable &&o) noexcept
	Move construction, terminates the process if the i/o is in progress.
awaitable &	operator= (const awaitable &)=delete
awaitable &	operator= (awaitable &&o) noexcept
	~awaitable ()
	Destructor, blocks if the i/o is in progress.
bool	await_ready () noexcept
	True if the i/o state is finished. Begins the i/o if it is not initiated yet.
result_type	await_resume ()
	Returns the result of the i/o.

Public Attributes
byte	_state_storage [_state_storage_bytes]
io_operation_state *	_state {nullptr}

Static Public Attributes
static constexpr size_t	_state_storage_bytes = _awaitable_size - sizeof(void *) - sizeof(io_operation_state *)

Protected Types
using	lock_guard = io_operation_state::lock_guard

Protected Member Functions
void	set_state (io_operation_state *state) noexcept
virtual void	read_finished (lock_guard &g, io_operation_state_type) override
	Called when an i/o has finished, and its state can now be destroyed.
virtual void	write_or_barrier_finished (lock_guard &g, io_operation_state_type) override
	Called when an i/o has finished, and its state can now be destroyed.
virtual void	read_initiated (lock_guard &, io_operation_state_type)
	Called when an i/o has been initiated, and is now being processed asynchronously.
virtual bool	read_completed (lock_guard &, io_operation_state_type, io_result< buffers_type > &&)
	Called when an i/o has completed, and its result is available. Return true if you consume the result.
virtual void	write_initiated (lock_guard &, io_operation_state_type)
	Called when an i/o has been initiated, and is now being processed asynchronously.
virtual bool	write_completed (lock_guard &, io_operation_state_type, io_result< const_buffers_type > &&)
	Called when an i/o has completed, and its result is available. Return true if you consume the result.
virtual void	barrier_initiated (lock_guard &, io_operation_state_type)
	Called when an i/o has been initiated, and is now being processed asynchronously.
virtual bool	barrier_completed (lock_guard &, io_operation_state_type, io_result< const_buffers_type > &&)
	Called when an i/o has completed, and its result is available. Return true if you consume the result.

Friends
class	byte_io_handle
class	byte_socket_handle
class	listening_byte_socket_handle

Detailed Description

template<class T>
struct llfio_v2_xxx::byte_io_multiplexer::awaitable< T >

A convenience coroutine awaitable type returned by .co_read(), .co_write() and .co_barrier(). Blocks execution if no i/o multiplexer has been set on this handle!

Upon first .await_ready(), the awaitable initiates the i/o. If the i/o completes immediately, the awaitable is immediately ready and no coroutine suspension occurs.

If the i/o does not complete immediately, the coroutine is suspended. To cause resumption of execution, you will need to pump the associated i/o multiplexer for completions using byte_io_multiplexer::check_for_any_completed_io().

Constructor & Destructor Documentation

awaitable() [1/3]

template<class T >

constexpr llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::awaitable ( )

inlineconstexpr

Default constructor.

{}

awaitable() [2/3]

template<class T >

llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::awaitable ( result_type &&  res )

inlineexplicitnoexcept

Constructs an immediately finished awaitable.

    {
      _state = new(_state_storage) _unsynchronised_io_operation_state(std::move(res));
      _state->visitor = this;
    }

awaitable() [3/3]

template<class T >

llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::awaitable ( awaitable< T > &&  o )

inlinenoexcept

Move construction, terminates the process if the i/o is in progress.

        : io_operation_state_visitor(std::move(o))
#if LLFIO_ENABLE_COROUTINES
        , _coro(o._coro)
#endif
    {
      if(o._state != nullptr && !is_initialised(o._state->current_state()) && !is_finished(o._state->current_state()))
      {
        abort();  // attempt to relocate an awaitable currently in use
      }
      _state = o._state->relocate_to(_state_storage);
      o._state->~io_operation_state();
      o._state = nullptr;
      _state->visitor = this;
#if LLFIO_ENABLE_COROUTINES
      o._coro = {};
#endif
    }

~awaitable()

template<class T >

llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::~awaitable ( )

inline

Destructor, blocks if the i/o is in progress.

{
  if(_state != nullptr)
  {
    auto state = _state->current_state();
    if(state != io_operation_state_type::unknown && !is_initialised(state) && !is_finished(state))
    {
#if LLFIO_ENABLE_COROUTINES
      // Resumption of the coroutine at this point causes recursion into this destructor, so prevent that
      _coro = {};
#endif
      state = _state->h->multiplexer()->check_io_operation(_state);
      if(!is_completed(state))
      {
        // Cancel the i/o
        (void) _state->h->multiplexer()->cancel_io_operation(_state);
      }
      while(!is_finished(state))
      {
        // Block forever until I finish
        (void) _state->h->multiplexer()->check_for_any_completed_io({});
        state = _state->current_state();
      }
    }
    _state->~io_operation_state();
  }
}

Member Function Documentation

await_ready()

template<class T >

bool llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::await_ready ( )

inlinenoexcept

True if the i/o state is finished. Begins the i/o if it is not initiated yet.

{
  auto state = _state->current_state();
  if(is_initialised(state))
  {
    // Begin the i/o
    state = _state->h->multiplexer()->init_io_operation(_state);
    // std::cout << "Coroutine " << _state << " begins i/o, state on return was " << (int) state << std::endl;
  }
  return is_finished(state);
}

await_resume()

template<class T >

result_type llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::await_resume ( )

inline

Returns the result of the i/o.

    {
      // std::cout << "Coroutine " << _state << " fetches result after resumption" << std::endl;
      return _result_type_from_io_operation_state(_state, (buffers_type *) nullptr);
    }

barrier_completed()

virtual bool llfio_v2_xxx::byte_io_multiplexer::io_operation_state_visitor::barrier_completed ( lock_guard &  , io_operation_state_type  , io_result< const_buffers_type > &&    )

inlinevirtualinherited

Called when an i/o has completed, and its result is available. Return true if you consume the result.

{ return false; }

barrier_initiated()

virtual void llfio_v2_xxx::byte_io_multiplexer::io_operation_state_visitor::barrier_initiated ( lock_guard &  , io_operation_state_type    )

inlinevirtualinherited

Called when an i/o has been initiated, and is now being processed asynchronously.

{}

operator=()

template<class T >

awaitable & llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::operator= ( awaitable< T > &&  o )

inlinenoexcept

    {
      if(this == &o)
      {
        return *this;
      }
      this->~awaitable();
      new(this) awaitable(std::move(o));
      return *this;
    }

read_completed()

virtual bool llfio_v2_xxx::byte_io_multiplexer::io_operation_state_visitor::read_completed ( lock_guard &  , io_operation_state_type  , io_result< buffers_type > &&    )

inlinevirtualinherited

Called when an i/o has completed, and its result is available. Return true if you consume the result.

{ return false; }

read_finished()

template<class T >

virtual void llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::read_finished ( lock_guard &  , io_operation_state_type    )

inlineoverrideprotectedvirtual

Called when an i/o has finished, and its state can now be destroyed.

Reimplemented from llfio_v2_xxx::byte_io_multiplexer::io_operation_state_visitor.

    {
      (void) g;
#if LLFIO_ENABLE_COROUTINES
      if(_coro)
      {
        // std::cout << "Coroutine " << _state << " resumes" << std::endl;
        auto coro = _coro;
        _coro = {};
        g.unlock();
        coro.resume();
      }
#endif
    }

read_initiated()

virtual void llfio_v2_xxx::byte_io_multiplexer::io_operation_state_visitor::read_initiated ( lock_guard &  , io_operation_state_type    )

inlinevirtualinherited

Called when an i/o has been initiated, and is now being processed asynchronously.

{}

set_state()

template<class T >

void llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::set_state ( io_operation_state *  state )

inlineprotectednoexcept

    {
      _state = state;
      _state->visitor = this;
    }

write_completed()

virtual bool llfio_v2_xxx::byte_io_multiplexer::io_operation_state_visitor::write_completed ( lock_guard &  , io_operation_state_type  , io_result< const_buffers_type > &&    )

inlinevirtualinherited

Called when an i/o has completed, and its result is available. Return true if you consume the result.

{ return false; }

write_initiated()

virtual void llfio_v2_xxx::byte_io_multiplexer::io_operation_state_visitor::write_initiated ( lock_guard &  , io_operation_state_type    )

inlinevirtualinherited

Called when an i/o has been initiated, and is now being processed asynchronously.

{}

write_or_barrier_finished()

template<class T >

virtual void llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::write_or_barrier_finished ( lock_guard &  , io_operation_state_type    )

inlineoverrideprotectedvirtual

Called when an i/o has finished, and its state can now be destroyed.

Reimplemented from llfio_v2_xxx::byte_io_multiplexer::io_operation_state_visitor.

    {
      (void) g;
#if LLFIO_ENABLE_COROUTINES
      if(_coro)
      {
        auto coro = _coro;
        _coro = {};
        g.unlock();
        coro.resume();
      }
#endif
    }

Member Data Documentation

_state

template<class T >

io_operation_state* llfio_v2_xxx::byte_io_multiplexer::awaitable< T >::_state {nullptr}

{nullptr};

---

The documentation for this struct was generated from the following files:

• include/llfio/v2.0/byte_io_multiplexer.hpp
• include/llfio/v2.0/byte_io_handle.hpp