Class DecomissionableLastInFirstOutFixedSizeSemaphore

src/semaphore.hpp:244–416

                            : __semaphore__)

class DecomissionableLastInFirstOutFixedSizeSemaphore
{
public:
  // TODO(benh): enable specifying the number of threads that will use
  // this semaphore. Currently this is difficult because we construct
  // the `RunQueue` and later this class before we've determined the
  // number of worker threads we'll create.
  DecomissionableLastInFirstOutFixedSizeSemaphore()
  {
    for (size_t i = 0; i < semaphores.size(); i++) {
      semaphores[i] = nullptr;
    }
  }

  void signal()
  {
    // NOTE: we _always_ increment `count` which means that even if we
    // try and signal a thread another thread might have come in and
    // decremented `count` already. This is deliberate, but it would
    // be interesting to also investigate the performance where we
    // always signal a new thread.
    count.fetch_add(1);

    while (waiters.load() > 0 && count.load() > 0) {
      for (size_t i = 0; i < semaphores.size(); i++) {
        // Don't bother finding a semaphore to signal if there isn't
        // anybody to signal (`waiters` == 0) or anything to do
        // (`count` == 0).
        if (waiters.load() == 0 || count.load() == 0) {
          return;
        }

        // Try and find and then signal a waiter.
        //
        // TODO(benh): we `load()` first and then do a
        // compare-and-swap because the read shouldn't require a lock
        // instruction or synchronizing the bus. In addition, we
        // should be able to optimize the loads in the future to a
        // weaker memory ordering. That being said, if we don't see
        // performance wins when trying that we should consider just
        // doing a `std::atomic::exchange()` instead.
        KernelSemaphore* semaphore = semaphores[i].load();
        if (semaphore != nullptr) {
          if (!semaphores[i].compare_exchange_strong(semaphore, nullptr)) {
            continue;
          }

          // NOTE: we decrement `waiters` _here_ rather than in `wait`
          // so that future signalers won't bother looping here
          // (potentially for a long time) trying to find a waiter
          // that might have already been signaled but just hasn't
          // woken up yet. We even go as far as decrementing `waiters`
          // _before_ we signal to really keep a thread from having to
          // loop.
          waiters.fetch_sub(1);

          semaphore->signal();