semaphore.cc

Go to the documentation of this file.

#include "ion/port/semaphore.h"
#include "ion/port/threadutils.h"

#if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
#include <mach/mach_init.h>
#include <mach/task.h>
#include <time.h>
#elif defined(ION_PLATFORM_ASMJS)
#include <cassert>
#elif !defined(ION_PLATFORM_WINDOWS)
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#endif

namespace ion {
namespace port {

Semaphore::Semaphore() {
#if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
  semaphore_ = dispatch_semaphore_create(0);
#elif defined(ION_PLATFORM_WINDOWS)
  semaphore_ = CreateSemaphore(NULL, 0, 0x7fffffff, NULL);
  value_.store(0);
#elif defined(ION_PLATFORM_ASMJS)
  value_ = 0;
#else
  sem_init(&semaphore_, 0, 0);
#endif
}

Semaphore::Semaphore(uint32 initial_value) {
#if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
  semaphore_ = dispatch_semaphore_create(0);
  while (initial_value--)
    Post();
#elif defined(ION_PLATFORM_WINDOWS)
  semaphore_ = CreateSemaphore(NULL, 0, 0x7fffffff, NULL);
  value_.store(initial_value);
#elif defined(ION_PLATFORM_ASMJS)
  value_ = initial_value;
#else
  sem_init(&semaphore_, 0, initial_value);
#endif
}

Semaphore::~Semaphore() {
#if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
#elif defined(ION_PLATFORM_WINDOWS)
  CloseHandle(semaphore_);
#elif defined(ION_PLATFORM_ASMJS)
#else
  sem_destroy(&semaphore_);
#endif
}

bool Semaphore::Post() {
#if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
  return semaphore_
    ? (dispatch_semaphore_signal(semaphore_) || true)
    : false;
#elif defined(ION_PLATFORM_WINDOWS)
  if (++value_ > 0) {
    return true;
  } else {
    return ReleaseSemaphore(semaphore_, 1, NULL) != 0;
  }
#elif defined(ION_PLATFORM_ASMJS)
  ++value_;
  return true;
#else
  return sem_post(&semaphore_) == 0;
#endif
}

bool Semaphore::TryWait() {
#if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
  return semaphore_
    ? (0 == dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_NOW))
    : false;
#elif defined(ION_PLATFORM_WINDOWS)
  int val = value_.load(std::memory_order_acquire);
  while (val > 0) {
    if (value_.compare_exchange_weak(val, val - 1,
                                     std::memory_order_acq_rel,
                                     std::memory_order_acquire)) {
      return true;
    }
  }
  return false;
#elif defined(ION_PLATFORM_ASMJS)
  if (value_ > 0) {
    --value_;
    return true;
  } else {
    return false;
  }
#else
  return sem_trywait(&semaphore_) == 0;
#endif
}

bool Semaphore::TimedWaitMs(int64 timeout_in_ms) {
  if (timeout_in_ms < 0)
    return Wait();

#if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
  static const int64 kMsecToNsec = 1000000;
  const dispatch_time_t deadline = dispatch_time(DISPATCH_TIME_NOW,
                                                 timeout_in_ms * kMsecToNsec);
  return semaphore_
    ? (0 == dispatch_semaphore_wait(semaphore_, deadline))
    : false;
#elif defined(ION_PLATFORM_WINDOWS)
  if (value_-- > 0) {
    return true;
  }
  if (WaitForSingleObject(semaphore_, timeout_in_ms) == WAIT_OBJECT_0) {
    return true;
  } else {
    ++value_;
    return false;
  }
#elif defined(ION_PLATFORM_ASMJS)
  return TryWait();
#else
  static const int64 kMsecToNsec = 1000000;
  static const int64 kNsecPerSec = 1000000000;

  timeval now;
  ::gettimeofday(&now, NULL);
  const uint64 timeout_in_ns = now.tv_usec * 1000 + timeout_in_ms * kMsecToNsec;

  timespec timeout;
  timeout.tv_nsec = static_cast<int32>(timeout_in_ns % kNsecPerSec);
  timeout.tv_sec = static_cast<int32>(now.tv_sec + timeout_in_ns / kNsecPerSec);
#if !defined(ION_PLATFORM_PNACL) && !defined(ION_PLATFORM_NACL)
  return sem_timedwait(&semaphore_, &timeout) == 0;
#else
  while (!TryWait()) {
    YieldThread();
    ::gettimeofday(&now, NULL);
    if (now.tv_sec > timeout.tv_sec ||
        (now.tv_sec == timeout.tv_sec &&
         now.tv_usec * 1000 > timeout.tv_nsec)) {
      return false;
    }
  }
  return true;
#endif
#endif
}

bool Semaphore::Wait() {
#if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
  return semaphore_
    ? (dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER) || true)
    : false;
#elif defined(ION_PLATFORM_WINDOWS)
  int spin_count = 2;
  while (spin_count--) {
    if (TryWait()) {
      return true;
    }
  }
  if (value_-- > 0) {
    return true;
  } else {
    if (WaitForSingleObject(semaphore_, INFINITE) == WAIT_OBJECT_0) {
      return true;
    } else {
      ++value_;       // COV_NF_LINE
      return false;   // COV_NF_LINE
    }
  }
#elif defined(ION_PLATFORM_ASMJS)
  if (value_ > 0) {
    --value_;
    return true;
  } else {
    assert(false &&
        "Semaphore::Wait cannot block on a platform without threads.");
    return false;
  }
#else
  return sem_wait(&semaphore_) == 0;
#endif
}
}  // namespace port
}  // namespace ion