RWMutex.inc revision 280031 
1//= llvm/Support/Win32/Mutex.inc - Win32 Reader/Writer Mutual Exclusion Lock  =//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Win32 specific (non-pthread) RWMutex class.
11//
12//===----------------------------------------------------------------------===//
13
14//===----------------------------------------------------------------------===//
15//=== WARNING: Implementation here must contain only generic Win32 code that
16//===          is guaranteed to work on *all* Win32 variants.
17//===----------------------------------------------------------------------===//
18
19#include "WindowsSupport.h"
20
21namespace llvm {
22using namespace sys;
23
24// Windows has slim read-writer lock support on Vista and higher, so we
25// will attempt to load the APIs.  If they exist, we will use them, and
26// if not, we will fall back on critical sections.  When we drop support
27// for XP, we can stop lazy-loading these APIs and just use them directly.
28#if defined(__MINGW32__)
29  // Taken from WinNT.h
30  typedef struct _RTL_SRWLOCK {
31    PVOID Ptr;
32  } RTL_SRWLOCK, *PRTL_SRWLOCK;
33
34  // Taken from WinBase.h
35  typedef RTL_SRWLOCK SRWLOCK, *PSRWLOCK;
36#endif
37
38static VOID (WINAPI *fpInitializeSRWLock)(PSRWLOCK lock) = NULL;
39static VOID (WINAPI *fpAcquireSRWLockExclusive)(PSRWLOCK lock) = NULL;
40static VOID (WINAPI *fpAcquireSRWLockShared)(PSRWLOCK lock) = NULL;
41static VOID (WINAPI *fpReleaseSRWLockExclusive)(PSRWLOCK lock) = NULL;
42static VOID (WINAPI *fpReleaseSRWLockShared)(PSRWLOCK lock) = NULL;
43
44static bool sHasSRW = false;
45
46static bool loadSRW() {
47  static bool sChecked = false;
48  if (!sChecked) {
49    sChecked = true;
50
51    if (HMODULE hLib = ::GetModuleHandleW(L"Kernel32.dll")) {
52      fpInitializeSRWLock =
53        (VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
54                                               "InitializeSRWLock");
55      fpAcquireSRWLockExclusive =
56        (VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
57                                               "AcquireSRWLockExclusive");
58      fpAcquireSRWLockShared =
59        (VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
60                                               "AcquireSRWLockShared");
61      fpReleaseSRWLockExclusive =
62        (VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
63                                               "ReleaseSRWLockExclusive");
64      fpReleaseSRWLockShared =
65        (VOID (WINAPI *)(PSRWLOCK))::GetProcAddress(hLib,
66                                               "ReleaseSRWLockShared");
67
68      if (fpInitializeSRWLock != NULL) {
69        sHasSRW = true;
70      }
71    }
72  }
73  return sHasSRW;
74}
75
76RWMutexImpl::RWMutexImpl() {
77  if (loadSRW()) {
78    data_ = calloc(1, sizeof(SRWLOCK));
79    fpInitializeSRWLock(static_cast<PSRWLOCK>(data_));
80  } else {
81    data_ = calloc(1, sizeof(CRITICAL_SECTION));
82    InitializeCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
83  }
84}
85
86RWMutexImpl::~RWMutexImpl() {
87  if (!sHasSRW)
88    DeleteCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
89  // Nothing to do in the case of slim reader/writers except free the memory.
90  free(data_);
91}
92
93bool RWMutexImpl::reader_acquire() {
94  if (sHasSRW) {
95    fpAcquireSRWLockShared(static_cast<PSRWLOCK>(data_));
96  } else {
97    EnterCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
98  }
99  return true;
100}
101
102bool RWMutexImpl::reader_release() {
103  if (sHasSRW) {
104    fpReleaseSRWLockShared(static_cast<PSRWLOCK>(data_));
105  } else {
106    LeaveCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
107  }
108  return true;
109}
110
111bool RWMutexImpl::writer_acquire() {
112  if (sHasSRW) {
113    fpAcquireSRWLockExclusive(static_cast<PSRWLOCK>(data_));
114  } else {
115    EnterCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
116  }
117  return true;
118}
119
120bool RWMutexImpl::writer_release() {
121  if (sHasSRW) {
122    fpReleaseSRWLockExclusive(static_cast<PSRWLOCK>(data_));
123  } else {
124    LeaveCriticalSection(static_cast<LPCRITICAL_SECTION>(data_));
125  }
126  return true;
127}
128
129
130}
131