2007-12-17 Brent Fulgham <bfulgham@gmail.com>
[WebKit-https.git] / WebCore / platform / win / ThreadConditionWin.cpp
1 /*
2  * Copyright (C) 2007 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  * =============================================================================
29  * Note:  The implementation of condition variables under the Windows
30  * plaform was based on that of the excellent BOOST C++ library.  It
31  * has been rewritten to fit in with the WebKit architecture and to
32  * use its coding conventions.
33  * =============================================================================
34  *
35  * The Boost license is virtually identical to the Apple variation at the
36  * top of this file, but is included here for completeness:
37  *
38  * Boost Software License - Version 1.0 - August 17th, 2003
39  *
40  * Permission is hereby granted, free of charge, to any person or organization
41  * obtaining a copy of the software and accompanying documentation covered by
42  * this license (the "Software") to use, reproduce, display, distribute,
43  * execute, and transmit the Software, and to prepare derivative works of the
44  * Software, and to permit third-parties to whom the Software is furnished to
45  * do so, all subject to the following:
46  *
47  * The copyright notices in the Software and this entire statement, including
48  * the above license grant, this restriction and the following disclaimer,
49  * must be included in all copies of the Software, in whole or in part, and
50  * all derivative works of the Software, unless such copies or derivative
51  * works are solely in the form of machine-executable object code generated by
52  * a source language processor.
53  *
54  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
55  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
56  * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
57  * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
58  * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
59  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
60  * DEALINGS IN THE SOFTWARE.
61  */
62
63 #include "config.h"
64 #include "Logging.h"
65 #include "Threading.h"
66 #include <limits>
67 #include <errno.h>
68
69 namespace WebCore {
70
71 static const long MaxSemaphoreCount = static_cast<long>(~0UL >> 1);
72
73 ThreadCondition::ThreadCondition()
74 {
75     m_condition.m_timedOut = 0;
76     m_condition.m_blocked = 0;
77     m_condition.m_waitingForRemoval = 0;
78     m_condition.m_gate = ::CreateSemaphore(0, 1, 1, 0);
79     m_condition.m_queue = ::CreateSemaphore(0, 0, MaxSemaphoreCount, 0);
80     m_condition.m_mutex = ::CreateMutex(0, 0, 0);
81
82     if (!m_condition.m_gate || !m_condition.m_queue || !m_condition.m_mutex) {
83         if (m_condition.m_gate)
84             ::CloseHandle(m_condition.m_gate);
85         if (m_condition.m_queue)
86             ::CloseHandle(m_condition.m_queue);
87         if (m_condition.m_mutex)
88             ::CloseHandle(m_condition.m_mutex);
89     }
90 }
91
92 ThreadCondition::~ThreadCondition()
93 {
94     ::CloseHandle(m_condition.m_gate);
95     ::CloseHandle(m_condition.m_queue);
96     ::CloseHandle(m_condition.m_mutex);
97 }
98     
99 void ThreadCondition::wait(Mutex& mutex)
100 {
101     PlatformMutex& cs = mutex.impl();
102
103     // Enter the wait state.
104     DWORD res = ::WaitForSingleObject(m_condition.m_gate, INFINITE);
105     ASSERT(res == WAIT_OBJECT_0);
106     ++m_condition.m_blocked;
107     res = ::ReleaseSemaphore(m_condition.m_gate, 1, 0);
108     ASSERT(res);
109
110     ::LeaveCriticalSection(&cs.m_internalMutex);
111
112     res = ::WaitForSingleObject(m_condition.m_queue, INFINITE);
113     ASSERT(res == WAIT_OBJECT_0);
114
115     res = ::WaitForSingleObject(m_condition.m_mutex, INFINITE);
116     ASSERT(res == WAIT_OBJECT_0);
117     size_t wasWaiting = m_condition.m_waitingForRemoval;
118     size_t wasTimedOut = m_condition.m_timedOut;
119     if (wasWaiting != 0) {
120         if (--m_condition.m_waitingForRemoval == 0) {
121             if (m_condition.m_blocked != 0) {
122                 res = ::ReleaseSemaphore(m_condition.m_gate, 1, 0);  // open m_gate
123                 ASSERT(res);
124                 wasWaiting = 0;
125             }
126             else if (m_condition.m_timedOut != 0)
127                 m_condition.m_timedOut = 0;
128         }
129     } else if (++m_condition.m_timedOut == ((std::numeric_limits<unsigned>::max)() / 2)) {
130         // timeout occured, normalize the m_condition.m_timedOut count
131         // this may occur if many calls to wait with a timeout are made and
132         // no call to notify_* is made
133         res = ::WaitForSingleObject(m_condition.m_gate, INFINITE);
134         ASSERT(res == WAIT_OBJECT_0);
135         m_condition.m_blocked -= m_condition.m_timedOut;
136         res = ::ReleaseSemaphore(m_condition.m_gate, 1, 0);
137         ASSERT(res);
138         m_condition.m_timedOut = 0;
139     }
140     res = ::ReleaseMutex(m_condition.m_mutex);
141     ASSERT(res);
142
143     if (wasWaiting == 1) {
144         for (/**/ ; wasTimedOut; --wasTimedOut) {
145             // better now than spurious later
146             res = ::WaitForSingleObject(m_condition.m_queue, INFINITE);
147             ASSERT(res == WAIT_OBJECT_0);
148         }
149         res = ::ReleaseSemaphore(m_condition.m_gate, 1, 0);
150         ASSERT(res);
151     }
152
153     ::EnterCriticalSection (&cs.m_internalMutex);
154 }
155
156 void ThreadCondition::signal()
157 {
158     unsigned signals = 0;
159
160     DWORD res = ::WaitForSingleObject(m_condition.m_mutex, INFINITE);
161     ASSERT(res == WAIT_OBJECT_0);
162
163     if (m_condition.m_waitingForRemoval != 0) { // the m_gate is already closed
164         if (m_condition.m_blocked == 0) {
165             res = ::ReleaseMutex(m_condition.m_mutex);
166             ASSERT(res);
167             return;
168         }
169
170         ++m_condition.m_waitingForRemoval;
171         --m_condition.m_blocked;
172
173         signals = 1;
174     } else {
175         res = ::WaitForSingleObject(m_condition.m_gate, INFINITE);
176         ASSERT(res == WAIT_OBJECT_0);
177         if (m_condition.m_blocked > m_condition.m_timedOut) {
178             if (m_condition.m_timedOut != 0) {
179                 m_condition.m_blocked -= m_condition.m_timedOut;
180                 m_condition.m_timedOut = 0;
181             }
182             signals = m_condition.m_waitingForRemoval = 1;
183             --m_condition.m_blocked;
184         } else {
185             res = ::ReleaseSemaphore(m_condition.m_gate, 1, 0);
186             ASSERT(res);
187         }
188     }
189
190     res =::ReleaseMutex(m_condition.m_mutex);
191     ASSERT(res);
192
193     if (signals) {
194         res = ::ReleaseSemaphore(m_condition.m_queue, signals, 0);
195         ASSERT(res);
196     }
197 }
198
199 void ThreadCondition::broadcast()
200 {
201     unsigned signals = 0;
202
203     WORD res = ::WaitForSingleObject(m_condition.m_mutex, INFINITE);
204     ASSERT(res == WAIT_OBJECT_0);
205
206     if (m_condition.m_waitingForRemoval != 0) { // the m_gate is already closed
207         if (m_condition.m_blocked == 0) {
208             res = ::ReleaseMutex(m_condition.m_mutex);
209             ASSERT(res);
210             return;
211         }
212
213         m_condition.m_waitingForRemoval += (signals = m_condition.m_blocked);
214         m_condition.m_blocked = 0;
215     } else {
216         res = ::WaitForSingleObject(m_condition.m_gate, INFINITE);
217         ASSERT(res == WAIT_OBJECT_0);
218         if (m_condition.m_blocked > m_condition.m_timedOut) {
219             if (m_condition.m_timedOut != 0) {
220                 m_condition.m_blocked -= m_condition.m_timedOut;
221                 m_condition.m_timedOut = 0;
222             }
223             signals = m_condition.m_waitingForRemoval = m_condition.m_blocked;
224             m_condition.m_blocked = 0;
225         } else {
226             res = ::ReleaseSemaphore(m_condition.m_gate, 1, 0);
227             ASSERT(res);
228         }
229     }
230
231     res = ::ReleaseMutex(m_condition.m_mutex);
232     ASSERT(res);
233
234     if (signals) {
235         res = ::ReleaseSemaphore(m_condition.m_queue, signals, 0);
236         ASSERT(res);
237     }
238 }
239     
240 } // namespace WebCore