blob: 120075b0cb96246fe3c0b0196122fa274630e7fb (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "primpl.h"
#include "obsolete/prsem.h"
/************************************************************************/
/*
** Create a new semaphore.
*/
PR_IMPLEMENT(PRSemaphore*) PR_NewSem(PRUintn value)
{
PRSemaphore *sem;
PRCondVar *cvar;
PRLock *lock;
sem = PR_NEWZAP(PRSemaphore);
if (sem) {
#ifdef HAVE_CVAR_BUILT_ON_SEM
_PR_MD_NEW_SEM(&sem->md, value);
#else
lock = PR_NewLock();
if (!lock) {
PR_DELETE(sem);
return NULL;
}
cvar = PR_NewCondVar(lock);
if (!cvar) {
PR_DestroyLock(lock);
PR_DELETE(sem);
return NULL;
}
sem->cvar = cvar;
sem->count = value;
#endif
}
return sem;
}
/*
** Destroy a semaphore. There must be no thread waiting on the semaphore.
** The caller is responsible for guaranteeing that the semaphore is
** no longer in use.
*/
PR_IMPLEMENT(void) PR_DestroySem(PRSemaphore *sem)
{
#ifdef HAVE_CVAR_BUILT_ON_SEM
_PR_MD_DESTROY_SEM(&sem->md);
#else
PR_ASSERT(sem->waiters == 0);
PR_DestroyLock(sem->cvar->lock);
PR_DestroyCondVar(sem->cvar);
#endif
PR_DELETE(sem);
}
/*
** Wait on a Semaphore.
**
** This routine allows a calling thread to wait or proceed depending upon the
** state of the semahore sem. The thread can proceed only if the counter value
** of the semaphore sem is currently greater than 0. If the value of semaphore
** sem is positive, it is decremented by one and the routine returns immediately
** allowing the calling thread to continue. If the value of semaphore sem is 0,
** the calling thread blocks awaiting the semaphore to be released by another
** thread.
**
** This routine can return PR_PENDING_INTERRUPT if the waiting thread
** has been interrupted.
*/
PR_IMPLEMENT(PRStatus) PR_WaitSem(PRSemaphore *sem)
{
PRStatus status = PR_SUCCESS;
#ifdef HAVE_CVAR_BUILT_ON_SEM
return _PR_MD_WAIT_SEM(&sem->md);
#else
PR_Lock(sem->cvar->lock);
while (sem->count == 0) {
sem->waiters++;
status = PR_WaitCondVar(sem->cvar, PR_INTERVAL_NO_TIMEOUT);
sem->waiters--;
if (status != PR_SUCCESS) {
break;
}
}
if (status == PR_SUCCESS) {
sem->count--;
}
PR_Unlock(sem->cvar->lock);
#endif
return (status);
}
/*
** This routine increments the counter value of the semaphore. If other threads
** are blocked for the semaphore, then the scheduler will determine which ONE
** thread will be unblocked.
*/
PR_IMPLEMENT(void) PR_PostSem(PRSemaphore *sem)
{
#ifdef HAVE_CVAR_BUILT_ON_SEM
_PR_MD_POST_SEM(&sem->md);
#else
PR_Lock(sem->cvar->lock);
if (sem->waiters) {
PR_NotifyCondVar(sem->cvar);
}
sem->count++;
PR_Unlock(sem->cvar->lock);
#endif
}
#if DEBUG
/*
** Returns the value of the semaphore referenced by sem without affecting
** the state of the semaphore. The value represents the semaphore vaule
** at the time of the call, but may not be the actual value when the
** caller inspects it. (FOR DEBUGGING ONLY)
*/
PR_IMPLEMENT(PRUintn) PR_GetValueSem(PRSemaphore *sem)
{
PRUintn rv;
#ifdef HAVE_CVAR_BUILT_ON_SEM
rv = _PR_MD_GET_VALUE_SEM(&sem->md);
#else
PR_Lock(sem->cvar->lock);
rv = sem->count;
PR_Unlock(sem->cvar->lock);
#endif
return rv;
}
#endif
|
