libetherpix

1) /*

2)  * EtherPix library

3)  *

4)  * Copyright 2010-2011 Stefan Schuermans <stefan schuermans info>

5)  *
6)  * This program is free software: you can redistribute it and/or modify
7)  * it under the terms of the GNU General Public License as published by
8)  * the Free Software Foundation, version 3 of the License.
9)  *
10)  *
11)  * This program is distributed in the hope that it will be useful,
12)  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13)  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14)  * GNU General Public License for more details.
15)  *
16)  * You should have received a copy of the GNU Lesser General Public License
17)  * along with this program. If not, see <http://www.gnu.org/licenses/>.
18)  */
19) 

20) #ifndef ETP_THREAD_H
21) #define ETP_THREAD_H

22) 
23) #ifdef WINDOWS
24) #  include <windows.h>
25) #else
26) #  include <errno.h>
27) #  include <pthread.h>
28) #  include <sys/time.h>
29) #  include <stdlib.h>
30) #endif
31) 
32) /** signature to define or declare thread function */
33) #ifdef WINDOWS

34) #  define ETP_THREAD_FUNC(func) DWORD (__stdcall func)(LPVOID vp_displayer)

35) #else

36) #  define ETP_THREAD_FUNC(func) void * (func)(void *vp_displayer)

37) #endif
38) 
39) /** return a void pointer from a thread function */
40) #ifdef WINDOWS

41) #  define ETP_THREAD_RETURN(vp) return (DWORD)(vp);

42) #else

43) #  define ETP_THREAD_RETURN(vp) return (vp);

44) #endif
45) 
46) /** type for a thread ID */
47) #ifdef WINDOWS

48) typedef HANDLE etp_thread_id_t;

49) #else

50) typedef pthread_t etp_thread_id_t;

51) #endif
52) 
53) /** type for a mutex */
54) #ifdef WINDOWS

55) typedef HANDLE etp_thread_mutex_t;

56) #else

57) typedef pthread_mutex_t etp_thread_mutex_t;

58) #endif
59) 
60) /** type for a condition */
61) #ifdef WINDOWS

62) typedef HANDLE etp_thread_cond_t;

63) #else

64) typedef pthread_cond_t etp_thread_cond_t;

65) #endif
66) 
67) /**
68)  * \brief create a thread
69)  * \param[out] *p_tid thread ID
70)  * \param[in] func thread function
71)  * \param[in] p_data user data pointer
72)  * \return 1 if successful, 0 on error
73)  */

74) static inline int etp_thread_create(etp_thread_id_t *p_tid,
75)                                     ETP_THREAD_FUNC(*func),

76)                                     void * p_data)
77) {
78) #ifdef WINDOWS
79)   HANDLE h = CreateThread(NULL, 0, func, (LPVOID)p_data, 0, NULL);
80)   if (h != NULL)
81)     *p_tid = h;
82)   return h != NULL;
83) #else
84)   return pthread_create(p_tid, NULL, func, p_data) == 0;
85) #endif
86) }
87) 
88) /**
89)  * \brief join a thread
90)  * \param[in] tid thread ID
91)  */

92) static inline void etp_thread_join(etp_thread_id_t tid)

93) {
94) #ifdef WINDOWS
95)   WaitForSingleObject(tid, INFINITE);
96)   CloseHandle(tid);
97) #else
98)   pthread_join(tid, NULL);
99) #endif
100) }
101) 
102) /**
103)  * \brief initialize mutex
104)  * \param[in] *p_mtx mutex variable
105)  * \return 1 if successful, 0 on error
106)  */

107) static inline int etp_thread_mutex_init(etp_thread_mutex_t *p_mtx)

108) {
109) #ifdef WINDOWS
110)   HANDLE h = CreateMutex(NULL, FALSE, NULL);
111)   if (h != NULL)
112)     *p_mtx = h;
113)   return h != NULL;
114) #else
115)   return pthread_mutex_init(p_mtx, NULL) == 0;
116) #endif
117) }
118) 
119) /**
120)  * \brief destroy mutex
121)  * \param[in] *p_mtx mutex variable
122)  */

123) static inline void etp_thread_mutex_destroy(etp_thread_mutex_t *p_mtx)

124) {
125) #ifdef WINDOWS
126)   CloseHandle(*p_mtx);
127) #else
128)   pthread_mutex_destroy(p_mtx);
129) #endif
130) }
131) 
132) /**
133)  * \brief lock mutex
134)  * \param[in] *p_mtx mutex variable
135)  */

136) static inline void etp_thread_mutex_lock(etp_thread_mutex_t *p_mtx)

137) {
138) #ifdef WINDOWS
139)   WaitForSingleObject(*p_mtx, INFINITE);
140) #else
141)   pthread_mutex_lock(p_mtx);
142) #endif
143) }
144) 
145) /**
146)  * \brief unlock mutex
147)  * \param[in] *p_mtx mutex variable
148)  */

149) static inline void etp_thread_mutex_unlock(etp_thread_mutex_t *p_mtx)

150) {
151) #ifdef WINDOWS
152)   ReleaseMutex(*p_mtx);
153) #else
154)   pthread_mutex_unlock(p_mtx);
155) #endif
156) }
157) 
158) /**
159)  * \brief initialize condition
160)  * \param[in] *p_cond conition variable
161)  * \return 1 if successful, 0 on error
162)  */

163) static inline int etp_thread_cond_init(etp_thread_cond_t *p_cond)

164) {
165) #ifdef WINDOWS
166)   HANDLE h = CreateEvent(NULL, FALSE, FALSE, NULL);
167)   if (h != NULL)
168)     *p_cond = h;
169)   return h != NULL;
170) #else
171)   return pthread_cond_init(p_cond, NULL) == 0;
172) #endif
173) }
174) 
175) /**
176)  * \brief destroy condition
177)  * \param[in] *p_cond condition variable
178)  */

179) static inline void etp_thread_cond_destroy(etp_thread_cond_t *p_cond)

180) {
181) #ifdef WINDOWS
182)   CloseHandle(*p_cond);
183) #else
184)   pthread_cond_destroy(p_cond);
185) #endif
186) }
187) 
188) /**
189)  * \brief signal condition
190)  * \param[in] *p_cond condition variable
191)  */

192) static inline void etp_thread_cond_signal(etp_thread_cond_t *p_cond)

193) {
194) #ifdef WINDOWS
195)   SetEvent(*p_cond);
196) #else
197)   pthread_cond_signal(p_cond);
198) #endif
199) }
200) 
201) /**
202)  * \brief wait for condition
203)  * \param[in] *p_cond condition variable
204)  * \param[in] *p_mtx mutex variable to unlock while waiting
205)  */

206) static inline void etp_thread_cond_wait(etp_thread_cond_t *p_cond,
207)                                         etp_thread_mutex_t *p_mtx)

208) {
209) #ifdef WINDOWS
210)   /* the unlock/wait-begin and wait-end/lock are atomic for pthread,

211)      but this is not needed for libetherpix... */

212)   ReleaseMutex(*p_mtx); /* unlock mutex */
213)   WaitForSingleObject(*p_cond, INFINITE); /* wait for condition */
214)   WaitForSingleObject(*p_mtx, INFINITE); /* lock mutex again */
215) #else
216)   pthread_cond_wait(p_cond, p_mtx);
217) #endif
218) }
219) 
220) /**
221)  * \brief wait for condition with timeout
222)  * \param[in] *p_cond condition variable
223)  * \param[in] *p_mtx mutex variable to unlock while waiting
224)  * \param[in] *p_now current time
225)  * \param[in] millisecs number of milliseconds to wait at most
226)  * \return 0 for condition singnaled, 1 for timeout
227)  */

228) static inline int etp_thread_cond_timedwait(etp_thread_cond_t *p_cond,
229)                                             etp_thread_mutex_t *p_mtx,

230)                                             struct timeval *p_now,
231)                                             unsigned int millisecs)
232) {
233) #ifdef WINDOWS
234)   int ret;
235)   /* the unlock/wait-begin and wait-end/lock are atomic for pthread,

236)      but this is not needed for libetherpix... */

237)   ReleaseMutex(*p_mtx); /* unlock mutex */
238)   ret = WaitForSingleObject(*p_cond, millisecs); /* wait for condition */
239)   WaitForSingleObject(*p_mtx, INFINITE); /* lock mutex again */
240)   return ret == WAIT_TIMEOUT;
241)   (void)p_now;
242) #else
243)   struct timespec until;
244)   until.tv_sec = p_now->tv_sec + millisecs / 1000;
245)   until.tv_nsec = p_now->tv_usec * 1000 + (millisecs % 1000) * 1000000;
246)   if (until.tv_nsec > 1000000000) {
247)     until.tv_nsec -= 1000000000;
248)     until.tv_sec++;
249)   }
250)   return pthread_cond_timedwait(p_cond, p_mtx, &until) == ETIMEDOUT;
251) #endif
252) }
253) 

254) #endif /* #ifndef ETP_THREAD_H */