include/am-thread-windows.h
author David Anderson <dvander@alliedmods.net>
Fri Sep 06 13:54:31 2013 -0700 (2013-09-06)
changeset 18 9b30f80f6e49
parent 0 ba3d4abaf3f1
permissions -rw-r--r--
Eliminate Newborn/NoAddRef (bug 5907, r=ds).
     1 // vim: set sts=8 ts=2 sw=2 tw=99 et:
     2 //
     3 // Copyright (C) 2013, David Anderson and AlliedModders LLC
     4 // All rights reserved.
     5 // 
     6 // Redistribution and use in source and binary forms, with or without
     7 // modification, are permitted provided that the following conditions are met:
     8 // 
     9 //  * Redistributions of source code must retain the above copyright notice, this
    10 //    list of conditions and the following disclaimer.
    11 //  * Redistributions in binary form must reproduce the above copyright notice,
    12 //    this list of conditions and the following disclaimer in the documentation
    13 //    and/or other materials provided with the distribution.
    14 //  * Neither the name of AlliedModders LLC nor the names of its contributors
    15 //    may be used to endorse or promote products derived from this software
    16 //    without specific prior written permission.
    17 //
    18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    19 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    20 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    21 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    22 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    23 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    24 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    25 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    26 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    27 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    28 // POSSIBILITY OF SUCH DAMAGE.
    29 
    30 #ifndef _include_amtl_thread_windows_h_
    31 #define _include_amtl_thread_windows_h_
    32 
    33 #include <windows.h>
    34 
    35 namespace ke {
    36 
    37 class CriticalSection : public Lockable
    38 {
    39  public:
    40   CriticalSection() {
    41     InitializeCriticalSection(&cs_);
    42   }
    43   ~CriticalSection() {
    44     DeleteCriticalSection(&cs_);
    45   }
    46 
    47   bool DoTryLock() KE_OVERRIDE {
    48     return !!TryEnterCriticalSection(&cs_);
    49   }
    50   void DoLock() KE_OVERRIDE {
    51     EnterCriticalSection(&cs_);
    52   }
    53 
    54   void DoUnlock() KE_OVERRIDE {
    55     LeaveCriticalSection(&cs_);
    56   }
    57 
    58  private:
    59   CRITICAL_SECTION cs_;
    60 };
    61 
    62 typedef CriticalSection Mutex;
    63 
    64 // Currently, this class only supports single-listener CVs.
    65 class ConditionVariable : public Lockable
    66 {
    67  public:
    68   ConditionVariable() {
    69     event_ = CreateEvent(NULL, FALSE, FALSE, NULL);
    70   }
    71   ~ConditionVariable() {
    72     CloseHandle(event_);
    73   }
    74 
    75   bool DoTryLock() KE_OVERRIDE {
    76     return cs_.DoTryLock();
    77   }
    78   void DoLock() KE_OVERRIDE {
    79     cs_.DoLock();
    80   }
    81   void DoUnlock() KE_OVERRIDE {
    82     cs_.DoUnlock();
    83   }
    84 
    85   void Notify() {
    86     AssertCurrentThreadOwns();
    87     SetEvent(event_);
    88   }
    89 
    90   WaitResult Wait(size_t timeout_ms) {
    91     // This will assert if the lock has not been acquired. We don't need to be
    92     // atomic here, like pthread_cond_wait, because the event bit will stick
    93     // until reset by a wait function.
    94     Unlock();
    95     DWORD rv = WaitForSingleObject(event_, timeout_ms);
    96     Lock();
    97 
    98     if (rv == WAIT_TIMEOUT)
    99       return Wait_Timeout;
   100     if (rv == WAIT_FAILED)
   101       return Wait_Error;
   102     return Wait_Signaled;
   103   }
   104 
   105   WaitResult Wait() {
   106     return Wait(INFINITE);
   107   }
   108 
   109  private:
   110   CriticalSection cs_;
   111   HANDLE event_;
   112 };
   113 
   114 class Thread
   115 {
   116  public:
   117   Thread(IRunnable *run, const char *name = NULL) {
   118     thread_ = CreateThread(NULL, 0, Main, run, 0, NULL);
   119   }
   120   ~Thread() {
   121     if (!thread_)
   122       return;
   123     CloseHandle(thread_);
   124   }
   125 
   126   bool Succeeded() const {
   127     return !!thread_;
   128   }
   129 
   130   void Join() {
   131     if (!Succeeded())
   132       return;
   133     WaitForSingleObject(thread_, INFINITE);
   134   }
   135 
   136   HANDLE handle() const {
   137 	  return thread_;
   138   }
   139 
   140  private:
   141   static DWORD WINAPI Main(LPVOID arg) {
   142     ((IRunnable *)arg)->Run();
   143     return 0;
   144   }
   145 
   146 #pragma pack(push, 8)
   147   struct ThreadNameInfo {
   148     DWORD dwType;
   149     LPCSTR szName;
   150     DWORD dwThreadID;
   151     DWORD dwFlags;
   152   };
   153 #pragma pack(pop)
   154 
   155  private:
   156   HANDLE thread_;
   157 };
   158 
   159 } // namespace ke
   160 
   161 #endif // _include_amtl_thread_windows_h_