folly::pushmi::detail::trampoline< E > Class Template Reference

#include <trampoline.h>

Static Public Member Functions
static trampoline_id	get_id ()
static bool	is_owned ()
template<class Selector , class Derived >
static void	submit (Selector, Derived &, recurse_t)
requires not static Same< SingleReceiver, recurse_t > void	submit (ownordelegate_t, SingleReceiver awhat)
requires not static Same< SingleReceiver, recurse_t > void	submit (ownornest_t, SingleReceiver awhat)

Private Types
using	error_type = std::decay_t< E >
using	work_type = any_receiver< error_type, any_executor_ref< error_type >>
using	queue_type = std::deque< work_type >
using	pending_type = std::tuple< int, queue_type, bool >

Static Private Member Functions
static pending_type *&	owner ()
static int &	depth (pending_type &p)
static queue_type &	pending (pending_type &p)
static bool &	repeat (pending_type &p)

Detailed Description

template<class E>
class folly::pushmi::detail::trampoline< E >

Definition at line 50 of file trampoline.h.

Member Typedef Documentation

template<class E >

using folly::pushmi::detail::trampoline< E >::error_type = std::decay_t<E>

private

Definition at line 99 of file trampoline.h.

template<class E >

using folly::pushmi::detail::trampoline< E >::pending_type = std::tuple<int, queue_type, bool>

private

Definition at line 102 of file trampoline.h.

template<class E >

using folly::pushmi::detail::trampoline< E >::queue_type = std::deque<work_type>

private

Definition at line 101 of file trampoline.h.

template<class E >

using folly::pushmi::detail::trampoline< E >::work_type = any_receiver<error_type, any_executor_ref<error_type>>

private

Definition at line 100 of file trampoline.h.

Member Function Documentation

template<class E >

static int& folly::pushmi::detail::trampoline< E >::depth ( pending_type &  p )

inlinestaticprivate

Definition at line 109 of file trampoline.h.

                                            {
    return std::get<0>(p);
  }

template<class E >

static trampoline_id folly::pushmi::detail::trampoline< E >::get_id ( )

inlinestatic

Definition at line 122 of file trampoline.h.

Referenced by folly::pushmi::get_trampoline_id().

                                       {
    return {owner()};
  }

template<class E >

static bool folly::pushmi::detail::trampoline< E >::is_owned ( )

inlinestatic

Definition at line 126 of file trampoline.h.

Referenced by folly::pushmi::owned_by_trampoline().

                                {
    return owner() != nullptr;
  }

template<class E >

static pending_type*& folly::pushmi::detail::trampoline< E >::owner ( )

inlinestaticprivate

Definition at line 104 of file trampoline.h.

                                       {
    static thread_local pending_type* pending = nullptr;
    return pending;
  }

template<class E >

static queue_type& folly::pushmi::detail::trampoline< E >::pending ( pending_type &  p )

inlinestaticprivate

Definition at line 113 of file trampoline.h.

                                                     {
    return std::get<1>(p);
  }

template<class E >

static bool& folly::pushmi::detail::trampoline< E >::repeat ( pending_type &  p )

inlinestaticprivate

Definition at line 117 of file trampoline.h.

                                              {
    return std::get<2>(p);
  }

template<class E >

template<class Selector , class Derived >

static void folly::pushmi::detail::trampoline< E >::submit ( Selector  , Derived &  , recurse_t    )

inlinestatic

Definition at line 131 of file trampoline.h.

References folly::pushmi::PUSHMI_TEMPLATE(), folly::pushmi::repeat(), and folly::pushmi::requires().

                                                    {
    if (!is_owned()) {
      abort();
    }
    repeat(*owner()) = true;
  }

template<class E >

requires not static Same<SingleReceiver, recurse_t> void folly::pushmi::detail::trampoline< E >::submit ( ownordelegate_t  , SingleReceiver  awhat  )

inlinestatic

Definition at line 140 of file trampoline.h.

References folly::empty(), folly::gen::move, folly::pushmi::detail::ownornest, folly::pushmi::PUSHMI_TEMPLATE(), folly::pushmi::repeat(), folly::pushmi::requires(), folly::pushmi::set_done, folly::pushmi::set_error, folly::pushmi::set_value, and submit.

                            {
    delegator<E> that;

    if (is_owned()) {
      // thread already owned

      // poor mans scope guard
      try {
        if (++depth(*owner()) > 100) {
          // defer work to owner
          pending(*owner()).push_back(work_type{std::move(awhat)});
        } else {
          // dynamic recursion - optimization to balance queueing and
          // stack usage and value interleaving on the same thread.
          set_value(awhat, that);
          set_done(awhat);
        }
      } catch (...) {
        --depth(*owner());
        throw;
      }
      --depth(*owner());
      return;
    }

    // take over the thread

    pending_type pending_store;
    owner() = &pending_store;
    depth(pending_store) = 0;
    repeat(pending_store) = false;
    // poor mans scope guard
    try {
      trampoline<E>::submit(ownornest, std::move(awhat));
    } catch (...) {
      // ignore exceptions while delivering the exception
      try {
        set_error(awhat, std::current_exception());
        for (auto& what : pending(pending_store)) {
          set_error(what, std::current_exception());
        }
      } catch (...) {
      }
      pending(pending_store).clear();

      if (!is_owned()) {
        std::abort();
      }
      if (!pending(pending_store).empty()) {
        std::abort();
      }
      owner() = nullptr;
      throw;
    }
    if (!is_owned()) {
      std::abort();
    }
    if (!pending(pending_store).empty()) {
      std::abort();
    }
    owner() = nullptr;
  }

template<class E >

requires not static Same<SingleReceiver, recurse_t> void folly::pushmi::detail::trampoline< E >::submit ( ownornest_t  , SingleReceiver  awhat  )

inlinestatic

Definition at line 207 of file trampoline.h.

References folly::empty(), folly::gen::move, folly::pushmi::detail::ownordelegate, folly::pushmi::repeat(), folly::pushmi::set_done, folly::pushmi::set_value, and submit.

                            {
    delegator<E> that;

    if (!is_owned()) {
      trampoline<E>::submit(ownordelegate, std::move(awhat));
      return;
    }

    auto& pending_store = *owner();

    // static recursion - tail call optimization
    if (pending(pending_store).empty()) {
      bool go = true;
      while (go) {
        repeat(pending_store) = false;
        set_value(awhat, that);
        set_done(awhat);
        go = repeat(pending_store);
      }
    } else {
      pending(pending_store).push_back(work_type{std::move(awhat)});
    }

    if (pending(pending_store).empty()) {
      return;
    }

    while (!pending(pending_store).empty()) {
      auto what = std::move(pending(pending_store).front());
      pending(pending_store).pop_front();
      set_value(what, any_executor_ref<error_type>{that});
      set_done(what);
    }
  }

---

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

• proxygen/folly/folly/experimental/pushmi/trampoline.h