/src/dng_sdk/source/dng_pthread.cpp

Source (jump to first uncovered line)
/*****************************************************************************/
// Copyright 2002-2008 Adobe Systems Incorporated
// All Rights Reserved.
//
// NOTICE:  Adobe permits you to use, modify, and distribute this file in
// accordance with the terms of the Adobe license agreement accompanying it.
/*****************************************************************************/

/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_pthread.cpp#2 $ */ 
/* $DateTime: 2012/07/31 22:04:34 $ */
/* $Change: 840853 $ */
/* $Author: tknoll $ */

#include "dng_pthread.h"

/*****************************************************************************/

#if qDNGThreadSafe

/*****************************************************************************/

#include "dng_assertions.h"

/*****************************************************************************/

#if qWinOS

#pragma warning(disable : 4786)

// Nothing in this file requires Unicode,
// However, CreateSemaphore has a path parameter
// (which is NULL always in this code) and thus
// does not work on Win98 if UNICODE is defined.
// So we force it off here.

#undef UNICODE
#undef _UNICODE

#include <windows.h>
#include <process.h>
#include <errno.h>
#include <memory>
#include <new>
#include <map>

#else

#include <sys/time.h>

#endif

/*****************************************************************************/

#if qWinOS

/*****************************************************************************/

namespace {
  struct waiter {
    struct waiter *prev;
    struct waiter *next;
    HANDLE semaphore;
    bool chosen_by_signal;
  };
}

/*****************************************************************************/

struct dng_pthread_mutex_impl
{
  CRITICAL_SECTION lock;

  dng_pthread_mutex_impl()  { ::InitializeCriticalSection(&lock); }
  ~dng_pthread_mutex_impl() { ::DeleteCriticalSection(&lock); }
  void Lock()          { ::EnterCriticalSection(&lock); }
  void Unlock()        { ::LeaveCriticalSection(&lock); }
private:
  dng_pthread_mutex_impl &operator=(const dng_pthread_mutex_impl &);
  dng_pthread_mutex_impl(const dng_pthread_mutex_impl &) { }
};

/*****************************************************************************/

struct dng_pthread_cond_impl
{
  dng_pthread_mutex_impl lock;    // Mutual exclusion on next two variables
  waiter *head_waiter;      // List of threads waiting on this condition
  waiter *tail_waiter;      // Used to get FIFO, rather than LIFO, behavior for pthread_cond_signal 
  unsigned int broadcast_generation;  // Used as sort of a separator on broadcasts
                    // saves having to walk the waiters list setting
                    // each one's "chosen_by_signal" flag while the condition is locked

  dng_pthread_cond_impl() : head_waiter(NULL), tail_waiter(NULL), broadcast_generation(0) { }
  ~dng_pthread_cond_impl() { } ;

// Non copyable
private:
  dng_pthread_cond_impl &operator=(const dng_pthread_cond_impl &);
  dng_pthread_cond_impl(const dng_pthread_cond_impl &) { }

};

/*****************************************************************************/

namespace
{

  struct ScopedLock
  {
    dng_pthread_mutex_impl *mutex;

    ScopedLock(dng_pthread_mutex_impl *arg) : mutex(arg)
    {
      mutex->Lock();
    }
    ScopedLock(dng_pthread_mutex_impl &arg) : mutex(&arg)
    {
      mutex->Lock();
    }
    ~ScopedLock()
    {
      mutex->Unlock();
    }
  private:
    ScopedLock &operator=(const ScopedLock &);
    ScopedLock(const ScopedLock &) { }
  };

  dng_pthread_mutex_impl validationLock;

  void ValidateMutex(dng_pthread_mutex_t *mutex)
  {
    if (*mutex != DNG_PTHREAD_MUTEX_INITIALIZER)
      return;

    ScopedLock lock(validationLock);

    if (*mutex == DNG_PTHREAD_MUTEX_INITIALIZER)
      dng_pthread_mutex_init(mutex, NULL);
  }

  void ValidateCond(dng_pthread_cond_t *cond)
  {
    if (*cond != DNG_PTHREAD_COND_INITIALIZER)
      return;

    ScopedLock lock(validationLock);

    if (*cond == DNG_PTHREAD_COND_INITIALIZER)
      dng_pthread_cond_init(cond, NULL);
  }

  DWORD thread_wait_sema_TLS_index;
  bool thread_wait_sema_inited = false;
  dng_pthread_once_t once_thread_TLS = DNG_PTHREAD_ONCE_INIT;

  void init_thread_TLS()
  {
    thread_wait_sema_TLS_index = ::TlsAlloc();
    thread_wait_sema_inited = true;
  }

  void finalize_thread_TLS()
  {
    if (thread_wait_sema_inited)
      {
      ::TlsFree(thread_wait_sema_TLS_index);
      thread_wait_sema_inited = false;
      }
  }

  dng_pthread_mutex_impl primaryHandleMapLock;

  typedef std::map<DWORD, std::pair<HANDLE, void **> > ThreadMapType;

  // A map to make sure handles are freed and to allow returning a pointer sized result
  // even on 64-bit Windows.
  ThreadMapType primaryHandleMap;

  HANDLE GetThreadSemaphore()
  {
    dng_pthread_once(&once_thread_TLS, init_thread_TLS);

    HANDLE semaphore = ::TlsGetValue(thread_wait_sema_TLS_index);
    if (semaphore == NULL)
    {
      semaphore = ::CreateSemaphore(NULL, 0, 1, NULL);
      ::TlsSetValue(thread_wait_sema_TLS_index, semaphore);
    }

    return semaphore;
  }

  void FreeThreadSemaphore()
  {
    if (thread_wait_sema_inited)
    {
      HANDLE semaphore = (HANDLE)::TlsGetValue(thread_wait_sema_TLS_index);

      if (semaphore != NULL)
      {
        ::TlsSetValue(thread_wait_sema_TLS_index, NULL);
        ::CloseHandle(semaphore);
      }
    }
  }

  struct trampoline_args
  {
    void *(*func)(void *);
    void *arg;
  };

  // This trampoline takes care of the return type being different
  // between pthreads thread funcs and Windows C lib thread funcs
  unsigned __stdcall trampoline(void *arg_arg)
  {
    trampoline_args *args_ptr = (trampoline_args *)arg_arg;
    trampoline_args args = *args_ptr;

    delete args_ptr;

    GetThreadSemaphore();
    
    void *result = args.func(args.arg);

    {
      ScopedLock lockMap(primaryHandleMapLock);

      ThreadMapType::iterator iter = primaryHandleMap.find(pthread_self());
      if (iter != primaryHandleMap.end())
        *iter->second.second = result;
    }

    FreeThreadSemaphore();

    return S_OK;
  }

}

/*****************************************************************************/

extern "C" {

/*****************************************************************************/

struct dng_pthread_attr_impl
  {
  size_t stacksize;
  };

/*****************************************************************************/

int dng_pthread_attr_init(pthread_attr_t *attr)
  {
  dng_pthread_attr_impl *newAttrs;

  newAttrs = new (std::nothrow) dng_pthread_attr_impl;
  if (newAttrs == NULL)
    return -1; // ENOMEM;

  newAttrs->stacksize = 0;

  *attr = newAttrs;

  return 0;
  }

/*****************************************************************************/

int dng_pthread_attr_destroy(pthread_attr_t *attr)
  {
  if (*attr == NULL)
    return -1; // EINVAL

  delete *attr;

  *attr = NULL;

  return 0;
  }

/*****************************************************************************/

int dng_pthread_attr_setstacksize(dng_pthread_attr_t *attr, size_t stacksize)
  {
  if (attr == NULL || (*attr) == NULL)
    return -1; // EINVAL

  (*attr)->stacksize = stacksize;

  return 0;
  }

/*****************************************************************************/

int dng_pthread_attr_getstacksize(const dng_pthread_attr_t *attr, size_t *stacksize)
  {
  if (attr == NULL || (*attr) == NULL || stacksize == NULL)
    return -1; // EINVAL

  *stacksize = (*attr)->stacksize;

  return 0;
  }

/*****************************************************************************/

int dng_pthread_create(dng_pthread_t *thread, const pthread_attr_t *attrs, void * (*func)(void *), void *arg)
{
  try
  {
    uintptr_t result;
    unsigned threadID;
    std::auto_ptr<trampoline_args> args(new (std::nothrow) trampoline_args);
    std::auto_ptr<void *> resultHolder(new (std::nothrow) (void *));

    if (args.get() == NULL || resultHolder.get () == NULL)
      return -1; // ENOMEM

    args->func = func;
    args->arg = arg;

    size_t stacksize = 0;

    if (attrs != NULL)
      dng_pthread_attr_getstacksize (attrs, &stacksize);

    {
      ScopedLock lockMap(primaryHandleMapLock);

      result = _beginthreadex(NULL, (unsigned)stacksize, trampoline, args.get(), 0, &threadID);
      if (result == NULL)
        return -1; // ENOMEM
      args.release();

      std::pair<DWORD, std::pair<HANDLE, void **> > newMapEntry(threadID,
                                   std::pair<HANDLE, void **>((HANDLE)result, resultHolder.get ()));
      std::pair<ThreadMapType::iterator, bool> insertion = primaryHandleMap.insert(newMapEntry);

      // If there is a handle open on the thread, its ID should not be reused so assert that an insertion was made.
      DNG_ASSERT(insertion.second, "pthread emulation logic error");
    }


    resultHolder.release ();

    *thread = (dng_pthread_t)threadID;
    return 0;
  }
  catch (const std::bad_alloc &)
  {
    return -1;
  }
}

/*****************************************************************************/

int dng_pthread_detach(dng_pthread_t thread)
{
  HANDLE primaryHandle;
  void **resultHolder = NULL;

  {
    ScopedLock lockMap(primaryHandleMapLock);

    ThreadMapType::iterator iter = primaryHandleMap.find(thread);
    if (iter == primaryHandleMap.end())
      return -1;

    primaryHandle = iter->second.first;

    // A join is waiting on the thread.
    if (primaryHandle == NULL)
      return -1;

    resultHolder = iter->second.second;

    primaryHandleMap.erase(iter);
  }

  delete resultHolder;

  if (!::CloseHandle(primaryHandle))
    return -1;

  return 0;
}

/*****************************************************************************/

int dng_pthread_join(dng_pthread_t thread, void **result)
{
  bool found = false;
  HANDLE primaryHandle = NULL;
  void **resultHolder = NULL;

  ThreadMapType::iterator iter;

  {
    ScopedLock lockMap(primaryHandleMapLock);

    iter = primaryHandleMap.find(thread);
    found = iter != primaryHandleMap.end();
    if (found)
    {
      primaryHandle = iter->second.first;
      resultHolder = iter->second.second;

      // Set HANDLE to NULL to force any later join or detach to fail.
      iter->second.first = NULL;
    }
  }

  // This case can happens when joining a thread not created with pthread_create,
  // which is a bad idea, but it gets mapped to doing the join, but always returns NULL.
  if (!found)
    primaryHandle = ::OpenThread(SYNCHRONIZE|THREAD_QUERY_INFORMATION, FALSE, thread);

  if (primaryHandle == NULL)
    return -1;

  DWORD err;
  if (::WaitForSingleObject(primaryHandle, INFINITE) != WAIT_OBJECT_0)
  {
    err = ::GetLastError();
    return -1;
  }

  {
    ScopedLock lockMap(primaryHandleMapLock);

    if (iter != primaryHandleMap.end())
      primaryHandleMap.erase(iter);
  }

  ::CloseHandle(primaryHandle);
  if (result != NULL && resultHolder != NULL)
    *result = *resultHolder;

  delete resultHolder;

  return 0;
}

/*****************************************************************************/

dng_pthread_t dng_pthread_self()
{
  return (dng_pthread_t)::GetCurrentThreadId();
}

/*****************************************************************************/

void dng_pthread_exit(void *result)
{
  {
    ScopedLock lockMap(primaryHandleMapLock);

    ThreadMapType::iterator iter = primaryHandleMap.find(pthread_self());
    if (iter != primaryHandleMap.end())
      *iter->second.second = result;
  }

  FreeThreadSemaphore();

  _endthreadex(S_OK);
}

/*****************************************************************************/

int dng_pthread_mutex_init(dng_pthread_mutex_t *mutex, void * /* attrs */)
{
  dng_pthread_mutex_t result;
  try {
    result = new(dng_pthread_mutex_impl);
  } catch (const std::bad_alloc &)
  {
    return -1;
  }

  if (result == NULL)
    return -1;
  *mutex = result;
  return 0;
}

/*****************************************************************************/

int dng_pthread_mutex_destroy(dng_pthread_mutex_t *mutex)
{
  if (*mutex == DNG_PTHREAD_MUTEX_INITIALIZER)
  {
    *mutex = NULL;
    return 0;
  }

  delete *mutex;
  *mutex = NULL;
  return 0;
}

/*****************************************************************************/

int dng_pthread_cond_init(dng_pthread_cond_t *cond, void * /* attrs */)
{
  dng_pthread_cond_t result;
  try {
    result = new(dng_pthread_cond_impl);
  } catch (const std::bad_alloc &)
  {
    return -1;
  }

  if (result == NULL)
    return -1;
  *cond = result;
  return 0;
}

/*****************************************************************************/

int dng_pthread_cond_destroy(dng_pthread_cond_t *cond)
{
  if (*cond == DNG_PTHREAD_COND_INITIALIZER)
  {
    *cond = NULL;
    return 0;
  }

  delete *cond;
  *cond = NULL;
  return 0;
}

/*****************************************************************************/

int dng_pthread_mutexattr_init(dng_pthread_mutexattr_t* mutexattr)
{
  return 0;
}

/*****************************************************************************/

int dng_pthread_mutexattr_settype(dng_pthread_mutexattr_t* mutexattr, int type)
{
  return 0;
}

/*****************************************************************************/

int dng_pthread_mutex_lock(dng_pthread_mutex_t *mutex)
{
  ValidateMutex(mutex);
  (*mutex)->Lock();
  return 0;
}

/*****************************************************************************/

int dng_pthread_mutex_unlock(dng_pthread_mutex_t *mutex)
{
  ValidateMutex(mutex);
  (*mutex)->Unlock();
  return 0;
}

/*****************************************************************************/

static int cond_wait_internal(dng_pthread_cond_t *cond, dng_pthread_mutex_t *mutex, int timeout_milliseconds)
{
  dng_pthread_cond_impl &real_cond = **cond;
  dng_pthread_mutex_impl &real_mutex = **mutex;

  waiter this_wait;
  HANDLE semaphore = GetThreadSemaphore();
  int my_generation; // The broadcast generation this waiter is in

  {
    this_wait.next = NULL;
    this_wait.semaphore = semaphore;
    this_wait.chosen_by_signal = 0;

    ScopedLock lock1(real_cond.lock);

    // Add this waiter to the end of the list.
    this_wait.prev = real_cond.tail_waiter;
    if (real_cond.tail_waiter != NULL)
      real_cond.tail_waiter->next = &this_wait;
    real_cond.tail_waiter = &this_wait;

    // If the list was empty, set the head of the list to this waiter.
    if (real_cond.head_waiter == NULL)
      real_cond.head_waiter = &this_wait;

    // Note which broadcast generation this waiter belongs to.
    my_generation = real_cond.broadcast_generation;
  }

  real_mutex.Unlock();

  DWORD result = ::WaitForSingleObject(semaphore, timeout_milliseconds);

  if (result == WAIT_TIMEOUT)
  {
    // If the wait timed out, this thread is likely still on the waiters list
    // of the condition. However, there is a race in that the thread may have been
    // signaled or broadcast between when WaitForSingleObject decided
    // we had timed out and this code running.

    bool mustConsumeSemaphore = false;
    {
      ScopedLock lock2(real_cond.lock);

      bool chosen_by_signal = this_wait.chosen_by_signal;
      bool chosen_by_broadcast = my_generation != real_cond.broadcast_generation;

      if (chosen_by_signal || chosen_by_broadcast)
        mustConsumeSemaphore = true;
      else
      {
        // Still on waiters list. Remove this waiter from list.
        if (this_wait.next != NULL)
          this_wait.next->prev = this_wait.prev;
        else
          real_cond.tail_waiter = this_wait.prev;

        if (this_wait.prev != NULL)
          this_wait.prev->next = this_wait.next;
        else
          real_cond.head_waiter = this_wait.next;
      }
    }

    if (mustConsumeSemaphore)
    {
      ::WaitForSingleObject(semaphore, INFINITE);
      result = WAIT_OBJECT_0;
    }
  }
  else
    DNG_ASSERT (result == WAIT_OBJECT_0, "pthread emulation logic error");

  // reacquire the mutex
  real_mutex.Lock();

  return (result == WAIT_TIMEOUT) ? DNG_ETIMEDOUT : 0;
}

/*****************************************************************************/

int dng_pthread_cond_wait(dng_pthread_cond_t *cond, dng_pthread_mutex_t *mutex)
{
  ValidateCond(cond);

  return cond_wait_internal(cond, mutex, INFINITE); 
}

/*****************************************************************************/

int dng_pthread_cond_timedwait(dng_pthread_cond_t *cond, dng_pthread_mutex_t *mutex, struct dng_timespec *latest_time)
{
  ValidateCond(cond);
  
  struct dng_timespec sys_timespec;
  
  dng_pthread_now (&sys_timespec);

  __int64 sys_time  = (__int64)sys_timespec.tv_sec * 1000000000 + sys_timespec.tv_nsec;
  __int64 lock_time = (__int64)latest_time->tv_sec * 1000000000 + latest_time->tv_nsec;

  int wait_millisecs = (int)((lock_time - sys_time + 500000) / 1000000);
  
  if (wait_millisecs < 0)
    wait_millisecs = 0;

  return cond_wait_internal(cond, mutex, wait_millisecs); 
}

/*****************************************************************************/

int dng_pthread_cond_signal(dng_pthread_cond_t *cond)
{
  ValidateCond(cond);

  waiter *first;
  dng_pthread_cond_impl &real_cond = **cond;

  {
    ScopedLock lock(real_cond.lock);

    first = real_cond.head_waiter;
    if (first != NULL)
    {
      if (first->next != NULL)
        first->next->prev = NULL;
      else
        real_cond.tail_waiter = NULL; // Or first->prev, which is always NULL in this case

      first->chosen_by_signal = true;

      real_cond.head_waiter = first->next;
    }
  }

  if (first != NULL)
    ::ReleaseSemaphore(first->semaphore, 1, NULL);

  return 0;
}

/*****************************************************************************/

int dng_pthread_cond_broadcast(dng_pthread_cond_t *cond)
{
  ValidateCond(cond);

  waiter *first;
  dng_pthread_cond_impl &real_cond = **cond;

  {
    ScopedLock lock(real_cond.lock);

    first = real_cond.head_waiter;
    real_cond.head_waiter = NULL;
    real_cond.tail_waiter = NULL;

    real_cond.broadcast_generation++;
  }

  while (first != NULL)
  {
    waiter *next = first->next;
    ::ReleaseSemaphore(first->semaphore, 1, NULL);
    first = next;
  }

  return 0;
}

/*****************************************************************************/

int dng_pthread_once(dng_pthread_once_t *once, void (*init_func)())
{
  if (once == NULL || init_func == NULL)
    return EINVAL;

  if (once->inited)
    return 0;

  if (::InterlockedIncrement(&once->semaphore) == 0)
  {
    init_func();
    once->inited = 1;
  }
  else
  {
    while (!once->inited)
      Sleep(0);
  }

  return 0;
}

/*****************************************************************************/

int dng_pthread_key_create(dng_pthread_key_t * key, void (*destructor) (void *))
{
  if (destructor != NULL)
    return -1;

  DWORD result = ::TlsAlloc();
  if (result == TLS_OUT_OF_INDEXES)
    return -1;
  *key = (unsigned long)result;
  return 0;
}

/*****************************************************************************/

int dng_pthread_key_delete(dng_pthread_key_t key)
{
  if (::TlsFree((DWORD)key))
    return 0;
  return -1;
}

/*****************************************************************************/

int dng_pthread_setspecific(dng_pthread_key_t key, const void *value)
{
  if (::TlsSetValue((DWORD)key, const_cast<void *>(value)))
    return 0;
  return -1;
}

/*****************************************************************************/

void *dng_pthread_getspecific(dng_pthread_key_t key)
{
  return ::TlsGetValue((DWORD)key);
}

/*****************************************************************************/

namespace {
  struct rw_waiter {
    struct rw_waiter *prev;
    struct rw_waiter *next;
    HANDLE semaphore;
    bool is_writer;
  };
}

struct dng_pthread_rwlock_impl
{
  dng_pthread_mutex_impl mutex;
  
  rw_waiter *head_waiter;
  rw_waiter *tail_waiter;
  
  unsigned long readers_active;
  unsigned long writers_waiting;
  bool writer_active;

  dng_pthread_cond_impl read_wait;
  dng_pthread_cond_impl write_wait;

  dng_pthread_rwlock_impl ()
    : mutex ()
    , head_waiter (NULL)
    , tail_waiter (NULL)
    , readers_active (0)
    , writers_waiting (0)
    , read_wait ()
    , write_wait ()
    , writer_active (false)
  {
  }

  ~dng_pthread_rwlock_impl ()
  {
  }

  void WakeHeadWaiter ()
  {
    HANDLE semaphore = head_waiter->semaphore;

    head_waiter = head_waiter->next;
    if (head_waiter == NULL)
      tail_waiter = NULL;

    ::ReleaseSemaphore(semaphore, 1, NULL);
  }

};

/*****************************************************************************/

int dng_pthread_rwlock_init(dng_pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attrs)
{
  dng_pthread_rwlock_impl *newRWLock;

  newRWLock = new (std::nothrow) dng_pthread_rwlock_impl;
  if (newRWLock == NULL)
    return -1; // ENOMEM;

  *rwlock = newRWLock;

  return 0;
}

/*****************************************************************************/

int dng_pthread_rwlock_destroy(dng_pthread_rwlock_t *rwlock)
{
  dng_pthread_rwlock_impl &real_rwlock = **rwlock;

  {
    ScopedLock lock (real_rwlock.mutex);

    if (real_rwlock.head_waiter != NULL ||
      real_rwlock.readers_active != 0 ||
      real_rwlock.writers_waiting != 0 ||
      real_rwlock.writer_active)
      return -1; // EBUSY
  }

  delete *rwlock;
  *rwlock = NULL;
  return 0;
}

/*****************************************************************************/

#define CHECK_RWLOCK_STATE(real_rwlock) \
  DNG_ASSERT (!real_rwlock.writer_active || real_rwlock.readers_active == 0, "dng_pthread_rwlock_t logic error")

/*****************************************************************************/

int dng_pthread_rwlock_rdlock(dng_pthread_rwlock_t *rwlock)
{
  dng_pthread_rwlock_impl &real_rwlock = **rwlock;

  struct rw_waiter this_wait;
  bool doWait = false;;
  int result = 0;
  HANDLE semaphore=NULL;

    {

    ScopedLock lock (real_rwlock.mutex);

    CHECK_RWLOCK_STATE (real_rwlock);

    if (real_rwlock.writers_waiting > 0 || real_rwlock.writer_active)
    {
      semaphore = GetThreadSemaphore();

      this_wait.next = NULL;
      this_wait.semaphore = semaphore;
      this_wait.is_writer = false;

      // Add this waiter to the end of the list.
      this_wait.prev = real_rwlock.tail_waiter;
      if (real_rwlock.tail_waiter != NULL)
        real_rwlock.tail_waiter->next = &this_wait;
      real_rwlock.tail_waiter = &this_wait;

      // If the list was empty, set the head of the list to this waiter.
      if (real_rwlock.head_waiter == NULL)
        real_rwlock.head_waiter = &this_wait;

      doWait = true;
    }
    else
      real_rwlock.readers_active++;
  }

  if (result == 0 && doWait)
    result = (WaitForSingleObject(semaphore, INFINITE) == WAIT_OBJECT_0) ? 0 : -1;

  return result;
}

/*****************************************************************************/

int dng_pthread_rwlock_tryrdlock(dng_pthread_rwlock_t *rwlock)
{
  dng_pthread_rwlock_impl &real_rwlock = **rwlock;

  ScopedLock lock (real_rwlock.mutex);

  CHECK_RWLOCK_STATE (real_rwlock);

  if (real_rwlock.writers_waiting == 0 && !real_rwlock.writer_active)
  {
    real_rwlock.readers_active++;
    return 0;
  }

  return -1;
}

/*****************************************************************************/

int dng_pthread_rwlock_trywrlock(dng_pthread_rwlock_t *rwlock)
{
  dng_pthread_rwlock_impl &real_rwlock = **rwlock;

  ScopedLock lock (real_rwlock.mutex);

  CHECK_RWLOCK_STATE (real_rwlock);

  if (real_rwlock.readers_active == 0 &&
    real_rwlock.writers_waiting == 0 &&
    !real_rwlock.writer_active)
    {
    real_rwlock.writer_active = true;
    return 0;
    }

  return -1;
}

/*****************************************************************************/

int dng_pthread_rwlock_unlock(dng_pthread_rwlock_t *rwlock)
  {
  dng_pthread_rwlock_impl &real_rwlock = **rwlock;

  int result = 0;

  ScopedLock lock (real_rwlock.mutex);

  CHECK_RWLOCK_STATE (real_rwlock);

  if (real_rwlock.readers_active > 0)
    --real_rwlock.readers_active;
  else
    real_rwlock.writer_active = false;

  while (real_rwlock.head_waiter != NULL)
  {
    if (real_rwlock.head_waiter->is_writer)
    {
      if (real_rwlock.readers_active == 0)
      {
          real_rwlock.writers_waiting--;
          real_rwlock.writer_active = true;
          real_rwlock.WakeHeadWaiter ();
      }

      break;
    }
    else
    {
      ++real_rwlock.readers_active;
      real_rwlock.WakeHeadWaiter ();
    }
  }

  return result;
  }

/*****************************************************************************/

int dng_pthread_rwlock_wrlock(dng_pthread_rwlock_t *rwlock)
  {
  dng_pthread_rwlock_impl &real_rwlock = **rwlock;

  int result = 0;
  struct rw_waiter this_wait;
  HANDLE semaphore=NULL;
  bool doWait = false;

  {
    ScopedLock lock (real_rwlock.mutex);

    CHECK_RWLOCK_STATE (real_rwlock);

    if (real_rwlock.readers_active ||
      real_rwlock.writers_waiting ||
      real_rwlock.writer_active)
      {
      semaphore = GetThreadSemaphore();

      this_wait.next = NULL;
      this_wait.semaphore = semaphore;
      this_wait.is_writer = true;

      // Add this waiter to the end of the list.
      this_wait.prev = real_rwlock.tail_waiter;
      if (real_rwlock.tail_waiter != NULL)
        real_rwlock.tail_waiter->next = &this_wait;
      real_rwlock.tail_waiter = &this_wait;

      // If the list was empty, set the head of the list to this waiter.
      if (real_rwlock.head_waiter == NULL)
        real_rwlock.head_waiter = &this_wait;

      real_rwlock.writers_waiting++;

      doWait = true;
    }
    else
      real_rwlock.writer_active = true;
  }

  if (result == 0 && doWait)
    result = (WaitForSingleObject(semaphore, INFINITE) == WAIT_OBJECT_0) ? 0 : -1;

  return result;
  }

/*****************************************************************************/

void dng_pthread_disassociate()
{
  FreeThreadSemaphore();
}

void dng_pthread_terminate()
  {
  finalize_thread_TLS();
  }

/*****************************************************************************/

} // extern "C"

/*****************************************************************************/

#endif

/*****************************************************************************/

int dng_pthread_now (struct timespec *now)
  {
  
  if (now == NULL)
    return -1; // EINVAL
    
  #if qWinOS

  FILETIME ft;
  ::GetSystemTimeAsFileTime(&ft);

  __int64 sys_time = ((__int64)ft.dwHighDateTime << 32) + ft.dwLowDateTime;

  #define SecsFrom1601To1970 11644473600
  
  sys_time -= SecsFrom1601To1970 * 10000000LL;
  
  sys_time *= 100;  // Convert from 100ns to 1ns units

  now->tv_sec  = (long)(sys_time / 1000000000);
  now->tv_nsec = (long)(sys_time % 1000000000);
  
  #else
  
  struct timeval tv;

  if (gettimeofday (&tv, NULL) != 0)
    return errno;

  now->tv_sec  = tv.tv_sec;
  now->tv_nsec = tv.tv_usec * 1000;

  #endif

  return 0;
  
  }

/*****************************************************************************/

#endif // qDNGThreadSafe

/*****************************************************************************/

Coverage Report

Created: 2025-07-12 06:56