barrier.cc

Go to the documentation of this file.

#include "ion/port/barrier.h"

#if defined(ION_PLATFORM_WINDOWS)
#  include <assert.h>  // For checking return values since port has no logging.
#  include <algorithm>  // for swap
#endif

namespace ion {
namespace port {




#if defined(ION_PLATFORM_WINDOWS)



Barrier::Barrier(uint32 thread_count)
    : thread_count_(thread_count),
      wait_count_(0),
      turnstile1_(NULL),
      turnstile2_(NULL),
      is_valid_(thread_count_ > 0) {
  if (IsValid()) {
    turnstile1_ = CreateSemaphore(NULL, 0, thread_count_, NULL);
    turnstile2_ = CreateSemaphore(NULL, 0, thread_count_, NULL);
  }
}

Barrier::~Barrier() {
  if (IsValid()) {
    CloseHandle(turnstile2_);
    CloseHandle(turnstile1_);
  }
}

void Barrier::Wait() {
  if (IsValid() && thread_count_ > 1) {
    WaitInternal(1, thread_count_, turnstile1_);

    WaitInternal(-1, 0, turnstile2_);
  }
}

void Barrier::WaitInternal(int32 increment, int32 limit, HANDLE turnstile) {
  if ((wait_count_ += increment) == limit) {
    BOOL status = ReleaseSemaphore(turnstile, thread_count_ - 1, NULL);
    (void)status;  // Avoid warnings when the assertion is optimized out.
    assert(status != 0);
  } else {
    DWORD status = WaitForSingleObject(turnstile, INFINITE);
    (void)status;  // Avoid warnings when the assertion is optimized out.
    assert(status == WAIT_OBJECT_0);
  }
}

#elif defined(ION_PLATFORM_LINUX) || defined(ION_PLATFORM_QNX)



Barrier::Barrier(uint32 thread_count)
    : waiting_count_(0),
      is_valid_(!pthread_barrier_init(&barrier_, NULL, thread_count)) {}

Barrier::~Barrier() {
  if (IsValid()) {
    while (waiting_count_ != 0) {}
    pthread_barrier_destroy(&barrier_);
  }
}

void Barrier::Wait() {
  if (IsValid()) {
    ++waiting_count_;
    pthread_barrier_wait(&barrier_);
    --waiting_count_;
  }
}

#else



Barrier::Barrier(uint32 thread_count)
    : thread_count_(thread_count),
      wait_count_(0),
      exit_count_(1),
      is_valid_(thread_count_ > 0) {
  if (IsValid()) {
    pthread_cond_init(&condition_, NULL);
    pthread_cond_init(&exit_condition_, NULL);
    pthread_mutex_init(&mutex_, NULL);
  }
}

Barrier::~Barrier() {
  if (IsValid()) {
    pthread_mutex_lock(&mutex_);
    if (thread_count_ > 1 && --exit_count_) {
      pthread_cond_wait(&exit_condition_, &mutex_);
    }
    pthread_mutex_unlock(&mutex_);
    pthread_cond_destroy(&condition_);
    pthread_cond_destroy(&exit_condition_);
    pthread_mutex_destroy(&mutex_);
  }
}

void Barrier::Wait() {
  if (IsValid()) {
    pthread_mutex_lock(&mutex_);
    if (++wait_count_ == thread_count_) {
      wait_count_ = 0;
      exit_count_ = thread_count_ + 1;
      pthread_cond_broadcast(&condition_);
    } else {
      pthread_cond_wait(&condition_, &mutex_);
    }

    if (--exit_count_ == 0)
      pthread_cond_broadcast(&exit_condition_);
    pthread_mutex_unlock(&mutex_);
  }
}

#endif

}  // namespace port
}  // namespace ion