Move WaitableEvent

beast/Thread.h

@@ -26,5 +26,6 @@
 #include "thread/SharedLockGuard.h"
 #include "thread/SharedMutexAdapter.h"
 #include "thread/SharedData.h"
+#include "thread/WaitableEvent.h"
 
 #endif

beast/chrono/CPUMeter.h

@@ -21,7 +21,7 @@
 #define BEAST_CHRONO_CPUMETER_H_INCLUDED
 
 #include "RelativeTime.h"
-#include "SCopedTimeInterval.h"
+#include "ScopedTimeInterval.h"
 #include "../thread/SharedData.h"
 #include "../Atomic.h"
 
@@ -120,7 +120,7 @@ private:
         void advance ()
         {
             usage += history [index];
-            index = (++index) % numberOfAggregates;
+            index = (index+1) % numberOfAggregates;
             usage -= history [index];
             history [index].clear ();
         }

beast/thread/Thread.cpp

@@ -20,3 +20,4 @@
 #include "BeastConfig.h"
 
 #include "impl/RecursiveMutex.cpp"
+#include "impl/WaitableEvent.cpp"

beast/thread/WaitableEvent.h

@@ -0,0 +1,124 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Portions of this file are from JUCE.
+    Copyright (c) 2013 - Raw Material Software Ltd.
+    Please visit http://www.juce.com
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef BEAST_WAITABLEEVENT_H_INCLUDED
+#define BEAST_WAITABLEEVENT_H_INCLUDED
+
+#include "../Config.h"
+#include "../Uncopyable.h"
+
+#if ! BEAST_WINDOWS
+#include <pthread.h>
+#endif
+
+namespace beast {
+
+/** Allows threads to wait for events triggered by other threads.
+    A thread can call wait() on a WaitableEvent, and this will suspend the
+    calling thread until another thread wakes it up by calling the signal()
+    method.
+*/
+class WaitableEvent
+    : public Uncopyable
+    //, LeakChecked <WaitableEvent> // VFALCO TODO Move LeakChecked to beast/
+{
+public:
+    //==============================================================================
+    /** Creates a WaitableEvent object.
+
+        @param manualReset  If this is false, the event will be reset automatically when the wait()
+                            method is called. If manualReset is true, then once the event is signalled,
+                            the only way to reset it will be by calling the reset() method.
+
+        @param initiallySignaled If this is true then the event will be signaled when
+                                 the constructor returns.
+    */
+    explicit WaitableEvent (bool manualReset = false, bool initiallySignaled = false);
+
+    /** Destructor.
+
+        If other threads are waiting on this object when it gets deleted, this
+        can cause nasty errors, so be careful!
+    */
+    ~WaitableEvent();
+
+    //==============================================================================
+    /** Suspends the calling thread until the event has been signalled.
+
+        This will wait until the object's signal() method is called by another thread,
+        or until the timeout expires.
+
+        After the event has been signalled, this method will return true and if manualReset
+        was set to false in the WaitableEvent's constructor, then the event will be reset.
+
+        @param timeOutMilliseconds  the maximum time to wait, in milliseconds. A negative
+                                    value will cause it to wait forever.
+
+        @returns    true if the object has been signalled, false if the timeout expires first.
+        @see signal, reset
+    */
+    /** @{ */
+    bool wait () const;                             // wait forever
+    // VFALCO TODO Change wait() to seconds instead of millis
+    bool wait (int timeOutMilliseconds) const; // DEPRECATED
+    /** @} */
+
+    //==============================================================================
+    /** Wakes up any threads that are currently waiting on this object.
+
+        If signal() is called when nothing is waiting, the next thread to call wait()
+        will return immediately and reset the signal.
+
+        If the WaitableEvent is manual reset, all current and future threads that wait upon this
+        object will be woken, until reset() is explicitly called.
+
+        If the WaitableEvent is automatic reset, and one or more threads is waiting upon the object,
+        then one of them will be woken up. If no threads are currently waiting, then the next thread
+        to call wait() will be woken up. As soon as a thread is woken, the signal is automatically
+        reset.
+
+        @see wait, reset
+    */
+    void signal() const;
+
+    //==============================================================================
+    /** Resets the event to an unsignalled state.
+
+        If it's not already signalled, this does nothing.
+    */
+    void reset() const;
+
+private:
+#if BEAST_WINDOWS
+    void* handle;
+#else
+    mutable pthread_cond_t condition;
+    mutable pthread_mutex_t mutex;
+    mutable bool triggered;
+    mutable bool manualReset;
+#endif
+};
+
+}
+
+#endif

beast/thread/impl/WaitableEvent.cpp

@@ -0,0 +1,163 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Portions of this file are from JUCE.
+    Copyright (c) 2013 - Raw Material Software Ltd.
+    Please visit http://www.juce.com
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include "../WaitableEvent.h"
+
+#if BEAST_WINDOWS
+
+#include <Windows.h>
+
+namespace beast {
+
+WaitableEvent::WaitableEvent (const bool manualReset, bool initiallySignaled)
+    : handle (CreateEvent (0, manualReset ? TRUE : FALSE, initiallySignaled ? TRUE : FALSE, 0))
+{
+}
+
+WaitableEvent::~WaitableEvent()
+{
+    CloseHandle (handle);
+}
+
+void WaitableEvent::signal() const
+{
+    SetEvent (handle);
+}
+
+void WaitableEvent::reset() const
+{
+    ResetEvent (handle);
+}
+
+bool WaitableEvent::wait () const
+{
+    return WaitForSingleObject (handle, INFINITE) == WAIT_OBJECT_0;
+}
+
+bool WaitableEvent::wait (const int timeOutMs) const
+{
+    if (timeOutMs >= 0)
+        return WaitForSingleObject (handle,
+            (DWORD) timeOutMs) == WAIT_OBJECT_0;
+    return wait ();
+}
+
+}
+
+#else
+
+namespace beast {
+
+WaitableEvent::WaitableEvent (const bool useManualReset, bool initiallySignaled)
+    : triggered (false), manualReset (useManualReset)
+{
+    pthread_cond_init (&condition, 0);
+
+    pthread_mutexattr_t atts;
+    pthread_mutexattr_init (&atts);
+   #if ! BEAST_ANDROID
+    pthread_mutexattr_setprotocol (&atts, PTHREAD_PRIO_INHERIT);
+   #endif
+    pthread_mutex_init (&mutex, &atts);
+
+    if (initiallySignaled)
+        signal ();
+}
+
+WaitableEvent::~WaitableEvent()
+{
+    pthread_cond_destroy (&condition);
+    pthread_mutex_destroy (&mutex);
+}
+
+bool WaitableEvent::wait () const
+{
+    return wait (-1);
+}
+
+bool WaitableEvent::wait (const int timeOutMillisecs) const
+{
+    pthread_mutex_lock (&mutex);
+
+    if (! triggered)
+    {
+        if (timeOutMillisecs < 0)
+        {
+            do
+            {
+                pthread_cond_wait (&condition, &mutex);
+            }
+            while (! triggered);
+        }
+        else
+        {
+            struct timeval now;
+            gettimeofday (&now, 0);
+
+            struct timespec time;
+            time.tv_sec  = now.tv_sec  + (timeOutMillisecs / 1000);
+            time.tv_nsec = (now.tv_usec + ((timeOutMillisecs % 1000) * 1000)) * 1000;
+
+            if (time.tv_nsec >= 1000000000)
+            {
+                time.tv_nsec -= 1000000000;
+                time.tv_sec++;
+            }
+
+            do
+            {
+                if (pthread_cond_timedwait (&condition, &mutex, &time) == ETIMEDOUT)
+                {
+                    pthread_mutex_unlock (&mutex);
+                    return false;
+                }
+            }
+            while (! triggered);
+        }
+    }
+
+    if (! manualReset)
+        triggered = false;
+
+    pthread_mutex_unlock (&mutex);
+    return true;
+}
+
+void WaitableEvent::signal() const
+{
+    pthread_mutex_lock (&mutex);
+    triggered = true;
+    pthread_cond_broadcast (&condition);
+    pthread_mutex_unlock (&mutex);
+}
+
+void WaitableEvent::reset() const
+{
+    pthread_mutex_lock (&mutex);
+    triggered = false;
+    pthread_mutex_unlock (&mutex);
+}
+
+}
+
+#endif