Method runner

fdbserver/VersionedBTree.actor.cpp:219–295

	}

	ACTOR static Future<Void> runner(PriorityMultiLock* self) {
		state int sinceYield = 0;
		state Future<Void> error = self->brokenOnDestruct.getFuture();
		state int maxPriority = self->waiters.size() - 1;

		// Priority to try to run tasks from next
		state int priority = maxPriority;
		state Queue* pQueue = &self->waiters[maxPriority];

		// Track the number of waiters unlocked at the same priority in a row
		state int lastPriorityCount = 0;

		loop {
			// Cleanup finished runner futures at the front of the runner queue.
			while (!self->runners.empty() && self->runners.front().isReady()) {
				self->runners.pop_front();
			}

			// Wait for a runner to release its lock
			wait(self->release.onTrigger());
			prioritylock_printf("runner wakeup %s\n", self->toString().c_str());

			if (++sinceYield == 1000) {
				sinceYield = 0;
				wait(delay(0));
			}

			// While there are available slots and there are waiters, launch tasks
			while (self->available > 0 && self->waiting > 0) {
				prioritylock_printf("Checking priority=%d lastPriorityCount=%d %s\n",
				                    priority,
				                    lastPriorityCount,
				                    self->toString().c_str());

				while (!pQueue->empty() && ++lastPriorityCount < self->launchLimit) {
					Waiter w = pQueue->front();
					pQueue->pop_front();
					--self->waiting;
					Lock lock;
					prioritylock_printf("  Running waiter priority=%d wait=%f %s\n",
					                    priority,
					                    now() - w.queuedTime,
					                    self->toString().c_str());
					w.lockPromise.send(lock);

					// Self may have been destructed during the lock callback
					if (error.isReady()) {
						throw error.getError();
					}

					// If the lock was not already released, add it to the runners future queue
					if (lock.promise.canBeSet()) {
						self->addRunner(lock);

						// A slot has been consumed, so stop reading from this queue if there aren't any more
						if (--self->available == 0) {
							break;
						}