/*
- * Copyright 2015 Facebook, Inc.
+ * Copyright 2016 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <folly/ThreadName.h>
#include <folly/io/async/NotificationQueue.h>
+#include <folly/portability/Unistd.h>
-#include <boost/static_assert.hpp>
#include <condition_variable>
#include <fcntl.h>
#include <mutex>
#include <pthread.h>
-#include <unistd.h>
namespace {
-using folly::Cob;
using folly::EventBase;
-template <typename Callback>
class FunctionLoopCallback : public EventBase::LoopCallback {
public:
- explicit FunctionLoopCallback(Cob&& function)
+ explicit FunctionLoopCallback(EventBase::Func&& function)
: function_(std::move(function)) {}
- explicit FunctionLoopCallback(const Cob& function) : function_(function) {}
-
void runLoopCallback() noexcept override {
function_();
delete this;
}
private:
- Callback function_;
+ EventBase::Func function_;
};
}
namespace folly {
-const int kNoFD = -1;
-
/*
* EventBase::FunctionRunner
*/
-class EventBase::FunctionRunner : public NotificationQueue<Cob>::Consumer {
+class EventBase::FunctionRunner
+ : public NotificationQueue<EventBase::Func>::Consumer {
public:
- void messageAvailable(Cob&& msg) override {
-
+ void messageAvailable(Func&& msg) override {
// In libevent2, internal events do not break the loop.
// Most users would expect loop(), followed by runInEventBaseThread(),
// to break the loop and check if it should exit or not.
EventBase::EventBase(bool enableTimeMeasurement)
: runOnceCallbacks_(nullptr)
, stop_(false)
- , loopThread_(0)
+ , loopThread_()
, queue_(nullptr)
, fnRunner_(nullptr)
, maxLatency_(0)
, observer_(nullptr)
, observerSampleCount_(0)
, executionObserver_(nullptr) {
+ struct event ev;
{
std::lock_guard<std::mutex> lock(libevent_mutex_);
// allowing examination of its value without an explicit reference here.
// If ev.ev_base is NULL, then event_init() must be called, otherwise
// call event_base_new().
- struct event ev;
event_set(&ev, 0, 0, nullptr, nullptr);
- evb_ = (ev.ev_base) ? event_base_new() : event_init();
+ if (!ev.ev_base) {
+ evb_ = event_init();
+ }
}
+
+ if (ev.ev_base) {
+ evb_ = event_base_new();
+ }
+
if (UNLIKELY(evb_ == nullptr)) {
LOG(ERROR) << "EventBase(): Failed to init event base.";
folly::throwSystemError("error in EventBase::EventBase()");
EventBase::EventBase(event_base* evb, bool enableTimeMeasurement)
: runOnceCallbacks_(nullptr)
, stop_(false)
- , loopThread_(0)
+ , loopThread_()
, evb_(evb)
, queue_(nullptr)
, fnRunner_(nullptr)
}
EventBase::~EventBase() {
+ // Keep looping until all keep-alive handles are released. Each keep-alive
+ // handle signals that some external code will still schedule some work on
+ // this EventBase (so it's not safe to destroy it).
+ while (loopKeepAliveCount_ > 0) {
+ applyLoopKeepAlive();
+ loopOnce();
+ }
+
// Call all destruction callbacks, before we start cleaning up our state.
while (!onDestructionCallbacks_.empty()) {
LoopCallback* callback = &onDestructionCallbacks_.front();
delete &runBeforeLoopCallbacks_.front();
}
- (void) runLoopCallbacks(false);
+ (void)runLoopCallbacks();
if (!fnRunner_->consumeUntilDrained()) {
LOG(ERROR) << "~EventBase(): Unable to drain notification queue";
event_base_free(evb_);
}
- while (!runAfterDrainCallbacks_.empty()) {
- LoopCallback* callback = &runAfterDrainCallbacks_.front();
- runAfterDrainCallbacks_.pop_front();
- callback->runLoopCallback();
- }
-
{
std::lock_guard<std::mutex> lock(localStorageMutex_);
for (auto storage : localStorageToDtor_) {
bool EventBase::loopBody(int flags) {
VLOG(5) << "EventBase(): Starting loop.";
+
+ DCHECK(!invokingLoop_)
+ << "Your code just tried to loop over an event base from inside another "
+ << "event base loop. Since libevent is not reentrant, this leads to "
+ << "undefined behavior in opt builds. Please fix immediately. For the "
+ << "common case of an inner function that needs to do some synchronous "
+ << "computation on an event-base, replace getEventBase() by a new, "
+ << "stack-allocated EvenBase.";
+ invokingLoop_ = true;
+ SCOPE_EXIT {
+ invokingLoop_ = false;
+ };
+
int res = 0;
bool ranLoopCallbacks;
bool blocking = !(flags & EVLOOP_NONBLOCK);
}
while (!stop_.load(std::memory_order_acquire)) {
+ applyLoopKeepAlive();
++nextLoopCnt_;
// Run the before loop callbacks
idleStart = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now().time_since_epoch()).count();
} else {
- VLOG(11) << "EventBase " << this << " did not timeout "
- " time measurement is disabled "
- " nothingHandledYet(): "<< nothingHandledYet();
+ VLOG(11) << "EventBase " << this << " did not timeout";
}
// If the event loop indicate that there were no more events, and
return false;
}
- loopThread_.store(0, std::memory_order_release);
+ loopThread_.store({}, std::memory_order_release);
VLOG(5) << "EventBase(): Done with loop.";
return true;
}
-void EventBase::loopForever() {
- // Update the notification queue event to treat it as a normal (non-internal)
- // event. The notification queue event always remains installed, and the main
- // loop won't exit with it installed.
- fnRunner_->stopConsuming();
- fnRunner_->startConsuming(this, queue_.get());
-
- bool ret = loop();
+void EventBase::applyLoopKeepAlive() {
+ if (loopKeepAliveActive_ && loopKeepAliveCount_ == 0) {
+ // Restore the notification queue internal flag
+ fnRunner_->stopConsuming();
+ fnRunner_->startConsumingInternal(this, queue_.get());
+ loopKeepAliveActive_ = false;
+ } else if (!loopKeepAliveActive_ && loopKeepAliveCount_ > 0) {
+ // Update the notification queue event to treat it as a normal
+ // (non-internal) event. The notification queue event always remains
+ // installed, and the main loop won't exit with it installed.
+ fnRunner_->stopConsuming();
+ fnRunner_->startConsuming(this, queue_.get());
+ loopKeepAliveActive_ = true;
+ }
+}
- // Restore the notification queue internal flag
- fnRunner_->stopConsuming();
- fnRunner_->startConsumingInternal(this, queue_.get());
+void EventBase::loopForever() {
+ bool ret;
+ {
+ SCOPE_EXIT {
+ applyLoopKeepAlive();
+ };
+ // Make sure notification queue events are treated as normal events.
+ auto keepAlive = loopKeepAlive();
+ ret = loop();
+ }
if (!ret) {
folly::throwSystemError("error in EventBase::loopForever()");
}
}
-bool EventBase::bumpHandlingTime() {
+void EventBase::bumpHandlingTime() {
+ if (!enableTimeMeasurement_) {
+ return;
+ }
+
VLOG(11) << "EventBase " << this << " " << __PRETTY_FUNCTION__ <<
" (loop) latest " << latestLoopCnt_ << " next " << nextLoopCnt_;
- if(nothingHandledYet()) {
+ if (nothingHandledYet()) {
latestLoopCnt_ = nextLoopCnt_;
- if (enableTimeMeasurement_) {
- // set the time
- startWork_ = std::chrono::duration_cast<std::chrono::microseconds>(
- std::chrono::steady_clock::now().time_since_epoch()).count();
+ // set the time
+ startWork_ = std::chrono::duration_cast<std::chrono::microseconds>(
+ std::chrono::steady_clock::now().time_since_epoch())
+ .count();
- VLOG(11) << "EventBase " << this << " " << __PRETTY_FUNCTION__ <<
- " (loop) startWork_ " << startWork_;
- }
- return true;
+ VLOG(11) << "EventBase " << this << " " << __PRETTY_FUNCTION__
+ << " (loop) startWork_ " << startWork_;
}
- return false;
}
void EventBase::terminateLoopSoon() {
}
}
-void EventBase::runInLoop(const Cob& cob, bool thisIteration) {
+void EventBase::runInLoop(Func cob, bool thisIteration) {
DCHECK(isInEventBaseThread());
- auto wrapper = new FunctionLoopCallback<Cob>(cob);
+ auto wrapper = new FunctionLoopCallback(std::move(cob));
wrapper->context_ = RequestContext::saveContext();
if (runOnceCallbacks_ != nullptr && thisIteration) {
runOnceCallbacks_->push_back(*wrapper);
}
}
-void EventBase::runInLoop(Cob&& cob, bool thisIteration) {
- DCHECK(isInEventBaseThread());
- auto wrapper = new FunctionLoopCallback<Cob>(std::move(cob));
- wrapper->context_ = RequestContext::saveContext();
- if (runOnceCallbacks_ != nullptr && thisIteration) {
- runOnceCallbacks_->push_back(*wrapper);
- } else {
- loopCallbacks_.push_back(*wrapper);
- }
-}
-
-void EventBase::runAfterDrain(Cob&& cob) {
- auto callback = new FunctionLoopCallback<Cob>(std::move(cob));
- std::lock_guard<std::mutex> lg(runAfterDrainCallbacksMutex_);
- callback->cancelLoopCallback();
- runAfterDrainCallbacks_.push_back(*callback);
-}
-
void EventBase::runOnDestruction(LoopCallback* callback) {
std::lock_guard<std::mutex> lg(onDestructionCallbacksMutex_);
callback->cancelLoopCallback();
runBeforeLoopCallbacks_.push_back(*callback);
}
-bool EventBase::runInEventBaseThread(const Cob& fn) {
+bool EventBase::runInEventBaseThread(Func fn) {
// Send the message.
// It will be received by the FunctionRunner in the EventBase's thread.
// Short-circuit if we are already in our event base
if (inRunningEventBaseThread()) {
- runInLoop(fn);
+ runInLoop(std::move(fn));
return true;
}
try {
- queue_->putMessage(fn);
+ queue_->putMessage(std::move(fn));
} catch (const std::exception& ex) {
LOG(ERROR) << "EventBase " << this << ": failed to schedule function "
<< "for EventBase thread: " << ex.what();
return true;
}
-bool EventBase::runInEventBaseThreadAndWait(const Cob& fn) {
+bool EventBase::runInEventBaseThreadAndWait(Func fn) {
if (inRunningEventBaseThread()) {
LOG(ERROR) << "EventBase " << this << ": Waiting in the event loop is not "
<< "allowed";
return true;
}
-bool EventBase::runImmediatelyOrRunInEventBaseThreadAndWait(const Cob& fn) {
+bool EventBase::runImmediatelyOrRunInEventBaseThreadAndWait(Func fn) {
if (isInEventBaseThread()) {
fn();
return true;
} else {
- return runInEventBaseThreadAndWait(fn);
+ return runInEventBaseThreadAndWait(std::move(fn));
}
}
-void EventBase::runAfterDelay(const Cob& cob,
- uint32_t milliseconds,
- TimeoutManager::InternalEnum in) {
- if (!tryRunAfterDelay(cob, milliseconds, in)) {
+void EventBase::runAfterDelay(
+ Func cob,
+ uint32_t milliseconds,
+ TimeoutManager::InternalEnum in) {
+ if (!tryRunAfterDelay(std::move(cob), milliseconds, in)) {
folly::throwSystemError(
"error in EventBase::runAfterDelay(), failed to schedule timeout");
}
}
-bool EventBase::tryRunAfterDelay(const Cob& cob,
- uint32_t milliseconds,
- TimeoutManager::InternalEnum in) {
- CobTimeout* timeout = new CobTimeout(this, cob, in);
+bool EventBase::tryRunAfterDelay(
+ Func cob,
+ uint32_t milliseconds,
+ TimeoutManager::InternalEnum in) {
+ CobTimeout* timeout = new CobTimeout(this, std::move(cob), in);
if (!timeout->scheduleTimeout(milliseconds)) {
delete timeout;
return false;
return true;
}
-bool EventBase::runLoopCallbacks(bool setContext) {
+bool EventBase::runLoopCallbacks() {
if (!loopCallbacks_.empty()) {
bumpHandlingTime();
// Swap the loopCallbacks_ list with a temporary list on our stack.
while (!currentCallbacks.empty()) {
LoopCallback* callback = ¤tCallbacks.front();
currentCallbacks.pop_front();
- if (setContext) {
- RequestContext::setContext(callback->context_);
- }
+ folly::RequestContextScopeGuard rctx(callback->context_);
callback->runLoopCallback();
}
void EventBase::initNotificationQueue() {
// Infinite size queue
- queue_.reset(new NotificationQueue<Cob>());
+ queue_.reset(new NotificationQueue<Func>());
// We allocate fnRunner_ separately, rather than declaring it directly
// as a member of EventBase solely so that we don't need to include
value_ += (1.0 - coeff) * busy;
}
-bool EventBase::nothingHandledYet() {
+bool EventBase::nothingHandledYet() const noexcept {
VLOG(11) << "latest " << latestLoopCnt_ << " next " << nextLoopCnt_;
return (nextLoopCnt_ != latestLoopCnt_);
}
-/* static */
-void EventBase::runFunctionPtr(Cob* fn) {
- // The function should never throw an exception, because we have no
- // way of knowing what sort of error handling to perform.
- //
- // If it does throw, log a message and abort the program.
- try {
- (*fn)();
- } catch (const std::exception &ex) {
- LOG(ERROR) << "runInEventBaseThread() std::function threw a "
- << typeid(ex).name() << " exception: " << ex.what();
- abort();
- } catch (...) {
- LOG(ERROR) << "runInEventBaseThread() std::function threw an exception";
- abort();
- }
-
- // The function object was allocated by runInEventBaseThread().
- // Delete it once it has been run.
- delete fn;
-}
-
void EventBase::attachTimeoutManager(AsyncTimeout* obj,
InternalEnum internal) {
projects / folly.git / blobdiff