/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
+ * 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.
+ * You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
*/
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif
-#include "folly/io/async/EventBase.h"
+#include <folly/io/async/EventBase.h>
-#include "folly/io/async/NotificationQueue.h"
+#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;
-class Tr1FunctionLoopCallback : public EventBase::LoopCallback {
+class FunctionLoopCallback : public EventBase::LoopCallback {
public:
- explicit Tr1FunctionLoopCallback(const Cob& function)
- : function_(function) {}
+ explicit FunctionLoopCallback(EventBase::Func&& function)
+ : function_(std::move(function)) {}
- virtual void runLoopCallback() noexcept {
+ void runLoopCallback() noexcept override {
function_();
delete this;
}
private:
- Cob function_;
+ EventBase::Func function_;
};
-
}
namespace folly {
-const int kNoFD = -1;
-
/*
* EventBase::FunctionRunner
*/
class EventBase::FunctionRunner
- : public NotificationQueue<std::pair<void (*)(void*), void*>>::Consumer {
+ : public NotificationQueue<EventBase::Func>::Consumer {
public:
- void messageAvailable(std::pair<void (*)(void*), void*>&& msg) {
-
+ 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.
// stop_ flag as well as runInLoop callbacks, etc.
event_base_loopbreak(getEventBase()->evb_);
- if (msg.first == nullptr && msg.second == nullptr) {
+ if (!msg) {
// terminateLoopSoon() sends a null message just to
// wake up the loop. We can ignore these messages.
return;
}
- // If function is nullptr, just log and move on
- if (!msg.first) {
- LOG(ERROR) << "nullptr callback registered to be run in "
- << "event base thread";
- return;
- }
-
// 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 {
- msg.first(msg.second);
+ msg();
} catch (const std::exception& ex) {
LOG(ERROR) << "runInEventBaseThread() function threw a "
<< typeid(ex).name() << " exception: " << ex.what();
delete this;
}
+
+// The interface used to libevent is not thread-safe. Calls to
+// event_init() and event_base_free() directly modify an internal
+// global 'current_base', so a mutex is required to protect this.
+//
+// event_init() should only ever be called once. Subsequent calls
+// should be made to event_base_new(). We can recognise that
+// event_init() has already been called by simply inspecting current_base.
+static std::mutex libevent_mutex_;
+
/*
* EventBase methods
*/
-EventBase::EventBase()
+EventBase::EventBase(bool enableTimeMeasurement)
: runOnceCallbacks_(nullptr)
, stop_(false)
- , loopThread_(0)
- , evb_(static_cast<event_base*>(event_init()))
+ , loopThread_()
, queue_(nullptr)
, fnRunner_(nullptr)
, maxLatency_(0)
, avgLoopTime_(2000000)
, maxLatencyLoopTime_(avgLoopTime_)
+ , enableTimeMeasurement_(enableTimeMeasurement)
, nextLoopCnt_(-40) // Early wrap-around so bugs will manifest soon
, latestLoopCnt_(nextLoopCnt_)
, startWork_(0)
, observer_(nullptr)
- , observerSampleCount_(0) {
+ , observerSampleCount_(0)
+ , executionObserver_(nullptr) {
+ struct event ev;
+ {
+ std::lock_guard<std::mutex> lock(libevent_mutex_);
+
+ // The value 'current_base' (libevent 1) or
+ // 'event_global_current_base_' (libevent 2) is filled in by event_set(),
+ // 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().
+ event_set(&ev, 0, 0, nullptr, nullptr);
+ 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()");
+ }
VLOG(5) << "EventBase(): Created.";
initNotificationQueue();
- RequestContext::getStaticContext();
+ RequestContext::saveContext();
}
// takes ownership of the event_base
-EventBase::EventBase(event_base* evb)
+EventBase::EventBase(event_base* evb, bool enableTimeMeasurement)
: runOnceCallbacks_(nullptr)
, stop_(false)
- , loopThread_(0)
+ , loopThread_()
, evb_(evb)
, queue_(nullptr)
, fnRunner_(nullptr)
, maxLatency_(0)
, avgLoopTime_(2000000)
, maxLatencyLoopTime_(avgLoopTime_)
+ , enableTimeMeasurement_(enableTimeMeasurement)
, nextLoopCnt_(-40) // Early wrap-around so bugs will manifest soon
, latestLoopCnt_(nextLoopCnt_)
, startWork_(0)
, observer_(nullptr)
- , observerSampleCount_(0) {
+ , observerSampleCount_(0)
+ , executionObserver_(nullptr) {
+ if (UNLIKELY(evb_ == nullptr)) {
+ LOG(ERROR) << "EventBase(): Pass nullptr as event base.";
+ throw std::invalid_argument("EventBase(): event base cannot be nullptr");
+ }
initNotificationQueue();
- RequestContext::getStaticContext();
+ RequestContext::saveContext();
}
EventBase::~EventBase() {
- // Delete any unfired CobTimeout objects, so that we don't leak memory
+ // 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();
+ onDestructionCallbacks_.pop_front();
+ callback->runLoopCallback();
+ }
+
+ // Delete any unfired callback objects, so that we don't leak memory
// (Note that we don't fire them. The caller is responsible for cleaning up
// its own data structures if it destroys the EventBase with unfired events
// remaining.)
delete timeout;
}
- (void) runLoopCallbacks(false);
+ while (!runBeforeLoopCallbacks_.empty()) {
+ delete &runBeforeLoopCallbacks_.front();
+ }
+
+ (void)runLoopCallbacks();
+
+ if (!fnRunner_->consumeUntilDrained()) {
+ LOG(ERROR) << "~EventBase(): Unable to drain notification queue";
+ }
// Stop consumer before deleting NotificationQueue
fnRunner_->stopConsuming();
- event_base_free(evb_);
+ {
+ std::lock_guard<std::mutex> lock(libevent_mutex_);
+ event_base_free(evb_);
+ }
+
+ {
+ std::lock_guard<std::mutex> lock(localStorageMutex_);
+ for (auto storage : localStorageToDtor_) {
+ storage->onEventBaseDestruction(*this);
+ }
+ }
VLOG(5) << "EventBase(): Destroyed.";
}
return queue_->size();
}
+void EventBase::setMaxReadAtOnce(uint32_t maxAtOnce) {
+ fnRunner_->setMaxReadAtOnce(maxAtOnce);
+}
+
// Set smoothing coefficient for loop load average; input is # of milliseconds
// for exp(-1) decay.
void EventBase::setLoadAvgMsec(uint32_t ms) {
+ assert(enableTimeMeasurement_);
uint64_t us = 1000 * ms;
if (ms > 0) {
maxLatencyLoopTime_.setTimeInterval(us);
}
void EventBase::resetLoadAvg(double value) {
+ assert(enableTimeMeasurement_);
avgLoopTime_.reset(value);
maxLatencyLoopTime_.reset(value);
}
-static int64_t getTimeDelta(int64_t *prev) {
- int64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
- std::chrono::steady_clock::now().time_since_epoch()).count();
- int64_t delta = now - *prev;
- *prev = now;
- return delta;
+static std::chrono::milliseconds
+getTimeDelta(std::chrono::steady_clock::time_point* prev) {
+ auto result = std::chrono::steady_clock::now() - *prev;
+ *prev = std::chrono::steady_clock::now();
+
+ return std::chrono::duration_cast<std::chrono::milliseconds>(result);
}
void EventBase::waitUntilRunning() {
// enters the event_base loop -- will only exit when forced to
bool EventBase::loop() {
+ return loopBody();
+}
+
+bool EventBase::loopOnce(int flags) {
+ return loopBody(flags | EVLOOP_ONCE);
+}
+
+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;
- int nonBlocking;
+ bool blocking = !(flags & EVLOOP_NONBLOCK);
+ bool once = (flags & EVLOOP_ONCE);
+
+ // time-measurement variables.
+ std::chrono::steady_clock::time_point prev;
+ int64_t idleStart = 0;
+ int64_t busy;
+ int64_t idle;
loopThread_.store(pthread_self(), std::memory_order_release);
-#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 12)
if (!name_.empty()) {
- pthread_setname_np(pthread_self(), name_.c_str());
+ setThreadName(name_);
}
-#endif
- int64_t prev = std::chrono::duration_cast<std::chrono::milliseconds>(
- std::chrono::steady_clock::now().time_since_epoch()).count();
- int64_t idleStart = std::chrono::duration_cast<std::chrono::microseconds>(
- std::chrono::steady_clock::now().time_since_epoch()).count();
+ if (enableTimeMeasurement_) {
+ prev = std::chrono::steady_clock::now();
+ idleStart = std::chrono::duration_cast<std::chrono::microseconds>(
+ std::chrono::steady_clock::now().time_since_epoch()).count();
+ }
- // TODO: Read stop_ atomically with an acquire barrier.
- while (!stop_) {
+ while (!stop_.load(std::memory_order_acquire)) {
+ applyLoopKeepAlive();
++nextLoopCnt_;
+ // Run the before loop callbacks
+ LoopCallbackList callbacks;
+ callbacks.swap(runBeforeLoopCallbacks_);
+
+ while(!callbacks.empty()) {
+ auto* item = &callbacks.front();
+ callbacks.pop_front();
+ item->runLoopCallback();
+ }
+
// nobody can add loop callbacks from within this thread if
// we don't have to handle anything to start with...
- nonBlocking = (loopCallbacks_.empty() ? 0 : EVLOOP_NONBLOCK);
- res = event_base_loop(evb_, EVLOOP_ONCE | nonBlocking);
+ if (blocking && loopCallbacks_.empty()) {
+ res = event_base_loop(evb_, EVLOOP_ONCE);
+ } else {
+ res = event_base_loop(evb_, EVLOOP_ONCE | EVLOOP_NONBLOCK);
+ }
+
ranLoopCallbacks = runLoopCallbacks();
- int64_t busy = std::chrono::duration_cast<std::chrono::microseconds>(
- std::chrono::steady_clock::now().time_since_epoch()).count() - startWork_;
- int64_t idle = startWork_ - idleStart;
+ if (enableTimeMeasurement_) {
+ busy = std::chrono::duration_cast<std::chrono::microseconds>(
+ std::chrono::steady_clock::now().time_since_epoch()).count() -
+ startWork_;
+ idle = startWork_ - idleStart;
- avgLoopTime_.addSample(idle, busy);
- maxLatencyLoopTime_.addSample(idle, busy);
+ avgLoopTime_.addSample(idle, busy);
+ maxLatencyLoopTime_.addSample(idle, busy);
- if (observer_) {
- if (observerSampleCount_++ == observer_->getSampleRate()) {
- observerSampleCount_ = 0;
- observer_->loopSample(busy, idle);
+ if (observer_) {
+ if (observerSampleCount_++ == observer_->getSampleRate()) {
+ observerSampleCount_ = 0;
+ observer_->loopSample(busy, idle);
+ }
}
- }
- VLOG(11) << "EventBase " << this << " did not timeout "
- " loop time guess: " << busy + idle <<
- " idle time: " << idle <<
- " busy time: " << busy <<
- " avgLoopTime: " << avgLoopTime_.get() <<
- " maxLatencyLoopTime: " << maxLatencyLoopTime_.get() <<
- " maxLatency_: " << maxLatency_ <<
- " nothingHandledYet(): "<< nothingHandledYet();
-
- // see if our average loop time has exceeded our limit
- if ((maxLatency_ > 0) &&
- (maxLatencyLoopTime_.get() > double(maxLatency_))) {
- maxLatencyCob_();
- // back off temporarily -- don't keep spamming maxLatencyCob_
- // if we're only a bit over the limit
- maxLatencyLoopTime_.dampen(0.9);
- }
+ VLOG(11) << "EventBase " << this << " did not timeout "
+ " loop time guess: " << busy + idle <<
+ " idle time: " << idle <<
+ " busy time: " << busy <<
+ " avgLoopTime: " << avgLoopTime_.get() <<
+ " maxLatencyLoopTime: " << maxLatencyLoopTime_.get() <<
+ " maxLatency_: " << maxLatency_ <<
+ " notificationQueueSize: " << getNotificationQueueSize() <<
+ " nothingHandledYet(): "<< nothingHandledYet();
+
+ // see if our average loop time has exceeded our limit
+ if ((maxLatency_ > 0) &&
+ (maxLatencyLoopTime_.get() > double(maxLatency_))) {
+ maxLatencyCob_();
+ // back off temporarily -- don't keep spamming maxLatencyCob_
+ // if we're only a bit over the limit
+ maxLatencyLoopTime_.dampen(0.9);
+ }
- // Our loop run did real work; reset the idle timer
- idleStart = std::chrono::duration_cast<std::chrono::microseconds>(
- std::chrono::steady_clock::now().time_since_epoch()).count();
+ // Our loop run did real work; reset the idle timer
+ 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";
+ }
// If the event loop indicate that there were no more events, and
// we also didn't have any loop callbacks to run, there is nothing left to
}
}
- VLOG(5) << "EventBase " << this << " loop time: " << getTimeDelta(&prev);
+ if (enableTimeMeasurement_) {
+ VLOG(5) << "EventBase " << this << " loop time: " <<
+ getTimeDelta(&prev).count();
+ }
+
+ if (once) {
+ break;
+ }
}
// Reset stop_ so loop() can be called again
stop_ = false;
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_;
// set the time
startWork_ = std::chrono::duration_cast<std::chrono::microseconds>(
- std::chrono::steady_clock::now().time_since_epoch()).count();
+ 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() {
VLOG(5) << "EventBase(): Received terminateLoopSoon() command.";
- if (!isRunning()) {
- return;
- }
-
// Set stop to true, so the event loop will know to exit.
// TODO: We should really use an atomic operation here with a release
// barrier.
// this likely means the EventBase already has lots of events waiting
// anyway.
try {
- queue_->putMessage(std::make_pair(nullptr, nullptr));
+ queue_->putMessage(nullptr);
} catch (...) {
// We don't care if putMessage() fails. This likely means
// the EventBase already has lots of events waiting anyway.
}
}
-void EventBase::runInLoop(const Cob& cob, bool thisIteration) {
+void EventBase::runInLoop(Func cob, bool thisIteration) {
DCHECK(isInEventBaseThread());
- Tr1FunctionLoopCallback* wrapper = new Tr1FunctionLoopCallback(cob);
+ auto wrapper = new FunctionLoopCallback(std::move(cob));
wrapper->context_ = RequestContext::saveContext();
if (runOnceCallbacks_ != nullptr && thisIteration) {
runOnceCallbacks_->push_back(*wrapper);
}
}
-bool EventBase::runInEventBaseThread(void (*fn)(void*), void* arg) {
+void EventBase::runOnDestruction(LoopCallback* callback) {
+ std::lock_guard<std::mutex> lg(onDestructionCallbacksMutex_);
+ callback->cancelLoopCallback();
+ onDestructionCallbacks_.push_back(*callback);
+}
+
+void EventBase::runBeforeLoop(LoopCallback* callback) {
+ DCHECK(isInEventBaseThread());
+ callback->cancelLoopCallback();
+ runBeforeLoopCallbacks_.push_back(*callback);
+}
+
+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(new RunInLoopCallback(fn, arg));
+ runInLoop(std::move(fn));
return true;
}
try {
- queue_->putMessage(std::make_pair(fn, arg));
+ queue_->putMessage(std::move(fn));
} catch (const std::exception& ex) {
LOG(ERROR) << "EventBase " << this << ": failed to schedule function "
- << fn << "for EventBase thread: " << ex.what();
+ << "for EventBase thread: " << ex.what();
return false;
}
return true;
}
-bool EventBase::runInEventBaseThread(const Cob& fn) {
- // Short-circuit if we are already in our event base
+bool EventBase::runInEventBaseThreadAndWait(Func fn) {
if (inRunningEventBaseThread()) {
- runInLoop(fn);
- return true;
- }
-
- Cob* fnCopy;
- // Allocate a copy of the function so we can pass it to the other thread
- // The other thread will delete this copy once the function has been run
- try {
- fnCopy = new Cob(fn);
- } catch (const std::bad_alloc& ex) {
- LOG(ERROR) << "failed to allocate tr::function copy "
- << "for runInEventBaseThread()";
+ LOG(ERROR) << "EventBase " << this << ": Waiting in the event loop is not "
+ << "allowed";
return false;
}
- if (!runInEventBaseThread(&EventBase::runTr1FunctionPtr, fnCopy)) {
- delete fnCopy;
- return false;
- }
+ bool ready = false;
+ std::mutex m;
+ std::condition_variable cv;
+ runInEventBaseThread([&] {
+ SCOPE_EXIT {
+ std::unique_lock<std::mutex> l(m);
+ ready = true;
+ cv.notify_one();
+ // We cannot release the lock before notify_one, because a spurious
+ // wakeup in the waiting thread may lead to cv and m going out of scope
+ // prematurely.
+ };
+ fn();
+ });
+ std::unique_lock<std::mutex> l(m);
+ cv.wait(l, [&] { return ready; });
return true;
}
-bool EventBase::runAfterDelay(const Cob& cob,
- int milliseconds,
- TimeoutManager::InternalEnum in) {
- CobTimeout* timeout = new CobTimeout(this, cob, in);
+bool EventBase::runImmediatelyOrRunInEventBaseThreadAndWait(Func fn) {
+ if (isInEventBaseThread()) {
+ fn();
+ return true;
+ } else {
+ return runInEventBaseThreadAndWait(std::move(fn));
+ }
+}
+
+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(
+ 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;
}
-
pendingCobTimeouts_.push_back(*timeout);
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<std::pair<void (*)(void*), void*>>());
+ 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
LEFT = 2, // busy sample placed at the beginning of the iteration
};
+ // See http://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+ // and D676020 for more info on this calculation.
VLOG(11) << "idle " << idle << " oldBusyLeftover_ " << oldBusyLeftover_ <<
" idle + oldBusyLeftover_ " << idle + oldBusyLeftover_ <<
" busy " << busy << " " << __PRETTY_FUNCTION__;
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::runTr1FunctionPtr(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;
-}
-
-EventBase::RunInLoopCallback::RunInLoopCallback(void (*fn)(void*), void* arg)
- : fn_(fn)
- , arg_(arg) {}
-
-void EventBase::RunInLoopCallback::runLoopCallback() noexcept {
- fn_(arg_);
- delete this;
-}
-
void EventBase::attachTimeoutManager(AsyncTimeout* obj,
InternalEnum internal) {
event_base_set(getLibeventBase(), ev);
if (internal == AsyncTimeout::InternalEnum::INTERNAL) {
// Set the EVLIST_INTERNAL flag
- ev->ev_flags |= EVLIST_INTERNAL;
+ event_ref_flags(ev) |= EVLIST_INTERNAL;
}
}
}
bool EventBase::scheduleTimeout(AsyncTimeout* obj,
- std::chrono::milliseconds timeout) {
+ TimeoutManager::timeout_type timeout) {
assert(isInEventBaseThread());
// Set up the timeval and add the event
struct timeval tv;
void EventBase::setName(const std::string& name) {
assert(isInEventBaseThread());
name_ = name;
-#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 12)
+
if (isRunning()) {
- pthread_setname_np(loopThread_.load(std::memory_order_relaxed),
- name_.c_str());
+ setThreadName(loopThread_.load(std::memory_order_relaxed),
+ name_);
}
-#endif
}
const std::string& EventBase::getName() {
return name_;
}
+const char* EventBase::getLibeventVersion() { return event_get_version(); }
+const char* EventBase::getLibeventMethod() { return event_get_method(); }
+
} // folly