aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/eina/src/include/eina_inline_lock_win32.x
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/eina/src/include/eina_inline_lock_win32.x')
-rw-r--r--libraries/eina/src/include/eina_inline_lock_win32.x550
1 files changed, 0 insertions, 550 deletions
diff --git a/libraries/eina/src/include/eina_inline_lock_win32.x b/libraries/eina/src/include/eina_inline_lock_win32.x
deleted file mode 100644
index 1988724..0000000
--- a/libraries/eina/src/include/eina_inline_lock_win32.x
+++ /dev/null
@@ -1,550 +0,0 @@
1/* EINA - EFL data type library
2 * Copyright (C) 2011 Vincent Torri
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library;
16 * if not, see <http://www.gnu.org/licenses/>.
17 */
18
19#ifndef EINA_INLINE_LOCK_WIN32_X_
20#define EINA_INLINE_LOCK_WIN32_X_
21
22#include <windows.h>
23
24typedef CRITICAL_SECTION Eina_Lock;
25typedef struct _Eina_Condition Eina_Condition;
26typedef struct _Eina_RWLock Eina_RWLock;
27typedef DWORD Eina_TLS;
28typedef HANDLE Eina_Semaphore;
29
30#if _WIN32_WINNT >= 0x0600
31struct _Eina_Condition
32{
33 CRITICAL_SECTION *mutex;
34 CONDITION_VARIABLE condition;
35};
36
37struct _Eina_RWLock
38{
39 SRWLOCK mutex;
40
41 Eina_Bool is_read_mode : 1;
42};
43#else
44struct _Eina_Condition
45{
46 int waiters_count;
47 CRITICAL_SECTION waiters_count_lock;
48 CRITICAL_SECTION *mutex;
49 HANDLE semaphore;
50 HANDLE waiters_done;
51 Eina_Bool was_broadcast;
52};
53
54struct _Eina_RWLock
55{
56 LONG readers_count;
57 LONG writers_count;
58 int readers;
59 int writers;
60
61 Eina_Lock mutex;
62 Eina_Condition cond_read;
63 Eina_Condition cond_write;
64};
65#endif
66
67
68EAPI extern Eina_Bool _eina_threads_activated;
69
70
71static inline Eina_Bool
72eina_lock_new(Eina_Lock *mutex)
73{
74 InitializeCriticalSection(mutex);
75
76 return EINA_TRUE;
77}
78
79static inline void
80eina_lock_free(Eina_Lock *mutex)
81{
82 DeleteCriticalSection(mutex);
83}
84
85static inline Eina_Lock_Result
86eina_lock_take(Eina_Lock *mutex)
87{
88#ifdef EINA_HAVE_ON_OFF_THREADS
89 if (!_eina_threads_activated) return EINA_LOCK_SUCCEED;
90#endif
91
92 EnterCriticalSection(mutex);
93
94 return EINA_LOCK_SUCCEED;
95}
96
97static inline Eina_Lock_Result
98eina_lock_take_try(Eina_Lock *mutex)
99{
100#ifdef EINA_HAVE_ON_OFF_THREADS
101 if (!_eina_threads_activated) return EINA_LOCK_SUCCEED;
102#endif
103
104 return TryEnterCriticalSection(mutex) == 0 ? EINA_LOCK_FAIL : EINA_LOCK_SUCCEED;
105}
106
107static inline Eina_Lock_Result
108eina_lock_release(Eina_Lock *mutex)
109{
110#ifdef EINA_HAVE_ON_OFF_THREADS
111 if (!_eina_threads_activated) return EINA_LOCK_SUCCEED;
112#endif
113
114 LeaveCriticalSection(mutex);
115
116 return EINA_LOCK_SUCCEED;
117}
118
119static inline void
120eina_lock_debug(const Eina_Lock *mutex)
121{
122 (void)mutex;
123}
124
125static inline Eina_Bool
126eina_condition_new(Eina_Condition *cond, Eina_Lock *mutex)
127{
128 cond->mutex = mutex;
129#if _WIN32_WINNT >= 0x0600
130 InitializeConditionVariable(&cond->condition);
131#else
132 cond->waiters_count = 0;
133 cond->was_broadcast = EINA_FALSE;
134 cond->semaphore = CreateSemaphore(NULL, // no security
135 0, // initially 0
136 0x7fffffff, // max count
137 NULL); // unnamed
138 if (!cond->semaphore)
139 return EINA_FALSE;
140
141 InitializeCriticalSection(&cond->waiters_count_lock);
142
143 cond->waiters_done = CreateEvent(NULL, // no security
144 FALSE, // auto-reset
145 FALSE, // non-signaled initially
146 NULL); // unnamed
147 if (!cond->waiters_done)
148 {
149 CloseHandle(cond->semaphore);
150 return EINA_FALSE;
151 }
152#endif
153
154 return EINA_TRUE;
155}
156
157static inline void
158eina_condition_free(Eina_Condition *cond)
159{
160#if _WIN32_WINNT >= 0x0600
161 /* Nothing to do */
162 (void)cond;
163#else
164 CloseHandle(cond->waiters_done);
165 DeleteCriticalSection(&cond->waiters_count_lock);
166 CloseHandle(cond->semaphore);
167#endif
168}
169
170static inline Eina_Bool
171_eina_condition_internal_timedwait(Eina_Condition *cond, DWORD t)
172{
173#if _WIN32_WINNT >= 0x0600
174 SleepConditionVariableCS(&cond->condition, cond->mutex, t);
175#else
176 DWORD ret;
177 Eina_Bool last_waiter;
178
179 /* Avoid race conditions. */
180 EnterCriticalSection(&cond->waiters_count_lock);
181 cond->waiters_count++;
182 LeaveCriticalSection(&cond->waiters_count_lock);
183
184 /*
185 * This call atomically releases the mutex and waits on the
186 * semaphore until <pthread_cond_signal> or <pthread_cond_broadcast>
187 * are called by another thread.
188 */
189 ret = SignalObjectAndWait(cond->mutex, cond->semaphore, t, FALSE);
190 if (ret == WAIT_FAILED)
191 return EINA_FALSE;
192
193 /* Reacquire lock to avoid race conditions. */
194 EnterCriticalSection(&cond->waiters_count_lock);
195
196 /* We're no longer waiting... */
197 cond->waiters_count--;
198
199 /* Check to see if we're the last waiter after <pthread_cond_broadcast>. */
200 last_waiter = (cond->was_broadcast) && (cond->waiters_count == 0);
201
202 LeaveCriticalSection(&cond->waiters_count_lock);
203
204 /*
205 * If we're the last waiter thread during this particular broadcast
206 * then let all the other threads proceed.
207 */
208 if (last_waiter)
209 {
210 /*
211 * This call atomically signals the <waiters_done_> event and waits until
212 * it can acquire the <external_mutex>. This is required to ensure fairness.
213 */
214 ret = SignalObjectAndWait(cond->waiters_done, cond->mutex, t, FALSE);
215 if (ret == WAIT_FAILED)
216 return EINA_FALSE;
217 }
218 else
219 {
220 /*
221 * Always regain the external mutex since that's the guarantee we
222 * give to our callers.
223 */
224 ret = WaitForSingleObject(cond->mutex, t);
225 if (ret == WAIT_FAILED)
226 return EINA_FALSE;
227 }
228#endif
229
230 return EINA_TRUE;
231}
232
233static inline Eina_Bool
234eina_condition_timedwait(Eina_Condition *cond, double val)
235{
236 return _eina_condition_internal_timedwait(cond, (DWORD)(val * 1000));
237}
238
239static inline Eina_Bool
240eina_condition_wait(Eina_Condition *cond)
241{
242 return _eina_condition_internal_timedwait(cond, INFINITE);
243}
244
245static inline Eina_Bool
246eina_condition_broadcast(Eina_Condition *cond)
247{
248#if _WIN32_WINNT >= 0x0600
249 WakeAllConditionVariable(&cond->condition);
250 return EINA_TRUE;
251#else
252 Eina_Bool have_waiters;
253
254 /*
255 * This is needed to ensure that <waiters_count_> and <was_broadcast_> are
256 * consistent relative to each other.
257 */
258 EnterCriticalSection(&cond->waiters_count_lock);
259 have_waiters = EINA_FALSE;
260
261 if (cond->waiters_count > 0)
262 {
263 /*
264 * We are broadcasting, even if there is just one waiter...
265 * Record that we are broadcasting, which helps optimize
266 * <pthread_cond_wait> for the non-broadcast case.
267 */
268 cond->was_broadcast = EINA_TRUE;
269 have_waiters = EINA_TRUE;
270 }
271
272 if (have_waiters)
273 {
274 DWORD ret;
275
276 /* Wake up all the waiters atomically. */
277 ret = ReleaseSemaphore(cond->semaphore, cond->waiters_count, 0);
278 LeaveCriticalSection(&cond->waiters_count_lock);
279 if (!ret) return EINA_FALSE;
280
281 /*
282 * Wait for all the awakened threads to acquire the counting
283 * semaphore.
284 */
285 ret = WaitForSingleObject(cond->waiters_done, INFINITE);
286 if (ret == WAIT_FAILED)
287 return EINA_FALSE;
288 /*
289 * This assignment is okay, even without the <waiters_count_lock_> held
290 * because no other waiter threads can wake up to access it.
291 */
292 cond->was_broadcast = EINA_FALSE;
293 }
294 else
295 LeaveCriticalSection(&cond->waiters_count_lock);
296
297 return EINA_TRUE;
298#endif
299}
300
301static inline Eina_Bool
302eina_condition_signal(Eina_Condition *cond)
303{
304#if _WIN32_WINNT >= 0x0600
305 WakeConditionVariable(&cond->condition);
306#else
307 Eina_Bool have_waiters;
308
309 EnterCriticalSection(&cond->waiters_count_lock);
310 have_waiters = (cond->waiters_count > 0);
311 LeaveCriticalSection(&cond->waiters_count_lock);
312
313 /* If there aren't any waiters, then this is a no-op. */
314 if (have_waiters)
315 {
316 if (!ReleaseSemaphore(cond->semaphore, 1, 0))
317 return EINA_FALSE;
318 }
319#endif
320
321 return EINA_TRUE;
322}
323
324static inline Eina_Bool
325eina_rwlock_new(Eina_RWLock *mutex)
326{
327#if _WIN32_WINNT >= 0x0600
328 InitializeSRWLock(&mutex->mutex);
329 return EINA_TRUE;
330#else
331 if (!eina_lock_new(&(mutex->mutex))) return EINA_FALSE;
332 if (!eina_condition_new(&(mutex->cond_read), &(mutex->mutex)))
333 goto on_error1;
334 if (!eina_condition_new(&(mutex->cond_write), &(mutex->mutex)))
335 goto on_error2;
336
337 mutex->readers_count = 0;
338 mutex->writers_count = 0;
339 mutex->readers = 0;
340 mutex->writers = 0;
341
342 return EINA_TRUE;
343
344 on_error2:
345 eina_condition_free(&(mutex->cond_read));
346 on_error1:
347 eina_lock_free(&(mutex->mutex));
348 return EINA_FALSE;
349#endif
350}
351
352static inline void
353eina_rwlock_free(Eina_RWLock *mutex)
354{
355#if _WIN32_WINNT >= 0x0600
356 (void)mutex;
357#else
358 eina_condition_free(&(mutex->cond_read));
359 eina_condition_free(&(mutex->cond_write));
360 eina_lock_free(&(mutex->mutex));
361#endif
362}
363
364static inline Eina_Lock_Result
365eina_rwlock_take_read(Eina_RWLock *mutex)
366{
367#if _WIN32_WINNT >= 0x0600
368 AcquireSRWLockShared(&mutex->mutex);
369 mutex->is_read_mode = EINA_TRUE;
370#else
371 DWORD res = 0;
372
373 if (eina_lock_take(&(mutex->mutex)) == EINA_LOCK_FAIL)
374 return EINA_LOCK_FAIL;
375
376 if (mutex->writers)
377 {
378 mutex->readers_count++;
379 while (mutex->writers)
380 {
381 EnterCriticalSection(&mutex->cond_write.waiters_count_lock);
382 mutex->cond_read.waiters_count++;
383 LeaveCriticalSection(&mutex->cond_write.waiters_count_lock);
384 res = WaitForSingleObject(mutex->cond_write.semaphore, INFINITE);
385 if (res != WAIT_OBJECT_0) break;
386 }
387 mutex->readers_count--;
388 }
389 if (res == 0)
390 mutex->readers++;
391 eina_lock_release(&(mutex->mutex));
392#endif
393
394 return EINA_LOCK_SUCCEED;
395}
396
397static inline Eina_Lock_Result
398eina_rwlock_take_write(Eina_RWLock *mutex)
399{
400#if _WIN32_WINNT >= 0x0600
401 AcquireSRWLockExclusive(&mutex->mutex);
402 mutex->is_read_mode = EINA_FALSE;
403#else
404 DWORD res = 0;
405
406 if (eina_lock_take(&(mutex->mutex)) == EINA_LOCK_FAIL)
407 return EINA_LOCK_FAIL;
408
409 if (mutex->writers || mutex->readers > 0)
410 {
411 mutex->writers_count++;
412 while (mutex->writers || mutex->readers > 0)
413 {
414 EnterCriticalSection(&mutex->cond_write.waiters_count_lock);
415 mutex->cond_read.waiters_count++;
416 LeaveCriticalSection(&mutex->cond_write.waiters_count_lock);
417 res = WaitForSingleObject(mutex->cond_write.semaphore, INFINITE);
418 if (res != WAIT_OBJECT_0) break;
419 }
420 mutex->writers_count--;
421 }
422 if (res == 0) mutex->writers = 1;
423 eina_lock_release(&(mutex->mutex));
424#endif
425
426 return EINA_LOCK_SUCCEED;
427}
428
429static inline Eina_Lock_Result
430eina_rwlock_release(Eina_RWLock *mutex)
431{
432#if _WIN32_WINNT >= 0x0600
433 if (mutex->is_read_mode)
434 ReleaseSRWLockShared(&mutex->mutex);
435 else
436 ReleaseSRWLockExclusive(&mutex->mutex);
437#else
438 if (eina_lock_take(&(mutex->mutex)) == EINA_LOCK_FAIL)
439 return EINA_LOCK_FAIL;
440
441 if (mutex->writers)
442 {
443 mutex->writers = 0;
444 if (mutex->readers_count == 1)
445 {
446 EnterCriticalSection(&mutex->cond_read.waiters_count_lock);
447 if (mutex->cond_read.waiters_count > 0)
448 ReleaseSemaphore(mutex->cond_read.semaphore, 1, 0);
449 LeaveCriticalSection(&mutex->cond_read.waiters_count_lock);
450 }
451 else if (mutex->readers_count > 0)
452 eina_condition_broadcast(&(mutex->cond_read));
453 else if (mutex->writers_count > 0)
454 {
455 EnterCriticalSection (&mutex->cond_write.waiters_count_lock);
456 if (mutex->cond_write.waiters_count > 0)
457 ReleaseSemaphore(mutex->cond_write.semaphore, 1, 0);
458 LeaveCriticalSection (&mutex->cond_write.waiters_count_lock);
459 }
460 }
461 else if (mutex->readers > 0)
462 {
463 mutex->readers--;
464 if (mutex->readers == 0 && mutex->writers_count > 0)
465 {
466 EnterCriticalSection (&mutex->cond_write.waiters_count_lock);
467 if (mutex->cond_write.waiters_count > 0)
468 ReleaseSemaphore(mutex->cond_write.semaphore, 1, 0);
469 LeaveCriticalSection (&mutex->cond_write.waiters_count_lock);
470 }
471 }
472 eina_lock_release(&(mutex->mutex));
473#endif
474
475 return EINA_LOCK_SUCCEED;
476}
477
478static inline Eina_Bool
479eina_tls_new(Eina_TLS *key)
480{
481 if ((*key = TlsAlloc()) == TLS_OUT_OF_INDEXES)
482 return EINA_FALSE;
483 return EINA_TRUE;
484}
485
486static inline void
487eina_tls_free(Eina_TLS key)
488{
489 TlsFree(key);
490}
491
492static inline void *
493eina_tls_get(Eina_TLS key)
494{
495 return (void*)TlsGetValue(key);
496}
497
498static inline Eina_Bool
499eina_tls_set(Eina_TLS key, const void *data)
500{
501 if (TlsSetValue(key, (LPVOID)data) == 0)
502 return EINA_FALSE;
503 return EINA_TRUE;
504}
505
506static inline Eina_Bool
507eina_semaphore_new(Eina_Semaphore *sem, int count_init)
508{
509 if (!sem || (count_init <= 0))
510 return EINA_FALSE;
511
512 *sem = CreateSemaphore(NULL, count_init, 32767, NULL);
513 if (!*sem)
514 return EINA_FALSE;
515}
516
517static inline Eina_Bool
518eina_semaphore_free(Eina_Semaphore *sem)
519{
520 if (!sem)
521 return EINA_FALSE;
522
523 CloseHandle(*sem);
524}
525
526static inline Eina_Bool
527eina_semaphore_lock(Eina_Semaphore *sem)
528{
529 DWORD res;
530
531 if (!sem)
532 return EINA_FALSE;
533
534 res = WaitForSingleObject(*sem, 0L);
535 if (res == WAIT_OBJECT_0)
536 return EINA_TRUE;
537
538 return EINA_FALSE;
539}
540
541static inline Eina_Bool
542eina_semaphore_release(Eina_Semaphore *sem, int count_release)
543{
544 if (!sem)
545 return EINA_FALSE;
546
547 return ReleaseSemaphore(*sem, count_release, NULL) ? EINA_TRUE : EINA_FALSE;
548}
549
550#endif
generated by cgit v1.1 at 2024-08-27 19:51:15 +0000