dep/src/zthread/win32/FastLock.h

   1 /*
   2  * Copyright (c) 2005, Eric Crahen
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is furnished
   9  * to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in all
  12  * copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  18  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  19  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20  *
  21  */
  22
  23 #ifndef __ZTFASTLOCK_H__
  24 #define __ZTFASTLOCK_H__
  25
  26 #include "zthread/Exceptions.h"
  27 #include "zthread/NonCopyable.h"
  28 #include "../ThreadOps.h"
  29 #include <windows.h>
  30 #include <assert.h>
  31
  32 namespace ZThread {
  33
  34   /**
  35    * @class FastLock
  36    *
  37    * @author Eric Crahen <http://www.code-foo.com>
  38    * @date <2003-07-16T23:32:44-0400>
  39    * @version 2.2.11
  40    *
  41    * This FastLock implementation is based on a Win32 Mutex
  42    * object. This will perform better under high contention,
  43    * but will not be as fast as the spin lock under reasonable
  44    * circumstances.
  45    */
  46   class FastLock : private NonCopyable {
  47
  48     HANDLE _hMutex;
  49 #ifndef NDEBUG
  50     volatile bool _locked;
  51 #endif
  52
  53   public:
  54
  55     /**
  56      * Create a new FastLock
  57      */
  58     FastLock() {
  59
  60 #ifndef NDEBUG
  61       _locked = false;
  62 #endif
  63
  64       _hMutex = ::CreateMutex(0, 0, 0);
  65       assert(_hMutex != NULL);
  66       if(_hMutex == NULL)
  67         throw Initialization_Exception();
  68
  69     }
  70
  71
  72     ~FastLock() {
  73       ::CloseHandle(_hMutex);
  74     }
  75
  76   void acquire() {
  77
  78     if(::WaitForSingleObject(_hMutex, INFINITE) != WAIT_OBJECT_0) {
  79       assert(0);
  80       throw Synchronization_Exception();
  81     }
  82
  83 #ifndef NDEBUG
  84
  85     // Simulate deadlock to provide consistent behavior. This
  86     // will help avoid errors when porting. Avoiding situations
  87     // where a FastMutex mistakenly behaves as a recursive lock.
  88
  89     while(_locked)
  90       ThreadOps::yield();
  91
  92     _locked = true;
  93
  94 #endif
  95
  96   }
  97
  98   void release() {
  99
 100 #ifndef NDEBUG
 101     _locked = false;
 102 #endif
 103
 104     if(::ReleaseMutex(_hMutex) == 0) {
 105       assert(0);
 106       throw Synchronization_Exception();
 107     }
 108
 109   }
 110
 111
 112   bool tryAcquire(unsigned long timeout = 0) {
 113
 114     switch(::WaitForSingleObject(_hMutex, timeout)) {
 115       case WAIT_OBJECT_0:
 116
 117 #ifndef NDEBUG
 118
 119         // Simulate deadlock to provide consistent behavior. This
 120         // will help avoid errors when porting. Avoiding situations
 121         // where a FastMutex mistakenly behaves as a recursive lock.
 122
 123         while(_locked)
 124           ThreadOps::yield();
 125
 126         _locked = true;
 127
 128 #endif
 129
 130         return true;
 131       case WAIT_TIMEOUT:
 132         return false;
 133       default:
 134         break;
 135     }
 136
 137     assert(0);
 138     throw Synchronization_Exception();
 139
 140   }
 141
 142  };
 143
 144 } // namespace ZThread
 145
 146 #endif