Status ServiceExecutorReserved::_startWorker() {
log() << "Starting new worker thread for " << _name << " service executor";
return launchServiceWorkerThread([this] {
stdx::unique_lock<stdx::mutex> lk(_mutex);
_numRunningWorkerThreads.addAndFetch(1);
auto numRunningGuard = makeGuard([&] {
_numRunningWorkerThreads.subtractAndFetch(1);
_shutdownCondition.notify_one();
});
_numStartingThreads--;
_numReadyThreads++;
while (_stillRunning.load()) {
_threadWakeup.wait(lk, [&] { return (!_stillRunning.load() || !_readyTasks.empty()); });
if (!_stillRunning.loadRelaxed()) {
break;
}
if (_readyTasks.empty()) {
continue;
}
auto task = std::move(_readyTasks.front());
_readyTasks.pop_front();
_numReadyThreads -= 1;
bool launchReplacement = false;
if (_numReadyThreads + _numStartingThreads < _reservedThreads) {
_numStartingThreads++;
launchReplacement = true;
}
lk.unlock();
if (launchReplacement) {
auto threadStartStatus = _startWorker();
if (!threadStartStatus.isOK()) {
warning() << "Could not start new reserve worker thread: " << threadStartStatus;
}
}
_localWorkQueue.emplace_back(std::move(task));
while (!_localWorkQueue.empty() && _stillRunning.loadRelaxed()) {
_localRecursionDepth = 1;
_localWorkQueue.front()();
_localWorkQueue.pop_front();
}
lk.lock();
if (_numReadyThreads + 1 > _reservedThreads) {
break;
} else {
_numReadyThreads += 1;
}
}
LOG(3) << "Exiting worker thread in " << _name << " service executor";
});
}
Status ServiceExecutorSynchronous::schedule(Task task,
ScheduleFlags flags,
ServiceExecutorTaskName taskName) {
if (!_stillRunning.load()) {
return Status{ErrorCodes::ShutdownInProgress, "Executor is not running"};
}
if (!_localWorkQueue.empty()) {
/*
* In perf testing we found that yielding after running a each request produced
* at 5% performance boost in microbenchmarks if the number of worker threads
* was greater than the number of available cores.
*/
if (flags & ScheduleFlags::kMayYieldBeforeSchedule) {
if ((_localThreadIdleCounter++ & 0xf) == 0) {
markThreadIdle();
}
if (_numRunningWorkerThreads.loadRelaxed() > _numHardwareCores) {
stdx::this_thread::yield();
}
}
// Execute task directly (recurse) if allowed by the caller as it produced better
// performance in testing. Try to limit the amount of recursion so we don't blow up the
// stack, even though this shouldn't happen with this executor that uses blocking network
// I/O.
if ((flags & ScheduleFlags::kMayRecurse) &&
(_localRecursionDepth < synchronousServiceExecutorRecursionLimit.loadRelaxed())) {
++_localRecursionDepth;
task();
} else {
_localWorkQueue.emplace_back(std::move(task));
}
return Status::OK();
}
// First call to schedule() for this connection, spawn a worker thread that will push jobs
// into the thread local job queue.
LOG(3) << "Starting new executor thread in passthrough mode";
Status status = launchServiceWorkerThread([ this, task = std::move(task) ] {
_numRunningWorkerThreads.addAndFetch(1);
_localWorkQueue.emplace_back(std::move(task));
while (!_localWorkQueue.empty() && _stillRunning.loadRelaxed()) {
_localRecursionDepth = 1;
_localWorkQueue.front()();
_localWorkQueue.pop_front();
}
if (_numRunningWorkerThreads.subtractAndFetch(1) == 0) {
_shutdownCondition.notify_all();
}
});
return status;
}
