proxygen: folly::FunctionScheduler Class Reference

#include <FunctionScheduler.h>

Classes
struct	LatencyDistribution

struct	RepeatFunc

struct	RunTimeOrder

Public Types
using	IntervalDistributionFunc = Function< std::chrono::milliseconds()>

using	NextRunTimeFunc = Function< std::chrono::steady_clock::time_point(std::chrono::steady_clock::time_point, std::chrono::steady_clock::time_point)>

Public Member Functions
	FunctionScheduler ()

	~FunctionScheduler ()

void	setSteady (bool steady)

void	addFunction (Function< void()> &&cb, std::chrono::milliseconds interval, StringPiece nameID=StringPiece(), std::chrono::milliseconds startDelay=std::chrono::milliseconds(0))

void	addFunction (Function< void()> &&cb, std::chrono::milliseconds interval, const LatencyDistribution &latencyDistr, StringPiece nameID=StringPiece(), std::chrono::milliseconds startDelay=std::chrono::milliseconds(0))

void	addFunctionOnce (Function< void()> &&cb, StringPiece nameID=StringPiece(), std::chrono::milliseconds startDelay=std::chrono::milliseconds(0))

void	addFunctionUniformDistribution (Function< void()> &&cb, std::chrono::milliseconds minInterval, std::chrono::milliseconds maxInterval, StringPiece nameID, std::chrono::milliseconds startDelay)

void	addFunctionConsistentDelay (Function< void()> &&cb, std::chrono::milliseconds interval, StringPiece nameID=StringPiece(), std::chrono::milliseconds startDelay=std::chrono::milliseconds(0))

void	addFunctionGenericDistribution (Function< void()> &&cb, IntervalDistributionFunc &&intervalFunc, const std::string &nameID, const std::string &intervalDescr, std::chrono::milliseconds startDelay)

void	addFunctionGenericNextRunTimeFunctor (Function< void()> &&cb, NextRunTimeFunc &&fn, const std::string &nameID, const std::string &intervalDescr, std::chrono::milliseconds startDelay)

bool	cancelFunction (StringPiece nameID)

bool	cancelFunctionAndWait (StringPiece nameID)

void	cancelAllFunctions ()

void	cancelAllFunctionsAndWait ()

bool	resetFunctionTimer (StringPiece nameID)

bool	start ()

bool	shutdown ()

void	setThreadName (StringPiece threadName)

template<typename RepeatFuncNextRunTimeFunc >
void	addFunctionToHeapChecked (Function< void()> &&cb, RepeatFuncNextRunTimeFunc &&fn, const std::string &nameID, const std::string &intervalDescr, milliseconds startDelay, bool runOnce)

Private Types
typedef std::vector< std::unique_ptr< RepeatFunc > >	FunctionHeap

typedef std::unordered_map< StringPiece, RepeatFunc *, Hash >	FunctionMap

Private Member Functions
void	run ()

void	runOneFunction (std::unique_lock< std::mutex > &lock, std::chrono::steady_clock::time_point now)

void	cancelFunction (const std::unique_lock< std::mutex > &lock, RepeatFunc *it)

void	addFunctionToHeap (const std::unique_lock< std::mutex > &lock, std::unique_ptr< RepeatFunc > func)

template<typename RepeatFuncNextRunTimeFunc >
void	addFunctionToHeapChecked (Function< void()> &&cb, RepeatFuncNextRunTimeFunc &&fn, const std::string &nameID, const std::string &intervalDescr, std::chrono::milliseconds startDelay, bool runOnce)

void	addFunctionInternal (Function< void()> &&cb, NextRunTimeFunc &&fn, const std::string &nameID, const std::string &intervalDescr, std::chrono::milliseconds startDelay, bool runOnce)

void	addFunctionInternal (Function< void()> &&cb, IntervalDistributionFunc &&fn, const std::string &nameID, const std::string &intervalDescr, std::chrono::milliseconds startDelay, bool runOnce)

bool	cancelAllFunctionsWithLock (std::unique_lock< std::mutex > &lock)

bool	cancelFunctionWithLock (std::unique_lock< std::mutex > &lock, StringPiece nameID)

Private Attributes
std::thread	thread_

std::mutex	mutex_

bool	running_ {false}

FunctionHeap	functions_

FunctionMap	functionsMap_

RunTimeOrder	fnCmp_

RepeatFunc *	currentFunction_ {nullptr}

std::condition_variable	runningCondvar_

std::string	threadName_

bool	steady_ {false}

bool	cancellingCurrentFunction_ {false}

Detailed Description

Schedules any number of functions to run at various intervals. E.g.,

FunctionScheduler fs;

fs.addFunction([&] { LOG(INFO) << "tick..."; }, seconds(1), "ticker"); fs.addFunction(std::bind(&TestClass::doStuff, this), minutes(5), "stuff"); fs.start(); ........ fs.cancelFunction("ticker"); fs.addFunction([&] { LOG(INFO) << "tock..."; }, minutes(3), "tocker"); ........ fs.shutdown();

Note: the class uses only one thread - if you want to use more than one thread, either use multiple FunctionScheduler objects, or check out ThreadedRepeatingFunctionRunner.h for a much simpler contract of "run each function periodically in its own thread".

start() schedules the functions, while shutdown() terminates further scheduling.

Definition at line 54 of file FunctionScheduler.h.

Member Typedef Documentation

typedef std::vector<std::unique_ptr<RepeatFunc> > folly::FunctionScheduler::FunctionHeap

private

Definition at line 314 of file FunctionScheduler.h.

typedef std::unordered_map<StringPiece, RepeatFunc*, Hash> folly::FunctionScheduler::FunctionMap

private

Definition at line 315 of file FunctionScheduler.h.

using folly::FunctionScheduler::IntervalDistributionFunc = Function<std::chrono::milliseconds()>

A type alias for function that is called to determine the time interval for the next scheduled run.

Definition at line 154 of file FunctionScheduler.h.

using folly::FunctionScheduler::NextRunTimeFunc = Function<std::chrono::steady_clock::time_point( std::chrono::steady_clock::time_point, std::chrono::steady_clock::time_point)>

A type alias for function that returns the next run time, given the current run time and the current start time.

Definition at line 161 of file FunctionScheduler.h.

Constructor & Destructor Documentation

folly::FunctionScheduler::FunctionScheduler ( )

Definition at line 114 of file FunctionScheduler.cpp.

114 {}

folly::FunctionScheduler::~FunctionScheduler ( )

Definition at line 116 of file FunctionScheduler.cpp.

References addFunction(), folly::FunctionScheduler::LatencyDistribution::isPoisson, folly::gen::move, folly::FunctionScheduler::LatencyDistribution::poissonMean, folly::shutdown(), and folly::Range< Iter >::str().

                                       {
   // make sure to stop the thread (if running)
   shutdown();
 }

Member Function Documentation

void folly::FunctionScheduler::addFunction	(	Function< void()> &&	cb,
		std::chrono::milliseconds	interval,
		StringPiece	nameID = `StringPiece()`,
		std::chrono::milliseconds	startDelay = `std::chrono::milliseconds(0)`
	)

Adds a new function to the FunctionScheduler.

Functions will not be run until start() is called. When start() is called, each function will be run after its specified startDelay. Functions may also be added after start() has been called, in which case startDelay is still honored.

Throws an exception on error. In particular, each function must have a unique name–two functions cannot be added with the same name.

Referenced by folly::FunctionScheduler::LatencyDistribution::LatencyDistribution(), TEST(), and ~FunctionScheduler().

void folly::FunctionScheduler::addFunction	(	Function< void()> &&	cb,
		std::chrono::milliseconds	interval,
		const LatencyDistribution &	latencyDistr,
		StringPiece	nameID = `StringPiece()`,
		std::chrono::milliseconds	startDelay = `std::chrono::milliseconds(0)`
	)

void folly::FunctionScheduler::addFunctionConsistentDelay	(	Function< void()> &&	cb,
		std::chrono::milliseconds	interval,
		StringPiece	nameID = `StringPiece()`,
		std::chrono::milliseconds	startDelay = `std::chrono::milliseconds(0)`
	)

Add a new function to the FunctionScheduler whose start times are attempted to be scheduled so that they are congruent modulo the interval. Note: The scheduling of the next run time happens right before the function invocation, so the first time a function takes more time than the interval, it will be reinvoked immediately.

Definition at line 183 of file FunctionScheduler.cpp.

References folly::gen::move, and folly::Range< Iter >::str().

Referenced by folly::FunctionScheduler::LatencyDistribution::LatencyDistribution(), and TEST().

                              {
   addFunctionInternal(
       std::move(cb),
       ConsistentDelayFunctor(interval),
       nameID.str(),
       to<std::string>(interval.count(), "ms"),
       startDelay,
       false /*runOnce*/);
 }

void folly::FunctionScheduler::addFunctionGenericDistribution	(	Function< void()> &&	cb,
		IntervalDistributionFunc &&	intervalFunc,
		const std::string &	nameID,
		const std::string &	intervalDescr,
		std::chrono::milliseconds	startDelay
	)

Add a new function to the FunctionScheduler. The scheduling interval is determined by the interval distribution functor, which is called every time the next function execution is scheduled. This allows for supporting custom interval distribution algorithms in addition to built in constant interval; and Poisson and jitter distributions (

See also: FunctionScheduler::addFunction and; FunctionScheduler::addFunctionJitterInterval).

Definition at line 197 of file FunctionScheduler.cpp.

References folly::gen::move.

Referenced by TEST().

                              {
   addFunctionInternal(
       std::move(cb),
       std::move(intervalFunc),
       nameID,
       intervalDescr,
       startDelay,
       false /*runOnce*/);
 }

void folly::FunctionScheduler::addFunctionGenericNextRunTimeFunctor	(	Function< void()> &&	cb,
		NextRunTimeFunc &&	fn,
		const std::string &	nameID,
		const std::string &	intervalDescr,
		std::chrono::milliseconds	startDelay
	)

Like addFunctionGenericDistribution, adds a new function to the FunctionScheduler, but the next run time is determined directly by the given functor, rather than by adding an interval.

Definition at line 212 of file FunctionScheduler.cpp.

References folly::gen::move.

                              {
   addFunctionInternal(
       std::move(cb),
       std::move(fn),
       nameID,
       intervalDescr,
       startDelay,
       false /*runOnce*/);
 }

void folly::FunctionScheduler::addFunctionInternal	(	Function< void()> &&	cb,
		NextRunTimeFunc &&	fn,
		const std::string &	nameID,
		const std::string &	intervalDescr,
		std::chrono::milliseconds	startDelay,
		bool	runOnce
	)

private

Referenced by addFunctionToHeapChecked().

void folly::FunctionScheduler::addFunctionInternal	(	Function< void()> &&	cb,
		IntervalDistributionFunc &&	fn,
		const std::string &	nameID,
		const std::string &	intervalDescr,
		std::chrono::milliseconds	startDelay,
		bool	runOnce
	)

private

void folly::FunctionScheduler::addFunctionOnce	(	Function< void()> &&	cb,
		StringPiece	nameID = `StringPiece()`,
		std::chrono::milliseconds	startDelay = `std::chrono::milliseconds(0)`
	)

Adds a new function to the FunctionScheduler to run only once.

Definition at line 154 of file FunctionScheduler.cpp.

References folly::gen::move, and folly::Range< Iter >::str().

Referenced by folly::FunctionScheduler::LatencyDistribution::LatencyDistribution(), and TEST().

                              {
   addFunctionInternal(
       std::move(cb),
       ConstIntervalFunctor(milliseconds::zero()),
       nameID.str(),
       "once",
       startDelay,
       true /*runOnce*/);
 }

void folly::FunctionScheduler::addFunctionToHeap	(	const std::unique_lock< std::mutex > &	lock,
		std::unique_ptr< RepeatFunc >	func
	)

private

Definition at line 551 of file FunctionScheduler.cpp.

References folly::gen::move, mutex_, and now().

                                     {
   // This function should only be called with mutex_ already locked.
   DCHECK(lock.mutex() == &mutex_);
   DCHECK(lock.owns_lock());
 
   functions_.push_back(std::move(func));
   functionsMap_[functions_.back()->name] = functions_.back().get();
   if (running_) {
     functions_.back()->resetNextRunTime(steady_clock::now());
     std::push_heap(functions_.begin(), functions_.end(), fnCmp_);
     // Signal the running thread to wake up and see if it needs to change
     // its current scheduling decision.
     runningCondvar_.notify_one();
   }
 }

template<typename RepeatFuncNextRunTimeFunc >

void folly::FunctionScheduler::addFunctionToHeapChecked	(	Function< void()> &&	cb,
		RepeatFuncNextRunTimeFunc &&	fn,
		const std::string &	nameID,
		const std::string &	intervalDescr,
		milliseconds	startDelay,
		bool	runOnce
	)

Definition at line 228 of file FunctionScheduler.cpp.

References addFunctionInternal(), folly::gen::move, mutex_, and string.

                   {
   if (!cb) {
     throw std::invalid_argument(
         "FunctionScheduler: Scheduled function must be set");
   }
   if (!fn) {
     throw std::invalid_argument(
         "FunctionScheduler: "
         "interval distribution or next run time function must be set");
   }
   if (startDelay < milliseconds::zero()) {
     throw std::invalid_argument(
         "FunctionScheduler: start delay must be non-negative");
   }
 
   std::unique_lock<std::mutex> l(mutex_);
   auto it = functionsMap_.find(nameID);
   // check if the nameID is unique
   if (it != functionsMap_.end() && it->second->isValid()) {
     throw std::invalid_argument(to<std::string>(
         "FunctionScheduler: a function named \"", nameID, "\" already exists"));
   }
 
   if (currentFunction_ && currentFunction_->name == nameID) {
     throw std::invalid_argument(to<std::string>(
         "FunctionScheduler: a function named \"", nameID, "\" already exists"));
   }
 
   addFunctionToHeap(
       l,
       std::make_unique<RepeatFunc>(
           std::move(cb),
           std::forward<RepeatFuncNextRunTimeFunc>(fn),
           nameID,
           intervalDescr,
           startDelay,
           runOnce));
 }

template<typename RepeatFuncNextRunTimeFunc >

void folly::FunctionScheduler::addFunctionToHeapChecked	(	Function< void()> &&	cb,
		RepeatFuncNextRunTimeFunc &&	fn,
		const std::string &	nameID,
		const std::string &	intervalDescr,
		std::chrono::milliseconds	startDelay,
		bool	runOnce
	)

private

void folly::FunctionScheduler::addFunctionUniformDistribution	(	Function< void()> &&	cb,
		std::chrono::milliseconds	minInterval,
		std::chrono::milliseconds	maxInterval,
		StringPiece	nameID,
		std::chrono::milliseconds	startDelay
	)

Add a new function to the FunctionScheduler with the time interval being distributed uniformly within the given interval [minInterval, maxInterval].

Definition at line 167 of file FunctionScheduler.cpp.

References folly::gen::move, and folly::Range< Iter >::str().

Referenced by folly::FunctionScheduler::LatencyDistribution::LatencyDistribution(), and TEST().

                              {
   addFunctionInternal(
       std::move(cb),
       UniformDistributionFunctor(minInterval, maxInterval),
       nameID.str(),
       to<std::string>(
           "[", minInterval.count(), " , ", maxInterval.count(), "] ms"),
       startDelay,
       false /*runOnce*/);
 }

void folly::FunctionScheduler::cancelAllFunctions ( )

All functions registered will be canceled.

Definition at line 362 of file FunctionScheduler.cpp.

References mutex_.

                                            {
   std::unique_lock<std::mutex> l(mutex_);
   cancelAllFunctionsWithLock(l);
 }

void folly::FunctionScheduler::cancelAllFunctionsAndWait ( )

Definition at line 367 of file FunctionScheduler.cpp.

References mutex_.

Referenced by TEST().

                                                   {
   std::unique_lock<std::mutex> l(mutex_);
   if (cancelAllFunctionsWithLock(l)) {
     runningCondvar_.wait(l, [this]() { return !cancellingCurrentFunction_; });
   }
 }

bool folly::FunctionScheduler::cancelAllFunctionsWithLock ( std::unique_lock< std::mutex > & lock )

private

Definition at line 350 of file FunctionScheduler.cpp.

                                     {
   CHECK_EQ(lock.owns_lock(), true);
   functions_.clear();
   functionsMap_.clear();
   if (currentFunction_) {
     cancellingCurrentFunction_ = true;
   }
   currentFunction_ = nullptr;
   return cancellingCurrentFunction_;
 }

bool folly::FunctionScheduler::cancelFunction ( StringPiece nameID )

Cancels the function with the specified name, so it will no longer be run.

Returns false if no function exists with the specified name.

Definition at line 310 of file FunctionScheduler.cpp.

References mutex_.

Referenced by TEST().

                                                          {
   std::unique_lock<std::mutex> l(mutex_);
   if (cancelFunctionWithLock(l, nameID)) {
     return true;
   }
   auto it = functionsMap_.find(nameID);
   if (it != functionsMap_.end() && it->second->isValid()) {
     cancelFunction(l, it->second);
     return true;
   }
 
   return false;
 }

void folly::FunctionScheduler::cancelFunction	(	const std::unique_lock< std::mutex > &	lock,
		RepeatFunc *	it
	)

private

Definition at line 340 of file FunctionScheduler.cpp.

References folly::FunctionScheduler::RepeatFunc::cancel(), mutex_, and folly::FunctionScheduler::RepeatFunc::name.

                     {
   // This function should only be called with mutex_ already locked.
   DCHECK(l.mutex() == &mutex_);
   DCHECK(l.owns_lock());
   functionsMap_.erase(it->name);
   it->cancel();
 }

bool folly::FunctionScheduler::cancelFunctionAndWait ( StringPiece nameID )

Definition at line 324 of file FunctionScheduler.cpp.

References mutex_.

Referenced by TEST().

                                                                 {
   std::unique_lock<std::mutex> l(mutex_);
 
   if (cancelFunctionWithLock(l, nameID)) {
     runningCondvar_.wait(l, [this]() { return !cancellingCurrentFunction_; });
     return true;
   }
 
   auto it = functionsMap_.find(nameID);
   if (it != functionsMap_.end() && it->second->isValid()) {
     cancelFunction(l, it->second);
     return true;
   }
   return false;
 }

bool folly::FunctionScheduler::cancelFunctionWithLock	(	std::unique_lock< std::mutex > &	lock,
		StringPiece	nameID
	)

private

Definition at line 295 of file FunctionScheduler.cpp.

                         {
   CHECK_EQ(lock.owns_lock(), true);
   if (currentFunction_ && currentFunction_->name == nameID) {
     functionsMap_.erase(currentFunction_->name);
     // This function is currently being run. Clear currentFunction_
     // The running thread will see this and won't reschedule the function.
     currentFunction_ = nullptr;
     cancellingCurrentFunction_ = true;
     return true;
   }
   return false;
 }

bool folly::FunctionScheduler::resetFunctionTimer ( StringPiece nameID )

Resets the specified function's timer. When resetFunctionTimer is called, the specified function's timer will be reset with the same parameters it was passed initially, including its startDelay. If the startDelay was 0, the function will be invoked immediately.

Returns false if no function exists with the specified name.

Definition at line 374 of file FunctionScheduler.cpp.

References mutex_, and now().

Referenced by TEST().

                                                              {
   std::unique_lock<std::mutex> l(mutex_);
   if (currentFunction_ && currentFunction_->name == nameID) {
     if (cancellingCurrentFunction_ || currentFunction_->runOnce) {
       return false;
     }
     currentFunction_->resetNextRunTime(steady_clock::now());
     return true;
   }
 
   // Since __adjust_heap() isn't a part of the standard API, there's no way to
   // fix the heap ordering if we adjust the key (nextRunTime) for the existing
   // RepeatFunc. Instead, we just cancel it and add an identical object.
   auto it = functionsMap_.find(nameID);
   if (it != functionsMap_.end() && it->second->isValid()) {
     if (running_) {
       it->second->resetNextRunTime(steady_clock::now());
       std::make_heap(functions_.begin(), functions_.end(), fnCmp_);
       runningCondvar_.notify_one();
     }
     return true;
   }
   return false;
 }

void folly::FunctionScheduler::run ( )

private

Definition at line 438 of file FunctionScheduler.cpp.

References folly::lock(), mutex_, now(), and folly::setThreadName().

                             {
   std::unique_lock<std::mutex> lock(mutex_);
 
   if (!threadName_.empty()) {
     folly::setThreadName(threadName_);
   }
 
   while (running_) {
     // If we have nothing to run, wait until a function is added or until we
     // are stopped.
     if (functions_.empty()) {
       runningCondvar_.wait(lock);
       continue;
     }
 
     auto now = steady_clock::now();
 
     // Move the next function to run to the end of functions_
     std::pop_heap(functions_.begin(), functions_.end(), fnCmp_);
 
     // Check to see if the function was cancelled.
     // If so, just remove it and continue around the loop.
     if (!functions_.back()->isValid()) {
       functions_.pop_back();
       continue;
     }
 
     auto sleepTime = functions_.back()->getNextRunTime() - now;
     if (sleepTime < milliseconds::zero()) {
       // We need to run this function now
       runOneFunction(lock, now);
       runningCondvar_.notify_all();
     } else {
       // Re-add the function to the heap, and wait until we actually
       // need to run it.
       std::push_heap(functions_.begin(), functions_.end(), fnCmp_);
       runningCondvar_.wait_for(lock, sleepTime);
     }
   }
 }

void folly::FunctionScheduler::runOneFunction	(	std::unique_lock< std::mutex > &	lock,
		std::chrono::steady_clock::time_point	now
	)

private

Definition at line 479 of file FunctionScheduler.cpp.

References folly::exceptionStr(), folly::gen::move, and mutex_.

                                 {
   DCHECK(lock.mutex() == &mutex_);
   DCHECK(lock.owns_lock());
 
   // The function to run will be at the end of functions_ already.
   //
   // Fully remove it from functions_ now.
   // We need to release mutex_ while we invoke this function, and we need to
   // maintain the heap property on functions_ while mutex_ is unlocked.
   auto func = std::move(functions_.back());
   functions_.pop_back();
   if (!func->cb) {
     VLOG(5) << func->name << "function has been canceled while waiting";
     return;
   }
   currentFunction_ = func.get();
   // Update the function's next run time.
   if (steady_) {
     // This allows scheduler to catch up
     func->setNextRunTimeSteady();
   } else {
     // Note that we set nextRunTime based on the current time where we started
     // the function call, rather than the time when the function finishes.
     // This ensures that we call the function once every time interval, as
     // opposed to waiting time interval seconds between calls.  (These can be
     // different if the function takes a significant amount of time to run.)
     func->setNextRunTimeStrict(now);
   }
 
   // Release the lock while we invoke the user's function
   lock.unlock();
 
   // Invoke the function
   try {
     VLOG(5) << "Now running " << func->name;
     func->cb();
   } catch (const std::exception& ex) {
     LOG(ERROR) << "Error running the scheduled function <" << func->name
                << ">: " << exceptionStr(ex);
   }
 
   // Re-acquire the lock
   lock.lock();
 
   if (!currentFunction_) {
     // The function was cancelled while we were running it.
     // We shouldn't reschedule it;
     cancellingCurrentFunction_ = false;
     return;
   }
   if (currentFunction_->runOnce) {
     // Don't reschedule if the function only needed to run once.
     functionsMap_.erase(currentFunction_->name);
     currentFunction_ = nullptr;
     return;
   }
 
   // Re-insert the function into our functions_ heap.
   // We only maintain the heap property while running_ is set.  (running_ may
   // have been cleared while we were invoking the user's function.)
   functions_.push_back(std::move(func));
 
   // Clear currentFunction_
   currentFunction_ = nullptr;
 
   if (running_) {
     std::push_heap(functions_.begin(), functions_.end(), fnCmp_);
   }
 }

void folly::FunctionScheduler::setSteady ( bool steady )

inline

By default steady is false, meaning schedules may lag behind overtime. This could be due to long running tasks or time drift because of randomness in thread wakeup time. By setting steady to true, FunctionScheduler will attempt to catch up. i.e. more like a cronjob

NOTE: it's only safe to set this before calling start()

Definition at line 68 of file FunctionScheduler.h.

References steady_.

Referenced by TEST().

                               {
     steady_ = steady;
   }

void folly::FunctionScheduler::setThreadName ( StringPiece threadName )

Set the name of the worker thread.

Definition at line 569 of file FunctionScheduler.cpp.

References mutex_, and folly::Range< Iter >::str().

                                                             {
   std::unique_lock<std::mutex> l(mutex_);
   threadName_ = threadName.str();
 }

bool folly::FunctionScheduler::shutdown ( )

Stops the FunctionScheduler.

It may be restarted later by calling start() again. Returns false if the scheduler was not running.

Definition at line 424 of file FunctionScheduler.cpp.

References g(), and mutex_.

Referenced by TEST().

                                  {
   {
     std::lock_guard<std::mutex> g(mutex_);
     if (!running_) {
       return false;
     }
 
     running_ = false;
     runningCondvar_.notify_one();
   }
   thread_.join();
   return true;
 }

bool folly::FunctionScheduler::start ( )

Starts the scheduler.

Returns false if the scheduler was already running.

Definition at line 399 of file FunctionScheduler.cpp.

References f, mutex_, now(), and folly::run().

Referenced by TEST().

                               {
   std::unique_lock<std::mutex> l(mutex_);
   if (running_) {
     return false;
   }
 
   VLOG(1) << "Starting FunctionScheduler with " << functions_.size()
           << " functions.";
   auto now = steady_clock::now();
   // Reset the next run time. for all functions.
   // note: this is needed since one can shutdown() and start() again
   for (const auto& f : functions_) {
     f->resetNextRunTime(now);
     VLOG(1) << "   - func: " << (f->name.empty() ? "(anon)" : f->name.c_str())
             << ", period = " << f->intervalDescr
             << ", delay = " << f->startDelay.count() << "ms";
   }
   std::make_heap(functions_.begin(), functions_.end(), fnCmp_);
 
   thread_ = std::thread([&] { this->run(); });
   running_ = true;
 
   return true;
 }

Member Data Documentation

bool folly::FunctionScheduler::cancellingCurrentFunction_ {false}

private

Definition at line 378 of file FunctionScheduler.h.

RepeatFunc* folly::FunctionScheduler::currentFunction_ {nullptr}

private

Definition at line 370 of file FunctionScheduler.h.

RunTimeOrder folly::FunctionScheduler::fnCmp_

private

Definition at line 366 of file FunctionScheduler.h.

FunctionHeap folly::FunctionScheduler::functions_

private

Definition at line 364 of file FunctionScheduler.h.

FunctionMap folly::FunctionScheduler::functionsMap_

private

Definition at line 365 of file FunctionScheduler.h.

std::mutex folly::FunctionScheduler::mutex_

private

Definition at line 359 of file FunctionScheduler.h.

bool folly::FunctionScheduler::running_ {false}

private

Definition at line 360 of file FunctionScheduler.h.

std::condition_variable folly::FunctionScheduler::runningCondvar_

private

Definition at line 374 of file FunctionScheduler.h.

bool folly::FunctionScheduler::steady_ {false}

private

Definition at line 377 of file FunctionScheduler.h.

Referenced by setSteady().

std::thread folly::FunctionScheduler::thread_

private

Definition at line 356 of file FunctionScheduler.h.

std::string folly::FunctionScheduler::threadName_

private

Definition at line 376 of file FunctionScheduler.h.

The documentation for this class was generated from the following files:

proxygen/folly/folly/experimental/FunctionScheduler.h
proxygen/folly/folly/experimental/FunctionScheduler.cpp

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation