folly::fibers::Fiber Class Reference

Fiber object used by FiberManager to execute tasks. More...

#include <Fiber.h>

Classes
class	LocalData

Public Member Functions
void	resume ()
	Fiber (const Fiber &)=delete
Fiber &	operator= (const Fiber &)=delete
	~Fiber ()
std::pair< void *, size_t >	getStack () const

Private Types
enum	State {   INVALID, NOT_STARTED, READY_TO_RUN, RUNNING,   AWAITING, AWAITING_IMMEDIATE, YIELDED }

Private Member Functions
	Fiber (FiberManager &fiberManager)
void	init (bool recordStackUsed)
template<typename F >
void	setFunction (F &&func)
template<typename F , typename G >
void	setFunctionFinally (F &&func, G &&finally)
void	fiberFunc ()
void	preempt (State state)
void	recordStackPosition ()
void *	getUserBuffer ()

Private Attributes
State	state_ {INVALID}
FiberManager &	fiberManager_
size_t	fiberStackSize_
unsigned char *	fiberStackLimit_
FiberImpl	fiberImpl_
std::shared_ptr< RequestContext >	rcontext_
folly::Function< void()>	func_
bool	recordStackUsed_ {false}
bool	stackFilledWithMagic_ {false}
folly::AtomicIntrusiveLinkedListHook< Fiber >	nextRemoteReady_
std::aligned_storage< kUserBufferSize >::type	userBuffer_
folly::Function< void()>	resultFunc_
folly::Function< void()>	finallyFunc_
LocalData	localData_
folly::IntrusiveListHook	listHook_
folly::IntrusiveListHook	globalListHook_
std::thread::id	threadId_ {}

Static Private Attributes
static constexpr size_t	kUserBufferSize = 256

Friends
class	Baton
class	FiberManager

Detailed Description

Fiber object used by FiberManager to execute tasks.

Each Fiber object can be executing at most one task at a time. In active phase it is running the task function and keeps its context. Fiber is also used to pass data to blocked task and thus unblock it. Each Fiber may be associated with a single FiberManager.

Definition at line 45 of file Fiber.h.

Member Enumeration Documentation

enum folly::fibers::Fiber::State

private

Enumerator
INVALID	Does't have task function
NOT_STARTED	Has task function, not started
READY_TO_RUN	Was started, blocked, then unblocked
RUNNING	Is running right now
AWAITING	Is currently blocked
AWAITING_IMMEDIATE	Was preempted to run an immediate function, and will be resumed right away
YIELDED	The fiber yielded execution voluntarily

Definition at line 67 of file Fiber.h.

             {
    INVALID, 
    NOT_STARTED, 
    READY_TO_RUN, 
    RUNNING, 
    AWAITING, 
    AWAITING_IMMEDIATE, 
    YIELDED, 
  };

Constructor & Destructor Documentation

folly::fibers::Fiber::Fiber ( const Fiber &  )

delete

folly::fibers::Fiber::~Fiber

(

)

Definition at line 104 of file Fiber.cpp.

References folly::fibers::GuardPageAllocator::deallocate(), fiberManager_, fiberStackLimit_, fiberStackSize_, and folly::fibers::FiberManager::stackAllocator_.

              {
#ifdef FOLLY_SANITIZE_ADDRESS
  if (asanFakeStack_ != nullptr) {
    fiberManager_.freeFakeStack(asanFakeStack_);
  }
  fiberManager_.unpoisonFiberStack(this);
#endif
  fiberManager_.stackAllocator_.deallocate(fiberStackLimit_, fiberStackSize_);
}

folly::fibers::Fiber::Fiber ( FiberManager &  fiberManager )

explicitprivate

Definition at line 70 of file Fiber.cpp.

References folly::fibers::FiberManager::allFibers_, fiberFunc(), fiberManager_, fiberStackLimit_, and fiberStackSize_.

    : fiberManager_(fiberManager),
      fiberStackSize_(fiberManager_.options_.stackSize),
      fiberStackLimit_(fiberManager_.stackAllocator_.allocate(fiberStackSize_)),
      fiberImpl_([this] { fiberFunc(); }, fiberStackLimit_, fiberStackSize_) {
  fiberManager_.allFibers_.push_back(*this);
}

Member Function Documentation

void folly::fibers::Fiber::fiberFunc ( )

private

Definition at line 128 of file Fiber.cpp.

References folly::fibers::FiberManager::deactivateFiber(), folly::fibers::FiberManager::exceptionCallback_, fiberManager_, fiberStackLimit_, fiberStackSize_, finallyFunc_, func_, INVALID, max, NOT_STARTED, folly::fibers::FiberManager::options_, recordStackUsed_, resultFunc_, RUNNING, folly::fibers::FiberManager::stackHighWatermark_, folly::fibers::FiberManager::Options::stackSize, state_, threadId_, and UNLIKELY.

Referenced by Fiber(), and init().

                                   {
#ifdef FOLLY_SANITIZE_ADDRESS
  fiberManager_.registerFinishSwitchStackWithAsan(
      nullptr, &asanMainStackBase_, &asanMainStackSize_);
#endif

  while (true) {
    DCHECK_EQ(state_, NOT_STARTED);

    threadId_ = localThreadId();
    state_ = RUNNING;

    try {
      if (resultFunc_) {
        DCHECK(finallyFunc_);
        DCHECK(!func_);

        resultFunc_();
      } else {
        DCHECK(func_);
        func_();
      }
    } catch (...) {
      fiberManager_.exceptionCallback_(
          std::current_exception(), "running Fiber func_/resultFunc_");
    }

    if (UNLIKELY(recordStackUsed_)) {
      fiberManager_.stackHighWatermark_ = std::max(
          fiberManager_.stackHighWatermark_,
          nonMagicInBytes(fiberStackLimit_, fiberStackSize_));
      VLOG(3) << "Max stack usage: " << fiberManager_.stackHighWatermark_;
      CHECK(
          fiberManager_.stackHighWatermark_ <
          fiberManager_.options_.stackSize - 64)
          << "Fiber stack overflow";
    }

    state_ = INVALID;

    fiberManager_.deactivateFiber(this);
  }
}

std::pair<void*, size_t> folly::fibers::Fiber::getStack ( ) const

inline

Retrieve this fiber's base stack and stack size.

Returns

This fiber's stack pointer and stack size.

Definition at line 62 of file Fiber.h.

References fiberStackLimit_, and fiberStackSize_.

Referenced by folly::fibers::FiberManager::activateFiber(), and folly::fibers::FiberManager::FibersPoolResizer::operator()().

                                          {
    return {fiberStackLimit_, fiberStackSize_};
  }

void * folly::fibers::Fiber::getUserBuffer ( )

inlineprivate

Definition at line 38 of file Fiber-inl.h.

References userBuffer_.

                                  {
  return &userBuffer_;
}

void folly::fibers::Fiber::init ( bool  recordStackUsed )

private

Definition at line 78 of file Fiber.cpp.

References fiberFunc(), fiberImpl_, fiberStackLimit_, fiberStackSize_, recordStackUsed_, stackFilledWithMagic_, uint64_t, and UNLIKELY.

Referenced by folly::fibers::FiberManager::getFiber().

                                     {
// It is necessary to disable the logic for ASAN because we change
// the fiber's stack.
#ifndef FOLLY_SANITIZE_ADDRESS
  recordStackUsed_ = recordStackUsed;
  if (UNLIKELY(recordStackUsed_ && !stackFilledWithMagic_)) {
    CHECK_EQ(
        reinterpret_cast<intptr_t>(fiberStackLimit_) % sizeof(uint64_t), 0u);
    CHECK_EQ(fiberStackSize_ % sizeof(uint64_t), 0u);
    std::fill(
        reinterpret_cast<uint64_t*>(fiberStackLimit_),
        reinterpret_cast<uint64_t*>(fiberStackLimit_ + fiberStackSize_),
        kMagic8Bytes);

    stackFilledWithMagic_ = true;

    // newer versions of boost allocate context on fiber stack,
    // need to create a new one
    fiberImpl_ =
        FiberImpl([this] { fiberFunc(); }, fiberStackLimit_, fiberStackSize_);
  }
#else
  (void)recordStackUsed;
#endif
}

Fiber& folly::fibers::Fiber::operator= ( const Fiber &  )

delete

void folly::fibers::Fiber::preempt ( State  state )

private

Switch out of fiber context into the main context, performing necessary housekeeping for the new state.

Parameters

state

New state, must not be RUNNING.

Definition at line 172 of file Fiber.cpp.

References folly::fibers::FiberManager::activeFiber_, folly::fibers::FiberManager::deactivateFiber(), fiberManager_, folly::fibers::FiberManager::preemptRunner_, READY_TO_RUN, recordStackPosition(), folly::fibers::InlineFunctionRunner::run(), RUNNING, and state_.

Referenced by folly::fibers::FiberManager::runInMainContext(), folly::fibers::Baton::waitFiber(), and folly::fibers::FiberManager::yield().

                               {
  auto preemptImpl = [&]() mutable {
    DCHECK_EQ(fiberManager_.activeFiber_, this);
    DCHECK_EQ(state_, RUNNING);
    DCHECK_NE(state, RUNNING);
    DCHECK(!std::current_exception());

    state_ = state;

    recordStackPosition();

    fiberManager_.deactivateFiber(this);

    DCHECK_EQ(fiberManager_.activeFiber_, this);
    DCHECK_EQ(state_, READY_TO_RUN);
    state_ = RUNNING;
  };

  if (fiberManager_.preemptRunner_) {
    fiberManager_.preemptRunner_->run(std::ref(preemptImpl));
  } else {
    preemptImpl();
  }
}

void folly::fibers::Fiber::recordStackPosition ( )

private

Examines how much of the stack we used at this moment and registers with the FiberManager (for monitoring).

Definition at line 114 of file Fiber.cpp.

References fiberManager_, fiberStackLimit_, fiberStackSize_, max, and folly::fibers::FiberManager::stackHighWatermark_.

Referenced by preempt().

                                {
  // For ASAN builds, functions may run on fake stack.
  // So we cannot get meaningful stack position.
#ifndef FOLLY_SANITIZE_ADDRESS
  int stackDummy;
  auto currentPosition = static_cast<size_t>(
      fiberStackLimit_ + fiberStackSize_ -
      static_cast<unsigned char*>(static_cast<void*>(&stackDummy)));
  fiberManager_.stackHighWatermark_ =
      std::max(fiberManager_.stackHighWatermark_, currentPosition);
  VLOG(4) << "Stack usage: " << currentPosition;
#endif
}

void folly::fibers::Fiber::resume

(

)

Resume the blocked task

Definition at line 54 of file Fiber.cpp.

References AWAITING, folly::fibers::FiberManager::ensureLoopScheduled(), fiberManager_, LIKELY, folly::fibers::FiberManager::observer_, READY_TO_RUN, folly::fibers::FiberManager::readyFibers_, folly::fibers::FiberManager::remoteReadyInsert(), folly::ExecutionObserver::runnable(), state_, and threadId_.

Referenced by folly::fibers::Baton::FiberWaiter::post().

                   {
  DCHECK_EQ(state_, AWAITING);
  state_ = READY_TO_RUN;

  if (fiberManager_.observer_) {
    fiberManager_.observer_->runnable(reinterpret_cast<uintptr_t>(this));
  }

  if (LIKELY(threadId_ == localThreadId())) {
    fiberManager_.readyFibers_.push_back(*this);
    fiberManager_.ensureLoopScheduled();
  } else {
    fiberManager_.remoteReadyInsert(this);
  }
}

template<typename F >

void folly::fibers::Fiber::setFunction ( F &&  func )

private

Definition at line 24 of file Fiber-inl.h.

References func_, INVALID, NOT_STARTED, and state_.

Referenced by folly::fibers::FiberManager::loopUntilNoReadyImpl().

                                {
  assert(state_ == INVALID);
  func_ = std::forward<F>(func);
  state_ = NOT_STARTED;
}

template<typename F , typename G >

void folly::fibers::Fiber::setFunctionFinally ( F &&  func, G &&  finally  )

private

Definition at line 31 of file Fiber-inl.h.

References finallyFunc_, INVALID, NOT_STARTED, resultFunc_, and state_.

                                                              {
  assert(state_ == INVALID);
  resultFunc_ = std::forward<F>(resultFunc);
  finallyFunc_ = std::forward<G>(finallyFunc);
  state_ = NOT_STARTED;
}

Friends And Related Function Documentation

friend class Baton

friend

Definition at line 80 of file Fiber.h.

friend class FiberManager

friend

Definition at line 81 of file Fiber.h.

Member Data Documentation

FiberImpl folly::fibers::Fiber::fiberImpl_

private

underlying fiber implementation

Definition at line 112 of file Fiber.h.

Referenced by folly::fibers::FiberManager::activateFiber(), folly::fibers::FiberManager::deactivateFiber(), and init().

FiberManager& folly::fibers::Fiber::fiberManager_

private

Associated FiberManager

Definition at line 109 of file Fiber.h.

Referenced by Fiber(), fiberFunc(), preempt(), recordStackPosition(), resume(), and ~Fiber().

unsigned char* folly::fibers::Fiber::fiberStackLimit_

private

Definition at line 111 of file Fiber.h.

Referenced by Fiber(), fiberFunc(), getStack(), init(), recordStackPosition(), and ~Fiber().

size_t folly::fibers::Fiber::fiberStackSize_

private

Definition at line 110 of file Fiber.h.

Referenced by Fiber(), fiberFunc(), getStack(), init(), recordStackPosition(), and ~Fiber().

folly::Function<void()> folly::fibers::Fiber::finallyFunc_

private

Definition at line 129 of file Fiber.h.

Referenced by fiberFunc(), folly::fibers::FiberManager::runReadyFiber(), and setFunctionFinally().

folly::Function<void()> folly::fibers::Fiber::func_

private

task function

Definition at line 114 of file Fiber.h.

Referenced by fiberFunc(), folly::fibers::FiberManager::runReadyFiber(), and setFunction().

folly::IntrusiveListHook folly::fibers::Fiber::globalListHook_

private

list hook for global list

Definition at line 177 of file Fiber.h.

constexpr size_t folly::fibers::Fiber::kUserBufferSize = 256

staticprivate

Definition at line 123 of file Fiber.h.

folly::IntrusiveListHook folly::fibers::Fiber::listHook_

private

list hook for different FiberManager queues

Definition at line 175 of file Fiber.h.

LocalData folly::fibers::Fiber::localData_

private

Definition at line 173 of file Fiber.h.

Referenced by folly::fibers::FiberManager::initLocalData(), folly::fibers::FiberManager::local(), folly::fibers::FiberManager::loopUntilNoReadyImpl(), and folly::fibers::FiberManager::runReadyFiber().

folly::AtomicIntrusiveLinkedListHook<Fiber> folly::fibers::Fiber::nextRemoteReady_

private

Points to next fiber in remote ready list

Definition at line 121 of file Fiber.h.

std::shared_ptr<RequestContext> folly::fibers::Fiber::rcontext_

private

current RequestContext

Definition at line 113 of file Fiber.h.

Referenced by folly::fibers::FiberManager::initLocalData(), folly::fibers::FiberManager::loopUntilNoReadyImpl(), and folly::fibers::FiberManager::runReadyFiber().

bool folly::fibers::Fiber::recordStackUsed_ {false}

private

Definition at line 115 of file Fiber.h.

Referenced by fiberFunc(), and init().

folly::Function<void()> folly::fibers::Fiber::resultFunc_

private

Definition at line 128 of file Fiber.h.

Referenced by fiberFunc(), folly::fibers::FiberManager::runReadyFiber(), and setFunctionFinally().

bool folly::fibers::Fiber::stackFilledWithMagic_ {false}

private

Definition at line 116 of file Fiber.h.

Referenced by init().

State folly::fibers::Fiber::state_ {INVALID}

private

current Fiber state

Definition at line 78 of file Fiber.h.

Referenced by fiberFunc(), preempt(), resume(), folly::fibers::FiberManager::runReadyFiber(), setFunction(), setFunctionFinally(), and folly::fibers::FiberManager::yield().

std::thread::id folly::fibers::Fiber::threadId_ {}

private

Definition at line 178 of file Fiber.h.

Referenced by fiberFunc(), and resume().

std::aligned_storage<kUserBufferSize>::type folly::fibers::Fiber::userBuffer_

private

Definition at line 124 of file Fiber.h.

Referenced by getUserBuffer().

---

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

• proxygen/folly/folly/fibers/Fiber.h
• proxygen/folly/folly/fibers/Fiber-inl.h
• proxygen/folly/folly/fibers/Fiber.cpp