/*
- * Copyright 2017 Facebook, Inc.
+ * Copyright 2014-present Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
#pragma once
#include <atomic>
#include <boost/utility.hpp>
#include <glog/logging.h>
-#include <folly/CallOnce.h>
#include <folly/Executor.h>
#include <folly/Function.h>
#include <folly/Portability.h>
#include <folly/ScopeGuard.h>
+#include <folly/executors/DrivableExecutor.h>
#include <folly/experimental/ExecutionObserver.h>
-#include <folly/futures/DrivableExecutor.h>
#include <folly/io/async/AsyncTimeout.h>
#include <folly/io/async/HHWheelTimer.h>
#include <folly/io/async/Request.h>
#include <folly/io/async/TimeoutManager.h>
#include <folly/portability/Event.h>
-
+#include <folly/synchronization/CallOnce.h>
namespace folly {
virtual void onEventBaseDestruction(EventBase& evb) = 0;
virtual ~EventBaseLocalBaseBase() = default;
};
-}
+} // namespace detail
template <typename T>
class EventBaseLocal;
std::unique_ptr<RequestEventBase>(new RequestEventBase(eb)));
}
+ bool hasCallback() override {
+ return false;
+ }
+
private:
explicit RequestEventBase(EventBase* eb) : eb_(eb) {}
EventBase* eb_;
public DrivableExecutor {
public:
using Func = folly::Function<void()>;
- using FuncRef = folly::FunctionRef<void()>;
/**
* A callback interface to use with runInLoop()
virtual void runLoopCallback() noexcept = 0;
void cancelLoopCallback() {
+ context_.reset();
unlink();
}
Func function_;
};
+ /**
+ * Create a new EventBase object.
+ *
+ * Same as EventBase(true), which constructs an EventBase that measures time.
+ */
+ EventBase() : EventBase(true) {}
+
/**
* Create a new EventBase object.
*
* that relies on time-measurement, including:
* observer, max latency and avg loop time.
*/
- explicit EventBase(bool enableTimeMeasurement = true);
+ explicit EventBase(bool enableTimeMeasurement);
/**
* Create a new EventBase object that will use the specified libevent
* Like runInEventBaseThread, but the caller waits for the callback to be
* executed.
*/
- bool runInEventBaseThreadAndWait(FuncRef fn);
+ bool runInEventBaseThreadAndWait(Func fn);
/*
* Like runInEventBaseThreadAndWait, except if the caller is already in the
* Like runInEventBaseThreadAndWait, except if the caller is already in the
* event base thread, the functor is simply run inline.
*/
- bool runImmediatelyOrRunInEventBaseThreadAndWait(FuncRef fn);
+ bool runImmediatelyOrRunInEventBaseThreadAndWait(Func fn);
/**
* Set the maximum desired latency in us and provide a callback which will be
/// destroyed. loop() will return to its original behavior only when all
/// loop keep-alives are released.
KeepAlive getKeepAliveToken() override {
- if (inRunningEventBaseThread()) {
- loopKeepAliveCount_++;
- } else {
- loopKeepAliveCountAtomic_.fetch_add(1, std::memory_order_relaxed);
- }
+ keepAliveAcquire();
return makeKeepAlive();
}
folly::VirtualEventBase& getVirtualEventBase();
protected:
- void keepAliveRelease() override {
+ void keepAliveAcquire() override {
if (inRunningEventBaseThread()) {
- loopKeepAliveCount_--;
+ loopKeepAliveCount_++;
} else {
- add([=] { loopKeepAliveCount_--; });
+ loopKeepAliveCountAtomic_.fetch_add(1, std::memory_order_relaxed);
+ }
+ }
+
+ void keepAliveRelease() override {
+ if (!inRunningEventBaseThread()) {
+ return add([=] { keepAliveRelease(); });
}
+ loopKeepAliveCount_--;
}
private: