if (LIKELY(baton_fiber == NO_WAITER)) {
continue;
} else if (baton_fiber == POSTED || baton_fiber == TIMEOUT) {
- fiber.setData(0);
+ fiber.resume();
break;
} else {
throw std::logic_error("Some Fiber is already waiting on this Baton.");
} while (!waitingFiber_.compare_exchange_weak(fiber, new_value));
if (fiber != NO_WAITER) {
- reinterpret_cast<Fiber*>(fiber)->setData(0);
+ reinterpret_cast<Fiber*>(fiber)->resume();
}
}
} // anonymous namespace
-void Fiber::setData(intptr_t data) {
+void Fiber::resume() {
DCHECK_EQ(state_, AWAITING);
- data_ = data;
state_ = READY_TO_RUN;
if (fiberManager_.observer_) {
state_ = INVALID;
- auto context = fiberManager_.deactivateFiber(this);
-
- DCHECK_EQ(reinterpret_cast<Fiber*>(context), this);
+ fiberManager_.deactivateFiber(this);
}
}
-intptr_t Fiber::preempt(State state) {
- intptr_t ret;
-
+void Fiber::preempt(State state) {
auto preemptImpl = [&]() mutable {
DCHECK_EQ(fiberManager_.activeFiber_, this);
DCHECK_EQ(state_, RUNNING);
recordStackPosition();
- ret = fiberManager_.deactivateFiber(this);
+ fiberManager_.deactivateFiber(this);
DCHECK_EQ(fiberManager_.activeFiber_, this);
DCHECK_EQ(state_, READY_TO_RUN);
} else {
preemptImpl();
}
-
- return ret;
}
Fiber::LocalData::LocalData(const LocalData& other) : data_(nullptr) {
class Fiber {
public:
/**
- * Sets data for the blocked task
- *
- * @param data this data will be returned by await() when task is resumed.
+ * Resume the blocked task
*/
- void setData(intptr_t data);
+ void resume();
Fiber(const Fiber&) = delete;
Fiber& operator=(const Fiber&) = delete;
* performing necessary housekeeping for the new state.
*
* @param state New state, must not be RUNNING.
- *
- * @return The value passed back from the main context.
*/
- intptr_t preempt(State state);
+ void preempt(State state);
/**
* Examines how much of the stack we used at this moment and
FiberManager& fiberManager_; /**< Associated FiberManager */
FContext fcontext_; /**< current task execution context */
- intptr_t data_; /**< Used to keep some data with the Fiber */
std::shared_ptr<RequestContext> rcontext_; /**< current RequestContext */
folly::Function<void()> func_; /**< task function */
bool recordStackUsed_{false};
loopController_->schedule();
}
-inline intptr_t FiberManager::activateFiber(Fiber* fiber) {
+inline void FiberManager::activateFiber(Fiber* fiber) {
DCHECK_EQ(activeFiber_, (Fiber*)nullptr);
#ifdef FOLLY_SANITIZE_ADDRESS
#endif
activeFiber_ = fiber;
- return jumpContext(&mainContext_, &fiber->fcontext_, fiber->data_);
+ jumpContext(
+ &mainContext_, &fiber->fcontext_, reinterpret_cast<intptr_t>(fiber));
}
-inline intptr_t FiberManager::deactivateFiber(Fiber* fiber) {
+inline void FiberManager::deactivateFiber(Fiber* fiber) {
DCHECK_EQ(activeFiber_, fiber);
#ifdef FOLLY_SANITIZE_ADDRESS
#endif
activeFiber_ = nullptr;
- return jumpContext(&fiber->fcontext_, &mainContext_, 0);
+ auto context = jumpContext(&fiber->fcontext_, &mainContext_, 0);
+ DCHECK_EQ(fiber, reinterpret_cast<Fiber*>(context));
}
inline void FiberManager::runReadyFiber(Fiber* fiber) {
fiber->rcontext_ = std::move(task->rcontext);
fiber->setFunction(std::move(task->func));
- fiber->data_ = reinterpret_cast<intptr_t>(fiber);
if (observer_) {
observer_->runnable(reinterpret_cast<uintptr_t>(fiber));
}
fiber->setFunction(std::ref(*funcLoc));
}
- fiber->data_ = reinterpret_cast<intptr_t>(fiber);
readyFibers_.push_back(*fiber);
if (observer_) {
observer_->runnable(reinterpret_cast<uintptr_t>(fiber));
fiber->setFunctionFinally(std::ref(*funcLoc), std::ref(*finallyLoc));
}
- fiber->data_ = reinterpret_cast<intptr_t>(fiber);
readyFibers_.push_back(*fiber);
if (observer_) {
observer_->runnable(reinterpret_cast<uintptr_t>(fiber));
AtomicIntrusiveLinkedListHook<RemoteTask> nextRemoteTask;
};
- intptr_t activateFiber(Fiber* fiber);
- intptr_t deactivateFiber(Fiber* fiber);
+ void activateFiber(Fiber* fiber);
+ void deactivateFiber(Fiber* fiber);
typedef folly::IntrusiveList<Fiber, &Fiber::listHook_> FiberTailQueue;
typedef folly::IntrusiveList<Fiber, &Fiber::globalListHook_>