1 /*

     2  * Copyright (C) 2007, 2008, 2010 Apple Inc. All rights reserved.

     3  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)

     4  *

     5  * Redistribution and use in source and binary forms, with or without

     6  * modification, are permitted provided that the following conditions

     7  * are met:

     8  *

     9  * 1.  Redistributions of source code must retain the above copyright

    10  *     notice, this list of conditions and the following disclaimer. 

    11  * 2.  Redistributions in binary form must reproduce the above copyright

    12  *     notice, this list of conditions and the following disclaimer in the

    13  *     documentation and/or other materials provided with the distribution. 

    14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

    15  *     its contributors may be used to endorse or promote products derived

    16  *     from this software without specific prior written permission. 

    17  *

    18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

    19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    28  *

    29  */

    30 

    31 #ifndef ThreadingPrimitives_h

    32 #define ThreadingPrimitives_h

    33 

    34 #include "Platform.h"

    35 

    36 #include <wtf/Assertions.h>

    37 #include <wtf/Locker.h>

    38 #include <wtf/Noncopyable.h>

    39 

    40 #if OS(WINDOWS)

    41 #include <windows.h>

    42 #endif

    43 

    44 #if USE(PTHREADS)

    45 #include <pthread.h>

    46 #elif PLATFORM(GTK)

    47 #include "GOwnPtr.h"

    48 typedef struct _GMutex GMutex;

    49 typedef struct _GCond GCond;

    50 #endif

    51 

    52 #if PLATFORM(QT)

    53 #include <qglobal.h>

    54 QT_BEGIN_NAMESPACE

    55 class QMutex;

    56 class QWaitCondition;

    57 QT_END_NAMESPACE

    58 #endif

    59 

    60 namespace WTF {

    61 

    62 #if USE(PTHREADS)

    63 typedef pthread_mutex_t PlatformMutex;

    64 #if HAVE(PTHREAD_RWLOCK)

    65 typedef pthread_rwlock_t PlatformReadWriteLock;

    66 #else

    67 typedef void* PlatformReadWriteLock;

    68 #endif

    69 typedef pthread_cond_t PlatformCondition;

    70 #elif PLATFORM(GTK)

    71 typedef GOwnPtr<GMutex> PlatformMutex;

    72 typedef void* PlatformReadWriteLock; // FIXME: Implement.

    73 typedef GOwnPtr<GCond> PlatformCondition;

    74 #elif PLATFORM(QT)

    75 typedef QT_PREPEND_NAMESPACE(QMutex)* PlatformMutex;

    76 typedef void* PlatformReadWriteLock; // FIXME: Implement.

    77 typedef QT_PREPEND_NAMESPACE(QWaitCondition)* PlatformCondition;

    78 #elif OS(WINDOWS)

    79 struct PlatformMutex {

    80     CRITICAL_SECTION m_internalMutex;

    81     size_t m_recursionCount;

    82 };

    83 typedef void* PlatformReadWriteLock; // FIXME: Implement.

    84 struct PlatformCondition {

    85     size_t m_waitersGone;

    86     size_t m_waitersBlocked;

    87     size_t m_waitersToUnblock; 

    88     HANDLE m_blockLock;

    89     HANDLE m_blockQueue;

    90     HANDLE m_unblockLock;

    91 

    92     bool timedWait(PlatformMutex&, DWORD durationMilliseconds);

    93     void signal(bool unblockAll);

    94 };

    95 #else

    96 typedef void* PlatformMutex;

    97 typedef void* PlatformReadWriteLock;

    98 typedef void* PlatformCondition;

    99 #endif

   100     

   101 class Mutex : public Noncopyable {

   102 public:

   103     Mutex();

   104     ~Mutex();

   105 

   106     void lock();

   107     bool tryLock();

   108     void unlock();

   109 

   110 public:

   111     PlatformMutex& impl() { return m_mutex; }

   112 private:

   113     PlatformMutex m_mutex;

   114 };

   115 

   116 typedef Locker<Mutex> MutexLocker;

   117 

   118 class ReadWriteLock : public Noncopyable {

   119 public:

   120     ReadWriteLock();

   121     ~ReadWriteLock();

   122 

   123     void readLock();

   124     bool tryReadLock();

   125 

   126     void writeLock();

   127     bool tryWriteLock();

   128     

   129     void unlock();

   130 

   131 private:

   132     PlatformReadWriteLock m_readWriteLock;

   133 };

   134 

   135 class ThreadCondition : public Noncopyable {

   136 public:

   137     ThreadCondition();

   138     ~ThreadCondition();

   139     

   140     void wait(Mutex& mutex);

   141     // Returns true if the condition was signaled before absoluteTime, false if the absoluteTime was reached or is in the past.

   142     // The absoluteTime is in seconds, starting on January 1, 1970. The time is assumed to use the same time zone as WTF::currentTime().

   143     bool timedWait(Mutex&, double absoluteTime);

   144     void signal();

   145     void broadcast();

   146     

   147 private:

   148     PlatformCondition m_condition;

   149 };

   150 

   151 } // namespace WTF

   152 

   153 using WTF::Mutex;

   154 using WTF::MutexLocker;

   155 using WTF::ThreadCondition;

   156 

   157 #endif // ThreadingPrimitives_h