semaphore.h

#pragma once
 
#include "gaia/config/config.h"
 
#if GAIA_PLATFORM_WINDOWS
  #include <climits>
 
  #include "gaia/mt/win32.h"
#elif GAIA_PLATFORM_APPLE
  #include <TargetConditionals.h>
  #include <dispatch/dispatch.h>
  #include <pthread.h>
#else
  #include <pthread.h>
  #include <semaphore.h>
#endif
 
namespace gaia {
  namespace mt {
    class GAIA_API Semaphore final {
#if GAIA_PLATFORM_WINDOWS
      void* m_handle;
#elif GAIA_PLATFORM_APPLE
      dispatch_semaphore_t m_handle;
#else
      sem_t m_handle;
#endif
 
      Semaphore(Semaphore&&) = delete;
      Semaphore(const Semaphore&) = delete;
      Semaphore& operator=(Semaphore&&) = delete;
      Semaphore& operator=(const Semaphore&) = delete;
 
      void init(int32_t count) {
#if GAIA_PLATFORM_WINDOWS
        m_handle = ::CreateSemaphoreExW(nullptr, count, INT_MAX, nullptr, 0, win32::SemaphoreAllAccess);
        GAIA_ASSERT(m_handle != nullptr);
#elif GAIA_PLATFORM_APPLE
        m_handle = dispatch_semaphore_create(count);
        GAIA_ASSERT(m_handle != nullptr);
#else
        [[maybe_unused]] int ret = sem_init(&m_handle, 0, (unsigned int)count);
        GAIA_ASSERT(ret == 0);
#endif
      }
 
      void done() {
#if GAIA_PLATFORM_WINDOWS
        if (m_handle != nullptr) {
          ::CloseHandle(m_handle);
          m_handle = nullptr;
        }
#elif GAIA_PLATFORM_APPLE
        // NOTE: Dispatch objects are reference counted.
        //       They are automatically released when no longer used.
        // -> dispatch_release(m_handle);
#else
        [[maybe_unused]] int ret = sem_destroy(&m_handle);
        GAIA_ASSERT(ret == 0);
#endif
      }
 
    public:
      explicit Semaphore(int32_t count = 0) {
        init(count);
      }
 
      ~Semaphore() {
        done();
      }
 
      void release(int32_t count) {
        GAIA_ASSERT(count > 0);
 
#if GAIA_PLATFORM_WINDOWS
        [[maybe_unused]] long prev = 0;
        [[maybe_unused]] int res = ::ReleaseSemaphore(m_handle, count, &prev);
        GAIA_ASSERT(res != 0);
#elif GAIA_PLATFORM_APPLE
        do {
          dispatch_semaphore_signal(m_handle);
        } while ((--count) != 0);
#else
        do {
          [[maybe_unused]] const auto ret = sem_post(&m_handle);
          GAIA_ASSERT(ret == 0);
        } while ((--count) != 0);
#endif
      }
 
      bool wait() {
#if GAIA_PLATFORM_WINDOWS
        GAIA_ASSERT(m_handle != nullptr);
        const unsigned long ret = ::WaitForSingleObject(m_handle, win32::Infinite);
        GAIA_ASSERT(ret == win32::WaitObject0);
        return (ret == win32::WaitObject0);
#elif GAIA_PLATFORM_APPLE
        const auto res = dispatch_semaphore_wait(m_handle, DISPATCH_TIME_FOREVER);
        GAIA_ASSERT(res == 0);
        return (res == 0);
#else
        int res;
        do {
          res = sem_wait(&m_handle);
        } while (res == -1 && errno == EINTR); // handle interrupts
 
        GAIA_ASSERT(res == 0);
        return (res == 0);
#endif
      }
    };
  } // namespace mt
} // namespace gaia