#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 {
}
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 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::runAfterDrain(Func cob) {
- auto callback = new FunctionLoopCallback(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();
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();
}
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