Method Done

lib/base/io-engine.cpp:100–131

* Releases the own slot acquired by the constructor (TryAcquireSlot()) if not already done. * * Precisely, increments the number of free slots (semaphore) by one. * Also wakes up all waiting constructors (slow path) if necessary. */

 * Also wakes up all waiting constructors (slow path) if necessary.
 */
void CpuBoundWork::Done()
{
	if (!m_Done) {
		m_Done = true;

		auto& ie (IoEngine::Get());

		// The constructor takes the slow path only if the semaphore is full,
		// so we only have to wake up constructors if the semaphore was full.
		// This works because after fetch_add(), TryAcquireSlot() (fast path) will succeed.
		if (ie.m_CpuBoundSemaphore.fetch_add(1) == 0u) {
			// So now there are only slow path subscribers from just before the fetch_add() to be woken up.
			// Precisely, only subscribers from just before the fetch_add() which turned 0 to 1.

			decltype(ie.m_CpuBoundWaiting) subscribers;

			{
				// Locking after fetch_add() is safe because a delayed wake-up is fine.
				// Wake-up of constructors which subscribed after the fetch_add() is also not a problem.
				// In worst case, they will just re-subscribe to the slow path.
				// Lost wake-ups are mitigated by the constructor, see its implementation comments.
				std::unique_lock lock (ie.m_CpuBoundWaitingMutex);
				std::swap(subscribers, ie.m_CpuBoundWaiting);
			}

			// Again, a delayed wake-up is fine, hence unlocked.
			for (auto& subscriber : subscribers) {
				boost::asio::post(subscriber.first, [cv = std::move(subscriber.second)] { cv->NotifyOne(); });
			}
		}
	}
}

LazyInit<std::unique_ptr<IoEngine>> IoEngine::m_Instance ([]() { return std::unique_ptr<IoEngine>(new IoEngine()); });