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
142
143
144
145
146
147
148
149
150
151
152
153
154
|
#ifndef WIBBLE_SYS_MUTEX_H
#define WIBBLE_SYS_MUTEX_H
/*
* Encapsulated pthread mutex and condition
*
* Copyright (C) 2003--2006 Enrico Zini <enrico@debian.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <wibble/exception.h>
#include <pthread.h>
namespace wibble {
namespace sys {
/**
* pthread mutex wrapper
*/
class Mutex
{
protected:
pthread_mutex_t mutex;
public:
Mutex()
{
if (int res = pthread_mutex_init(&mutex, 0))
throw wibble::exception::System(res, "creating pthread mutex");
}
~Mutex()
{
if (int res = pthread_mutex_destroy(&mutex))
throw wibble::exception::System(res, "destroying pthread mutex");
}
/// Lock the mutex
/// Normally it's better to use MutexLock
void lock()
{
if (int res = pthread_mutex_lock(&mutex))
throw wibble::exception::System(res, "locking pthread mutex");
}
/// Unlock the mutex
/// Normally it's better to use MutexLock
void unlock()
{
if (int res = pthread_mutex_unlock(&mutex))
throw wibble::exception::System(res, "unlocking pthread mutex");
}
/// Reinitialize the mutex
void reinit()
{
if (int res = pthread_mutex_init(&mutex, 0))
throw wibble::exception::System(res, "reinitialising pthread mutex");
}
friend class Condition;
};
/**
* Acquire a mutex lock, RAII-style
*/
class MutexLock
{
protected:
Mutex& mutex;
public:
MutexLock(Mutex& m) : mutex(m) { mutex.lock(); }
~MutexLock() { mutex.unlock(); }
friend class Condition;
};
/*
* pthread condition wrapper.
*
* It works in association with a MutexLock.
*/
class Condition
{
protected:
pthread_cond_t cond;
public:
Condition()
{
if (int res = pthread_cond_init(&cond, 0))
throw wibble::exception::System(res, "creating pthread condition");
}
~Condition()
{
if (int res = pthread_cond_destroy(&cond))
throw wibble::exception::System(res, "destroying pthread condition");
}
/// Wake up one process waiting on the condition
void signal()
{
if (int res = pthread_cond_signal(&cond))
throw wibble::exception::System(res, "signaling on a pthread condition");
}
/// Wake up all processes waiting on the condition
void broadcast()
{
if (int res = pthread_cond_broadcast(&cond))
throw wibble::exception::System(res, "broadcasting on a pthread condition");
}
/**
* Wait on the condition, locking with l. l is unlocked before waiting and
* locked again before returning.
*/
void wait(MutexLock& l)
{
if (int res = pthread_cond_wait(&cond, &l.mutex.mutex))
throw wibble::exception::System(res, "waiting on a pthread condition");
}
/**
* Wait on the condition, locking with l. l is unlocked before waiting and
* locked again before returning. If the time abstime is reached before
* the condition is signaled, then l is locked and the function returns
* false.
*
* @returns
* true if the wait succeeded, or false if the timeout was reached before
* the condition is signaled.
*/
bool wait(MutexLock& l, const struct timespec& abstime);
};
}
}
// vim:set ts=4 sw=4:
#endif
|
