noderb 0.0.4 → 0.0.6

data/ext/noderb_extension/libuv/deps/pthread-win32/ptw32_MCS_lock.c

@@ -1,278 +0,0 @@
-/*
- * ptw32_MCS_lock.c
- *
- * Description:
- * This translation unit implements queue-based locks.
- *
- * --------------------------------------------------------------------------
- *
- *      Pthreads-win32 - POSIX Threads Library for Win32
- *      Copyright(C) 1998 John E. Bossom
- *      Copyright(C) 1999,2005 Pthreads-win32 contributors
- * 
- *      Contact Email: rpj@callisto.canberra.edu.au
- * 
- *      The current list of contributors is contained
- *      in the file CONTRIBUTORS included with the source
- *      code distribution. The list can also be seen at the
- *      following World Wide Web location:
- *      http://sources.redhat.com/pthreads-win32/contributors.html
- * 
- *      This library is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU Lesser General Public
- *      License as published by the Free Software Foundation; either
- *      version 2 of the License, or (at your option) any later version.
- * 
- *      This library is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *      Lesser General Public License for more details.
- * 
- *      You should have received a copy of the GNU Lesser General Public
- *      License along with this library in the file COPYING.LIB;
- *      if not, write to the Free Software Foundation, Inc.,
- *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-/*
- * About MCS locks:
- *
- * MCS locks are queue-based locks, where the queue nodes are local to the
- * thread. The 'lock' is nothing more than a global pointer that points to
- * the last node in the queue, or is NULL if the queue is empty.
- * 
- * Originally designed for use as spin locks requiring no kernel resources
- * for synchronisation or blocking, the implementation below has adapted
- * the MCS spin lock for use as a general mutex that will suspend threads
- * when there is lock contention.
- *
- * Because the queue nodes are thread-local, most of the memory read/write
- * operations required to add or remove nodes from the queue do not trigger
- * cache-coherence updates.
- *
- * Like 'named' mutexes, MCS locks consume system resources transiently -
- * they are able to acquire and free resources automatically - but MCS
- * locks do not require any unique 'name' to identify the lock to all
- * threads using it.
- *
- * Usage of MCS locks:
- *
- * - you need a global ptw32_mcs_lock_t instance initialised to 0 or NULL.
- * - you need a local thread-scope ptw32_mcs_local_node_t instance, which
- *   may serve several different locks but you need at least one node for
- *   every lock held concurrently by a thread.
- *
- * E.g.:
- * 
- * ptw32_mcs_lock_t lock1 = 0;
- * ptw32_mcs_lock_t lock2 = 0;
- *
- * void *mythread(void *arg)
- * {
- *   ptw32_mcs_local_node_t node;
- *
- *   ptw32_mcs_acquire (&lock1, &node);
- *   ptw32_mcs_lock_release (&node);
- *
- *   ptw32_mcs_lock_acquire (&lock2, &node);
- *   ptw32_mcs_lock_release (&node);
- *   {
- *      ptw32_mcs_local_node_t nodex;
- *
- *      ptw32_mcs_lock_acquire (&lock1, &node);
- *      ptw32_mcs_lock_acquire (&lock2, &nodex);
- *
- *      ptw32_mcs_lock_release (&nodex);
- *      ptw32_mcs_lock_release (&node);
- *   }
- *   return (void *)0;
- * }
- */
-
-#include "pthread.h"
-#include "sched.h"
-#include "implement.h"
-
-/*
- * ptw32_mcs_flag_set -- notify another thread about an event.
- * 
- * Set event if an event handle has been stored in the flag, and
- * set flag to -1 otherwise. Note that -1 cannot be a valid handle value.
- */
-INLINE void 
-ptw32_mcs_flag_set (HANDLE * flag)
-{
-  HANDLE e = (HANDLE)(PTW32_INTERLOCKED_SIZE)PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE(
-						(PTW32_INTERLOCKED_SIZEPTR)flag,
-						(PTW32_INTERLOCKED_SIZE)-1,
-						(PTW32_INTERLOCKED_SIZE)0);
-  if ((HANDLE)0 != e)
-    {
-      /* another thread has already stored an event handle in the flag */
-      SetEvent(e);
-    }
-}
-
-/*
- * ptw32_mcs_flag_set -- wait for notification from another.
- * 
- * Store an event handle in the flag and wait on it if the flag has not been
- * set, and proceed without creating an event otherwise.
- */
-INLINE void 
-ptw32_mcs_flag_wait (HANDLE * flag)
-{
-  if ((PTW32_INTERLOCKED_LONG)0 ==
-        PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE((PTW32_INTERLOCKED_SIZEPTR)flag,
-                                            (PTW32_INTERLOCKED_SIZE)0)) /* MBR fence */
-    {
-      /* the flag is not set. create event. */
-
-      HANDLE e = CreateEvent(NULL, PTW32_FALSE, PTW32_FALSE, NULL);
-
-      if ((PTW32_INTERLOCKED_SIZE)0 == PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE(
-			                  (PTW32_INTERLOCKED_SIZEPTR)flag,
-			                  (PTW32_INTERLOCKED_SIZE)e,
-			                  (PTW32_INTERLOCKED_SIZE)0))
-	{
-	  /* stored handle in the flag. wait on it now. */
-	  WaitForSingleObject(e, INFINITE);
-	}
-
-      CloseHandle(e);
-    }
-}
-
-/*
- * ptw32_mcs_lock_acquire -- acquire an MCS lock.
- * 
- * See: 
- * J. M. Mellor-Crummey and M. L. Scott.
- * Algorithms for Scalable Synchronization on Shared-Memory Multiprocessors.
- * ACM Transactions on Computer Systems, 9(1):21-65, Feb. 1991.
- */
-#if defined(PTW32_BUILD_INLINED)
-INLINE 
-#endif /* PTW32_BUILD_INLINED */
-void 
-ptw32_mcs_lock_acquire (ptw32_mcs_lock_t * lock, ptw32_mcs_local_node_t * node)
-{
-  ptw32_mcs_local_node_t  *pred;
-  
-  node->lock = lock;
-  node->nextFlag = 0;
-  node->readyFlag = 0;
-  node->next = 0; /* initially, no successor */
-  
-  /* queue for the lock */
-  pred = (ptw32_mcs_local_node_t *)PTW32_INTERLOCKED_EXCHANGE_PTR((PTW32_INTERLOCKED_PVOID_PTR)lock,
-								  (PTW32_INTERLOCKED_PVOID)node);
-
-  if (0 != pred)
-    {
-      /* the lock was not free. link behind predecessor. */
-      pred->next = node;
-      ptw32_mcs_flag_set(&pred->nextFlag);
-      ptw32_mcs_flag_wait(&node->readyFlag);
-    }
-}
-
-/*
- * ptw32_mcs_lock_release -- release an MCS lock.
- * 
- * See: 
- * J. M. Mellor-Crummey and M. L. Scott.
- * Algorithms for Scalable Synchronization on Shared-Memory Multiprocessors.
- * ACM Transactions on Computer Systems, 9(1):21-65, Feb. 1991.
- */
-#if defined(PTW32_BUILD_INLINED)
-INLINE 
-#endif /* PTW32_BUILD_INLINED */
-void 
-ptw32_mcs_lock_release (ptw32_mcs_local_node_t * node)
-{
-  ptw32_mcs_lock_t *lock = node->lock;
-  ptw32_mcs_local_node_t *next =
-    (ptw32_mcs_local_node_t *)
-      PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE((PTW32_INTERLOCKED_SIZEPTR)&node->next, (PTW32_INTERLOCKED_SIZE)0); /* MBR fence */
-
-  if (0 == next)
-    {
-      /* no known successor */
-
-      if (node == (ptw32_mcs_local_node_t *)
-	  PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR((PTW32_INTERLOCKED_PVOID_PTR)lock,
-						 (PTW32_INTERLOCKED_PVOID)0,
-						 (PTW32_INTERLOCKED_PVOID)node))
-	{
-	  /* no successor, lock is free now */
-	  return;
-	}
-  
-      /* wait for successor */
-      ptw32_mcs_flag_wait(&node->nextFlag);
-      next = (ptw32_mcs_local_node_t *)
-	PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE((PTW32_INTERLOCKED_SIZEPTR)&node->next, (PTW32_INTERLOCKED_SIZE)0); /* MBR fence */
-    }
-
-  /* pass the lock */
-  ptw32_mcs_flag_set(&next->readyFlag);
-}
-
-/*
-  * ptw32_mcs_lock_try_acquire
- */
-#if defined(PTW32_BUILD_INLINED)
-INLINE 
-#endif /* PTW32_BUILD_INLINED */
-int 
-ptw32_mcs_lock_try_acquire (ptw32_mcs_lock_t * lock, ptw32_mcs_local_node_t * node)
-{
-  node->lock = lock;
-  node->nextFlag = 0;
-  node->readyFlag = 0;
-  node->next = 0; /* initially, no successor */
-
-  return ((PTW32_INTERLOCKED_PVOID)PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR((PTW32_INTERLOCKED_PVOID_PTR)lock,
-                                                        (PTW32_INTERLOCKED_PVOID)node,
-                                                        (PTW32_INTERLOCKED_PVOID)0)
-                                 == (PTW32_INTERLOCKED_PVOID)0) ? 0 : EBUSY;
-}
-
-/*
- * ptw32_mcs_node_transfer -- move an MCS lock local node, usually from thread
- * space to, for example, global space so that another thread can release
- * the lock on behalf of the current lock owner.
- *
- * Example: used in pthread_barrier_wait where we want the last thread out of
- * the barrier to release the lock owned by the last thread to enter the barrier
- * (the one that releases all threads but not necessarily the last to leave).
- *
- * Should only be called by the thread that has the lock.
- */
-#if defined(PTW32_BUILD_INLINED)
-INLINE 
-#endif /* PTW32_BUILD_INLINED */
-void 
-ptw32_mcs_node_transfer (ptw32_mcs_local_node_t * new_node, ptw32_mcs_local_node_t * old_node)
-{
-  new_node->lock = old_node->lock;
-  new_node->nextFlag = 0; /* Not needed - used only in initial Acquire */
-  new_node->readyFlag = 0; /* Not needed - we were waiting on this */
-  new_node->next = 0;
-
-  if ((ptw32_mcs_local_node_t *)PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR((PTW32_INTERLOCKED_PVOID_PTR)new_node->lock,
-                                                                       (PTW32_INTERLOCKED_PVOID)new_node,
-                                                                       (PTW32_INTERLOCKED_PVOID)old_node)
-       != old_node)
-    {
-      /*
-       * A successor has queued after us, so wait for them to link to us
-       */
-      while (old_node->next == 0)
-        {
-          sched_yield();
-        }
-      new_node->next = old_node->next;
-    }
-}

data/ext/noderb_extension/libuv/deps/pthread-win32/ptw32_callUserDestroyRoutines.c

@@ -1,232 +0,0 @@
-/*
- * ptw32_callUserDestroyRoutines.c
- *
- * Description:
- * This translation unit implements routines which are private to
- * the implementation and may be used throughout it.
- *
- * --------------------------------------------------------------------------
- *
- *      Pthreads-win32 - POSIX Threads Library for Win32
- *      Copyright(C) 1998 John E. Bossom
- *      Copyright(C) 1999,2005 Pthreads-win32 contributors
- * 
- *      Contact Email: rpj@callisto.canberra.edu.au
- * 
- *      The current list of contributors is contained
- *      in the file CONTRIBUTORS included with the source
- *      code distribution. The list can also be seen at the
- *      following World Wide Web location:
- *      http://sources.redhat.com/pthreads-win32/contributors.html
- * 
- *      This library is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU Lesser General Public
- *      License as published by the Free Software Foundation; either
- *      version 2 of the License, or (at your option) any later version.
- * 
- *      This library is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *      Lesser General Public License for more details.
- * 
- *      You should have received a copy of the GNU Lesser General Public
- *      License along with this library in the file COPYING.LIB;
- *      if not, write to the Free Software Foundation, Inc.,
- *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include "pthread.h"
-#include "implement.h"
-
-#if defined(__CLEANUP_CXX)
-# if defined(_MSC_VER)
-#  include <eh.h>
-# elif defined(__WATCOMC__)
-#  include <eh.h>
-#  include <exceptio.h>
-# else
-#  if defined(__GNUC__) && __GNUC__ < 3
-#    include <new.h>
-#  else
-#    include <new>
-     using
-       std::terminate;
-#  endif
-# endif
-#endif
-
-void
-ptw32_callUserDestroyRoutines (pthread_t thread)
-     /*
-      * -------------------------------------------------------------------
-      * DOCPRIVATE
-      *
-      * This the routine runs through all thread keys and calls
-      * the destroy routines on the user's data for the current thread.
-      * It simulates the behaviour of POSIX Threads.
-      *
-      * PARAMETERS
-      *              thread
-      *                      an instance of pthread_t
-      *
-      * RETURNS
-      *              N/A
-      * -------------------------------------------------------------------
-      */
-{
-  ThreadKeyAssoc * assoc;
-
-  if (thread.p != NULL)
-    {
-      ptw32_mcs_local_node_t threadLock;
-      ptw32_mcs_local_node_t keyLock;
-      int assocsRemaining;
-      int iterations = 0;
-      ptw32_thread_t * sp = (ptw32_thread_t *) thread.p;
-
-      /*
-       * Run through all Thread<-->Key associations
-       * for the current thread.
-       *
-       * Do this process at most PTHREAD_DESTRUCTOR_ITERATIONS times.
-       */
-      do
-	{
-	  assocsRemaining = 0;
-	  iterations++;
-
-	  ptw32_mcs_lock_acquire(&(sp->threadLock), &threadLock);
-	  /*
-	   * The pointer to the next assoc is stored in the thread struct so that
-	   * the assoc destructor in pthread_key_delete can adjust it
-	   * if it deletes this assoc. This can happen if we fail to acquire
-	   * both locks below, and are forced to release all of our locks,
-	   * leaving open the opportunity for pthread_key_delete to get in
-	   * before us.
-	   */
-	  sp->nextAssoc = sp->keys;
-	  ptw32_mcs_lock_release(&threadLock);
-
-	  for (;;)
-	    {
-	      void * value;
-	      pthread_key_t k;
-	      void (*destructor) (void *);
-
-	      /*
-	       * First we need to serialise with pthread_key_delete by locking
-	       * both assoc guards, but in the reverse order to our convention,
-	       * so we must be careful to avoid deadlock.
-	       */
-	      ptw32_mcs_lock_acquire(&(sp->threadLock), &threadLock);
-
-	      if ((assoc = (ThreadKeyAssoc *)sp->nextAssoc) == NULL)
-		{
-		  /* Finished */
-		  ptw32_mcs_lock_release(&threadLock);
-		  break;
-		}
-	      else
-		{
-		  /*
-		   * assoc->key must be valid because assoc can't change or be
-		   * removed from our chain while we hold at least one lock. If
-		   * the assoc was on our key chain then the key has not been
-		   * deleted yet.
-		   *
-		   * Now try to acquire the second lock without deadlocking.
-		   * If we fail, we need to relinquish the first lock and the
-		   * processor and then try to acquire them all again.
-		   */
-		  if (ptw32_mcs_lock_try_acquire(&(assoc->key->keyLock), &keyLock) == EBUSY)
-		    {
-		      ptw32_mcs_lock_release(&threadLock);
-		      Sleep(0);
-		      /*
-		       * Go around again.
-		       * If pthread_key_delete has removed this assoc in the meantime,
-		       * sp->nextAssoc will point to a new assoc.
-		       */
-		      continue;
-		    }
-		}
-
-	      /* We now hold both locks */
-
-	      sp->nextAssoc = assoc->nextKey;
-
-	      /*
-	       * Key still active; pthread_key_delete
-	       * will block on these same mutexes before
-	       * it can release actual key; therefore,
-	       * key is valid and we can call the destroy
-	       * routine;
-	       */
-	      k = assoc->key;
-	      destructor = k->destructor;
-	      value = TlsGetValue(k->key);
-	      TlsSetValue (k->key, NULL);
-
-	      // Every assoc->key exists and has a destructor
-	      if (value != NULL && iterations <= PTHREAD_DESTRUCTOR_ITERATIONS)
-		{
-		  /*
-		   * Unlock both locks before the destructor runs.
-		   * POSIX says pthread_key_delete can be run from destructors,
-		   * and that probably includes with this key as target.
-		   * pthread_setspecific can also be run from destructors and
-		   * also needs to be able to access the assocs.
-		   */
-		  ptw32_mcs_lock_release(&threadLock);
-		  ptw32_mcs_lock_release(&keyLock);
-
-		  assocsRemaining++;
-
-#if defined(__cplusplus)
-
-		  try
-		    {
-		      /*
-		       * Run the caller's cleanup routine.
-		       */
-		      destructor (value);
-		    }
-		  catch (...)
-		    {
-		      /*
-		       * A system unexpected exception has occurred
-		       * running the user's destructor.
-		       * We get control back within this block in case
-		       * the application has set up it's own terminate
-		       * handler. Since we are leaving the thread we
-		       * should not get any internal pthreads
-		       * exceptions.
-		       */
-		      terminate ();
-		    }
-
-#else /* __cplusplus */
-
-		  /*
-		   * Run the caller's cleanup routine.
-		   */
-		  destructor (value);
-
-#endif /* __cplusplus */
-
-		}
-	      else
-		{
-		  /*
-		   * Remove association from both the key and thread chains
-		   * and reclaim it's memory resources.
-		   */
-		  ptw32_tkAssocDestroy (assoc);
-		  ptw32_mcs_lock_release(&threadLock);
-		  ptw32_mcs_lock_release(&keyLock);
-		}
-	    }
-	}
-      while (assocsRemaining);
-    }
-}				/* ptw32_callUserDestroyRoutines */

data/ext/noderb_extension/libuv/deps/pthread-win32/ptw32_calloc.c

@@ -1,56 +0,0 @@
-/*
- * ptw32_calloc.c
- *
- * Description:
- * This translation unit implements miscellaneous thread functions.
- *
- * --------------------------------------------------------------------------
- *
- *      Pthreads-win32 - POSIX Threads Library for Win32
- *      Copyright(C) 1998 John E. Bossom
- *      Copyright(C) 1999,2005 Pthreads-win32 contributors
- * 
- *      Contact Email: rpj@callisto.canberra.edu.au
- * 
- *      The current list of contributors is contained
- *      in the file CONTRIBUTORS included with the source
- *      code distribution. The list can also be seen at the
- *      following World Wide Web location:
- *      http://sources.redhat.com/pthreads-win32/contributors.html
- * 
- *      This library is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU Lesser General Public
- *      License as published by the Free Software Foundation; either
- *      version 2 of the License, or (at your option) any later version.
- * 
- *      This library is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *      Lesser General Public License for more details.
- * 
- *      You should have received a copy of the GNU Lesser General Public
- *      License along with this library in the file COPYING.LIB;
- *      if not, write to the Free Software Foundation, Inc.,
- *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include "pthread.h"
-#include "implement.h"
-
-
-#if defined(NEED_CALLOC)
-void *
-ptw32_calloc (size_t n, size_t s)
-{
-  unsigned int m = n * s;
-  void *p;
-
-  p = malloc (m);
-  if (p == NULL)
-    return NULL;
-
-  memset (p, 0, m);
-
-  return p;
-}
-#endif

data/ext/noderb_extension/libuv/deps/pthread-win32/ptw32_cond_check_need_init.c

@@ -1,78 +0,0 @@
-/*
- * ptw32_cond_check_need_init.c
- *
- * Description:
- * This translation unit implements condition variables and their primitives.
- *
- *
- * --------------------------------------------------------------------------
- *
- *      Pthreads-win32 - POSIX Threads Library for Win32
- *      Copyright(C) 1998 John E. Bossom
- *      Copyright(C) 1999,2005 Pthreads-win32 contributors
- * 
- *      Contact Email: rpj@callisto.canberra.edu.au
- * 
- *      The current list of contributors is contained
- *      in the file CONTRIBUTORS included with the source
- *      code distribution. The list can also be seen at the
- *      following World Wide Web location:
- *      http://sources.redhat.com/pthreads-win32/contributors.html
- * 
- *      This library is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU Lesser General Public
- *      License as published by the Free Software Foundation; either
- *      version 2 of the License, or (at your option) any later version.
- * 
- *      This library is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *      Lesser General Public License for more details.
- * 
- *      You should have received a copy of the GNU Lesser General Public
- *      License along with this library in the file COPYING.LIB;
- *      if not, write to the Free Software Foundation, Inc.,
- *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include "pthread.h"
-#include "implement.h"
-
-
-int
-ptw32_cond_check_need_init (pthread_cond_t * cond)
-{
-  int result = 0;
-  ptw32_mcs_local_node_t node;
-
-  /*
-   * The following guarded test is specifically for statically
-   * initialised condition variables (via PTHREAD_OBJECT_INITIALIZER).
-   */
-  ptw32_mcs_lock_acquire(&ptw32_cond_test_init_lock, &node);
-
-  /*
-   * We got here possibly under race
-   * conditions. Check again inside the critical section.
-   * If a static cv has been destroyed, the application can
-   * re-initialise it only by calling pthread_cond_init()
-   * explicitly.
-   */
-  if (*cond == PTHREAD_COND_INITIALIZER)
-    {
-      result = pthread_cond_init (cond, NULL);
-    }
-  else if (*cond == NULL)
-    {
-      /*
-       * The cv has been destroyed while we were waiting to
-       * initialise it, so the operation that caused the
-       * auto-initialisation should fail.
-       */
-      result = EINVAL;
-    }
-
-  ptw32_mcs_lock_release(&node);
-
-  return result;
-}