folly::futures::detail::DeferredExecutor Class Reference

#include <Future-inl.h>

Inheritance diagram for folly::futures::detail::DeferredExecutor:

Public Member Functions
void	add (Func func) override
void	setExecutor (folly::Executor::KeepAlive<> executor)
void	detach ()
void	setNestedExecutors (std::vector< folly::Executor::KeepAlive< DeferredExecutor >> executors)
Public Member Functions inherited from folly::Executor
virtual	~Executor ()
virtual void	addWithPriority (Func, int8_t priority)
virtual uint8_t	getNumPriorities () const

Static Public Member Functions
static KeepAlive< DeferredExecutor >	create ()
Static Public Member Functions inherited from folly::Executor
template<typename ExecutorT >
static KeepAlive< ExecutorT >	getKeepAliveToken (ExecutorT *executor)
template<typename ExecutorT >
static KeepAlive< ExecutorT >	getKeepAliveToken (ExecutorT &executor)

Private Types
enum	State { State::EMPTY, State::HAS_FUNCTION, State::HAS_EXECUTOR, State::DETACHED }

Private Member Functions
	DeferredExecutor ()
bool	keepAliveAcquire () override
void	keepAliveRelease () override

Private Attributes
std::atomic< State >	state_ {State::EMPTY}
Func	func_
folly::Executor::KeepAlive	executor_
std::unique_ptr< std::vector< folly::Executor::KeepAlive< DeferredExecutor > > >	nestedExecutors_
std::atomic< ssize_t >	keepAliveCount_ {1}

Additional Inherited Members
Static Public Attributes inherited from folly::Executor
static const int8_t	LO_PRI = SCHAR_MIN
static const int8_t	MID_PRI = 0
static const int8_t	HI_PRI = SCHAR_MAX
Static Protected Member Functions inherited from folly::Executor
template<typename ExecutorT >
static bool	isKeepAliveDummy (const KeepAlive< ExecutorT > &keepAlive)
template<typename ExecutorT >
static KeepAlive< ExecutorT >	makeKeepAlive (ExecutorT *executor)

Detailed Description

Defer work until executor is actively boosted.

NOTE: that this executor is a private implementation detail belonging to the Folly Futures library and not intended to be used elsewhere. It is designed specifically for the use case of deferring work on a SemiFuture. It is NOT thread safe. Please do not use for any other purpose without great care.

Definition at line 497 of file Future-inl.h.

Member Enumeration Documentation

enum folly::futures::detail::DeferredExecutor::State

strongprivate

Enumerator
EMPTY
HAS_FUNCTION
HAS_EXECUTOR
DETACHED

Definition at line 601 of file Future-inl.h.

{ EMPTY, HAS_FUNCTION, HAS_EXECUTOR, DETACHED };

Constructor & Destructor Documentation

folly::futures::detail::DeferredExecutor::DeferredExecutor ( )

inlineprivate

Definition at line 583 of file Future-inl.h.

{}

Member Function Documentation

void folly::futures::detail::DeferredExecutor::add ( Func  )

inlineoverridevirtual

Enqueue a function to executed by this executor. This and all variants must be threadsafe.

Implements folly::Executor.

Definition at line 499 of file Future-inl.h.

References folly::exchange(), and folly::gen::move.

                               {
    auto state = state_.load(std::memory_order_acquire);
    if (state == State::DETACHED) {
      return;
    }
    if (state == State::HAS_EXECUTOR) {
      executor_->add(std::move(func));
      return;
    }
    DCHECK(state == State::EMPTY);
    func_ = std::move(func);
    if (state_.compare_exchange_strong(
            state,
            State::HAS_FUNCTION,
            std::memory_order_release,
            std::memory_order_acquire)) {
      return;
    }
    DCHECK(state == State::DETACHED || state == State::HAS_EXECUTOR);
    if (state == State::DETACHED) {
      std::exchange(func_, nullptr);
      return;
    }
    executor_->add(std::exchange(func_, nullptr));
  }

static KeepAlive<DeferredExecutor> folly::futures::detail::DeferredExecutor::create ( )

inlinestatic

Definition at line 578 of file Future-inl.h.

Referenced by folly::SemiFuture< T >::defer().

                                              {
    return makeKeepAlive<DeferredExecutor>(new DeferredExecutor());
  }

void folly::futures::detail::DeferredExecutor::detach ( )

inline

Definition at line 548 of file Future-inl.h.

References folly::exchange().

                {
    if (nestedExecutors_) {
      auto nestedExecutors = std::exchange(nestedExecutors_, nullptr);
      for (auto& nestedExecutor : *nestedExecutors) {
        nestedExecutor->detach();
      }
    }
    auto state = state_.load(std::memory_order_acquire);
    if (state == State::EMPTY &&
        state_.compare_exchange_strong(
            state,
            State::DETACHED,
            std::memory_order_release,
            std::memory_order_acquire)) {
      return;
    }

    DCHECK(state == State::HAS_FUNCTION);
    state_.store(State::DETACHED, std::memory_order_release);
    std::exchange(func_, nullptr);
  }

bool folly::futures::detail::DeferredExecutor::keepAliveAcquire ( )

inlineoverrideprivatevirtual

Reimplemented from folly::Executor.

Definition at line 585 of file Future-inl.h.

                                   {
    auto keepAliveCount =
        keepAliveCount_.fetch_add(1, std::memory_order_relaxed);
    DCHECK(keepAliveCount > 0);
    return true;
  }

void folly::futures::detail::DeferredExecutor::keepAliveRelease ( )

inlineoverrideprivatevirtual

Reimplemented from folly::Executor.

Definition at line 592 of file Future-inl.h.

                                   {
    auto keepAliveCount =
        keepAliveCount_.fetch_sub(1, std::memory_order_acq_rel);
    DCHECK(keepAliveCount > 0);
    if (keepAliveCount == 1) {
      delete this;
    }
  }

void folly::futures::detail::DeferredExecutor::setExecutor ( folly::Executor::KeepAlive<>  executor )

inline

Definition at line 525 of file Future-inl.h.

References folly::Executor::KeepAlive< ExecutorT >::copy(), folly::exchange(), and folly::gen::move.

                                                      {
    if (nestedExecutors_) {
      auto nestedExecutors = std::exchange(nestedExecutors_, nullptr);
      for (auto& nestedExecutor : *nestedExecutors) {
        nestedExecutor->setExecutor(executor.copy());
      }
    }
    executor_ = std::move(executor);
    auto state = state_.load(std::memory_order_acquire);
    if (state == State::EMPTY &&
        state_.compare_exchange_strong(
            state,
            State::HAS_EXECUTOR,
            std::memory_order_release,
            std::memory_order_acquire)) {
      return;
    }

    DCHECK(state == State::HAS_FUNCTION);
    state_.store(State::HAS_EXECUTOR, std::memory_order_release);
    executor_->add(std::exchange(func_, nullptr));
  }

void folly::futures::detail::DeferredExecutor::setNestedExecutors ( std::vector< folly::Executor::KeepAlive< DeferredExecutor >>  executors )

inline

Definition at line 570 of file Future-inl.h.

References folly::make_unique(), and folly::gen::move.

                                                                     {
    DCHECK(!nestedExecutors_);
    nestedExecutors_ = std::make_unique<
        std::vector<folly::Executor::KeepAlive<DeferredExecutor>>>(
        std::move(executors));
  }

Member Data Documentation

folly::Executor::KeepAlive folly::futures::detail::DeferredExecutor::executor_

private

Definition at line 604 of file Future-inl.h.

Func folly::futures::detail::DeferredExecutor::func_

private

Definition at line 603 of file Future-inl.h.

std::atomic<ssize_t> folly::futures::detail::DeferredExecutor::keepAliveCount_ {1}

private

Definition at line 607 of file Future-inl.h.

std::unique_ptr<std::vector<folly::Executor::KeepAlive<DeferredExecutor> > > folly::futures::detail::DeferredExecutor::nestedExecutors_

private

Definition at line 606 of file Future-inl.h.

std::atomic<State> folly::futures::detail::DeferredExecutor::state_ {State::EMPTY}

private

Definition at line 602 of file Future-inl.h.

---

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

• proxygen/folly/folly/futures/Future-inl.h