Merge lp:~anj/epics-base/epicsEvent-api into lp:~epics-core/epics-base/3.15
- epicsEvent-api
- Merge into 3.15
Status: | Merged |
---|---|
Merged at revision: | 12238 |
Proposed branch: | lp:~anj/epics-base/epicsEvent-api |
Merge into: | lp:~epics-core/epics-base/3.15 |
Diff against target: |
911 lines (+287/-269) 8 files modified
documentation/RELEASE_NOTES.html (+24/-0) src/libCom/osi/epicsEvent.cpp (+54/-22) src/libCom/osi/epicsEvent.h (+37/-31) src/libCom/osi/os/RTEMS/osdEvent.c (+18/-23) src/libCom/osi/os/WIN32/osdEvent.c (+17/-30) src/libCom/osi/os/posix/osdEvent.c (+124/-137) src/libCom/osi/os/vxWorks/osdEvent.c (+8/-16) src/libCom/osi/os/vxWorks/osdEvent.h (+5/-10) |
To merge this branch: | bzr merge lp:~anj/epics-base/epicsEvent-api |
Related bugs: |
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
EPICS Core Developers | Pending | ||
Review via email: mp+48992@code.launchpad.net |
Commit message
Description of the change
This branch modifies the epicsEvent APIs for both C and C++ callers, but keeping full backwards compatibility.
The enum epicsEventWaitS
It adds two new routines to the C API:
+ epicsEventTrigg
+ epicsEventMustT
epicsEventSigna
epicsEventWait() and epicsEventWaitW
All the epicsEventMust...() routines are now implemented in the common epicsEvent.cpp source file, and properly call cantProceed() instead of mis-using assert() in the event of any errors.
The Posix implementation now provides a basic epicsEventShow() routine.
For the C++ API it adds an epicsEvent:
The epicsEvent:
The epicsShareAPI decorations (used on Windows only) have all been removed.
Andrew Johnson (anj) wrote : | # |
Preview Diff
1 | === modified file 'documentation/RELEASE_NOTES.html' | |||
2 | --- documentation/RELEASE_NOTES.html 2010-11-28 03:06:40 +0000 | |||
3 | +++ documentation/RELEASE_NOTES.html 2011-02-08 21:39:58 +0000 | |||
4 | @@ -13,6 +13,30 @@ | |||
5 | 13 | <h2 align="center">Changes between 3.14.x and 3.15.1</h2> | 13 | <h2 align="center">Changes between 3.14.x and 3.15.1</h2> |
6 | 14 | <!-- Insert new items immediately below here ... --> | 14 | <!-- Insert new items immediately below here ... --> |
7 | 15 | 15 | ||
8 | 16 | <h3> | ||
9 | 17 | Reworked the epicsEvent C & C++ APIs</h3> | ||
10 | 18 | |||
11 | 19 | <ul> | ||
12 | 20 | <li>Renamed the enum epicsEventWaitStatus to epicsEventStatus</li> | ||
13 | 21 | <li>Defined epicsEventWaitStatus as a macro for epicsEventStatus</li> | ||
14 | 22 | <li>Renamed epicsEventWaitOk to epicsEventOk</li> | ||
15 | 23 | <li>Renamed epicsEventWaitError to epicsEventError</li> | ||
16 | 24 | <li>Defined epicsEventWaitOK and epicsEventWaitError as macros</li> | ||
17 | 25 | <li>Added epicsEventTrigger(id) which triggers an event and returns OK or an | ||
18 | 26 | error status if the underlying OS primitives report an error</li> | ||
19 | 27 | <li>Added epicsEventMustTrigger(id) which halts on error</li> | ||
20 | 28 | <li>Defined epicsEventSignal(id) as a macro for epicsEventMustTrigger(id)</li> | ||
21 | 29 | <li>Added a new C++ method epicsEvent::trigger() which throws an | ||
22 | 30 | epicsEvent::invalidSemaphore in the event of an error</li> | ||
23 | 31 | <li>epicsEvent::signal() makes an inline call to epicsEvent::trigger()</li> | ||
24 | 32 | <li>epicsEventWait() and epicsEventWaitWithTimeout() now return an error | ||
25 | 33 | status if the underlying OS primitives report an error</li> | ||
26 | 34 | <li>All the epicsEventMust...() routines are now implemented in the common | ||
27 | 35 | libCom/osi/epicsEvent.cpp source file, and call cantProceed() instead of | ||
28 | 36 | mis-using assert()</li> | ||
29 | 37 | <li>Implemented epicsEventShow() on Posix</li> | ||
30 | 38 | <li>Win32: Removed all epicsShareAPI decorations</li> | ||
31 | 39 | </ul> | ||
32 | 16 | 40 | ||
33 | 17 | <h3> | 41 | <h3> |
34 | 18 | Moved src/RTEMS/base directory</h3> | 42 | Moved src/RTEMS/base directory</h3> |
35 | 19 | 43 | ||
36 | === modified file 'src/libCom/osi/epicsEvent.cpp' | |||
37 | --- src/libCom/osi/epicsEvent.cpp 2004-09-30 19:15:45 +0000 | |||
38 | +++ src/libCom/osi/epicsEvent.cpp 2011-02-08 21:39:58 +0000 | |||
39 | @@ -1,10 +1,9 @@ | |||
40 | 1 | /*************************************************************************\ | 1 | /*************************************************************************\ |
42 | 2 | * Copyright (c) 2002 The University of Chicago, as Operator of Argonne | 2 | * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne |
43 | 3 | * National Laboratory. | 3 | * National Laboratory. |
44 | 4 | * Copyright (c) 2002 The Regents of the University of California, as | 4 | * Copyright (c) 2002 The Regents of the University of California, as |
45 | 5 | * Operator of Los Alamos National Laboratory. | 5 | * Operator of Los Alamos National Laboratory. |
48 | 6 | * EPICS BASE Versions 3.13.7 | 6 | * EPICS BASE is distributed subject to a Software License Agreement found |
47 | 7 | * and higher are distributed subject to a Software License Agreement found | ||
49 | 8 | * in file LICENSE that is included with this distribution. | 7 | * in file LICENSE that is included with this distribution. |
50 | 9 | \*************************************************************************/ | 8 | \*************************************************************************/ |
51 | 10 | 9 | ||
52 | @@ -17,6 +16,7 @@ | |||
53 | 17 | #define epicsExportSharedSymbols | 16 | #define epicsExportSharedSymbols |
54 | 18 | #include "epicsEvent.h" | 17 | #include "epicsEvent.h" |
55 | 19 | #include "epicsStdioRedirect.h" | 18 | #include "epicsStdioRedirect.h" |
56 | 19 | #include "cantProceed.h" | ||
57 | 20 | 20 | ||
58 | 21 | // vxWorks 5.4 gcc fails during compile when I use std::exception | 21 | // vxWorks 5.4 gcc fails during compile when I use std::exception |
59 | 22 | using namespace std; | 22 | using namespace std; |
60 | @@ -52,49 +52,81 @@ | |||
61 | 52 | epicsEventDestroy ( this->id ); | 52 | epicsEventDestroy ( this->id ); |
62 | 53 | } | 53 | } |
63 | 54 | 54 | ||
65 | 55 | void epicsEvent::signal () | 55 | void epicsEvent::trigger () |
66 | 56 | { | 56 | { |
68 | 57 | epicsEventSignal ( this->id ); | 57 | epicsEventStatus status = epicsEventTrigger (this->id); |
69 | 58 | |||
70 | 59 | if (status != epicsEventOK) { | ||
71 | 60 | throw invalidSemaphore (); | ||
72 | 61 | } | ||
73 | 58 | } | 62 | } |
74 | 59 | 63 | ||
75 | 60 | void epicsEvent::wait () | 64 | void epicsEvent::wait () |
76 | 61 | { | 65 | { |
80 | 62 | epicsEventWaitStatus status; | 66 | epicsEventStatus status = epicsEventWait (this->id); |
81 | 63 | status = epicsEventWait (this->id); | 67 | |
82 | 64 | if (status!=epicsEventWaitOK) { | 68 | if (status != epicsEventOK) { |
83 | 65 | throw invalidSemaphore (); | 69 | throw invalidSemaphore (); |
84 | 66 | } | 70 | } |
85 | 67 | } | 71 | } |
86 | 68 | 72 | ||
87 | 69 | bool epicsEvent::wait (double timeOut) | 73 | bool epicsEvent::wait (double timeOut) |
88 | 70 | { | 74 | { |
92 | 71 | epicsEventWaitStatus status; | 75 | epicsEventStatus status = epicsEventWaitWithTimeout (this->id, timeOut); |
93 | 72 | status = epicsEventWaitWithTimeout (this->id, timeOut); | 76 | |
94 | 73 | if (status==epicsEventWaitOK) { | 77 | if (status == epicsEventOK) { |
95 | 74 | return true; | 78 | return true; |
97 | 75 | } else if (status==epicsEventWaitTimeout) { | 79 | } else if (status == epicsEventWaitTimeout) { |
98 | 76 | return false; | 80 | return false; |
99 | 77 | } else { | ||
100 | 78 | throw invalidSemaphore (); | ||
101 | 79 | } | 81 | } |
103 | 80 | return false; | 82 | throw invalidSemaphore (); |
104 | 81 | } | 83 | } |
105 | 82 | 84 | ||
106 | 83 | bool epicsEvent::tryWait () | 85 | bool epicsEvent::tryWait () |
107 | 84 | { | 86 | { |
111 | 85 | epicsEventWaitStatus status; | 87 | epicsEventStatus status = epicsEventTryWait (this->id); |
112 | 86 | status = epicsEventTryWait (this->id); | 88 | |
113 | 87 | if (status==epicsEventWaitOK) { | 89 | if (status == epicsEventOK) { |
114 | 88 | return true; | 90 | return true; |
116 | 89 | } else if (status==epicsEventWaitTimeout) { | 91 | } else if (status == epicsEventWaitTimeout) { |
117 | 90 | return false; | 92 | return false; |
118 | 91 | } else { | ||
119 | 92 | throw invalidSemaphore (); | ||
120 | 93 | } | 93 | } |
122 | 94 | return false; | 94 | throw invalidSemaphore (); |
123 | 95 | } | 95 | } |
124 | 96 | 96 | ||
125 | 97 | void epicsEvent::show ( unsigned level ) const | 97 | void epicsEvent::show ( unsigned level ) const |
126 | 98 | { | 98 | { |
127 | 99 | epicsEventShow ( this->id, level ); | 99 | epicsEventShow ( this->id, level ); |
128 | 100 | } | 100 | } |
129 | 101 | |||
130 | 102 | |||
131 | 103 | // epicsEventMust... convenience routines for C code | ||
132 | 104 | |||
133 | 105 | extern "C" { | ||
134 | 106 | |||
135 | 107 | epicsShareFunc epicsEventId epicsEventMustCreate ( | ||
136 | 108 | epicsEventInitialState initialState) | ||
137 | 109 | { | ||
138 | 110 | epicsEventId id = epicsEventCreate (initialState); | ||
139 | 111 | |||
140 | 112 | if (!id) | ||
141 | 113 | cantProceed ("epicsEventMustCreate"); | ||
142 | 114 | return id; | ||
143 | 115 | } | ||
144 | 116 | |||
145 | 117 | epicsShareFunc void epicsEventMustTrigger (epicsEventId id) { | ||
146 | 118 | epicsEventStatus status = epicsEventTrigger (id); | ||
147 | 119 | |||
148 | 120 | if (status != epicsEventOK) | ||
149 | 121 | cantProceed ("epicsEventMustTrigger"); | ||
150 | 122 | } | ||
151 | 123 | |||
152 | 124 | epicsShareFunc void epicsEventMustWait (epicsEventId id) { | ||
153 | 125 | epicsEventStatus status = epicsEventWait (id); | ||
154 | 126 | |||
155 | 127 | if (status != epicsEventOK) | ||
156 | 128 | cantProceed ("epicsEventMustWait"); | ||
157 | 129 | } | ||
158 | 130 | |||
159 | 131 | } // extern "C" | ||
160 | 132 | |||
161 | 101 | 133 | ||
162 | === modified file 'src/libCom/osi/epicsEvent.h' | |||
163 | --- src/libCom/osi/epicsEvent.h 2009-01-06 17:07:56 +0000 | |||
164 | +++ src/libCom/osi/epicsEvent.h 2011-02-08 21:39:58 +0000 | |||
165 | @@ -1,25 +1,33 @@ | |||
166 | 1 | /*************************************************************************\ | 1 | /*************************************************************************\ |
168 | 2 | * Copyright (c) 2002 The University of Chicago, as Operator of Argonne | 2 | * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne |
169 | 3 | * National Laboratory. | 3 | * National Laboratory. |
170 | 4 | * Copyright (c) 2002 The Regents of the University of California, as | 4 | * Copyright (c) 2002 The Regents of the University of California, as |
171 | 5 | * Operator of Los Alamos National Laboratory. | 5 | * Operator of Los Alamos National Laboratory. |
174 | 6 | * EPICS BASE Versions 3.13.7 | 6 | * EPICS BASE is distributed subject to a Software License Agreement found |
173 | 7 | * and higher are distributed subject to a Software License Agreement found | ||
175 | 8 | * in file LICENSE that is included with this distribution. | 7 | * in file LICENSE that is included with this distribution. |
176 | 9 | \*************************************************************************/ | 8 | \*************************************************************************/ |
177 | 10 | #ifndef epicsEventh | 9 | #ifndef epicsEventh |
178 | 11 | #define epicsEventh | 10 | #define epicsEventh |
179 | 12 | 11 | ||
180 | 13 | #include "epicsAssert.h" | ||
181 | 14 | #include "shareLib.h" | 12 | #include "shareLib.h" |
182 | 15 | 13 | ||
183 | 16 | typedef struct epicsEventOSD *epicsEventId; | 14 | typedef struct epicsEventOSD *epicsEventId; |
184 | 17 | 15 | ||
185 | 18 | typedef enum { | 16 | typedef enum { |
190 | 19 | epicsEventWaitOK,epicsEventWaitTimeout,epicsEventWaitError | 17 | epicsEventOK = 0, |
191 | 20 | } epicsEventWaitStatus; | 18 | epicsEventWaitTimeout, |
192 | 21 | 19 | epicsEventError | |
193 | 22 | typedef enum {epicsEventEmpty,epicsEventFull} epicsEventInitialState; | 20 | } epicsEventStatus; |
194 | 21 | |||
195 | 22 | /* Backwards compatibility */ | ||
196 | 23 | #define epicsEventWaitStatus epicsEventStatus | ||
197 | 24 | #define epicsEventWaitOK epicsEventOK | ||
198 | 25 | #define epicsEventWaitError epicsEventError | ||
199 | 26 | |||
200 | 27 | typedef enum { | ||
201 | 28 | epicsEventEmpty, | ||
202 | 29 | epicsEventFull | ||
203 | 30 | } epicsEventInitialState; | ||
204 | 23 | 31 | ||
205 | 24 | #ifdef __cplusplus | 32 | #ifdef __cplusplus |
206 | 25 | 33 | ||
207 | @@ -27,42 +35,40 @@ | |||
208 | 27 | public: | 35 | public: |
209 | 28 | epicsEvent ( epicsEventInitialState initial = epicsEventEmpty ); | 36 | epicsEvent ( epicsEventInitialState initial = epicsEventEmpty ); |
210 | 29 | ~epicsEvent (); | 37 | ~epicsEvent (); |
215 | 30 | void signal (); | 38 | void trigger (); |
216 | 31 | void wait (); /* blocks until full */ | 39 | void signal () { this->trigger(); } |
217 | 32 | bool wait ( double timeOut ); /* false if empty at time out */ | 40 | void wait (); /* blocks until full */ |
218 | 33 | bool tryWait (); /* false if empty */ | 41 | bool wait ( double timeOut ); /* false if still empty at time out */ |
219 | 42 | bool tryWait (); /* false if empty */ | ||
220 | 34 | void show ( unsigned level ) const; | 43 | void show ( unsigned level ) const; |
221 | 35 | 44 | ||
223 | 36 | class invalidSemaphore; /* exception payload */ | 45 | class invalidSemaphore; /* exception payload */ |
224 | 37 | private: | 46 | private: |
225 | 38 | epicsEvent ( const epicsEvent & ); | 47 | epicsEvent ( const epicsEvent & ); |
226 | 39 | epicsEvent & operator = ( const epicsEvent & ); | 48 | epicsEvent & operator = ( const epicsEvent & ); |
227 | 40 | epicsEventId id; | 49 | epicsEventId id; |
228 | 41 | }; | 50 | }; |
229 | 42 | 51 | ||
230 | 43 | #endif /*__cplusplus */ | ||
231 | 44 | |||
232 | 45 | #ifdef __cplusplus | ||
233 | 46 | extern "C" { | 52 | extern "C" { |
234 | 47 | #endif /*__cplusplus */ | 53 | #endif /*__cplusplus */ |
235 | 48 | 54 | ||
249 | 49 | epicsShareFunc epicsEventId epicsShareAPI epicsEventCreate( | 55 | epicsShareFunc epicsEventId epicsEventCreate( |
250 | 50 | epicsEventInitialState initialState); | 56 | epicsEventInitialState initialState); |
251 | 51 | epicsShareFunc epicsEventId epicsShareAPI epicsEventMustCreate ( | 57 | epicsShareFunc epicsEventId epicsEventMustCreate ( |
252 | 52 | epicsEventInitialState initialState); | 58 | epicsEventInitialState initialState); |
253 | 53 | epicsShareFunc void epicsShareAPI epicsEventDestroy(epicsEventId id); | 59 | epicsShareFunc void epicsEventDestroy(epicsEventId id); |
254 | 54 | epicsShareFunc void epicsShareAPI epicsEventSignal(epicsEventId id); | 60 | epicsShareFunc epicsEventStatus epicsEventTrigger( |
255 | 55 | epicsShareFunc epicsEventWaitStatus epicsShareAPI epicsEventWait( | 61 | epicsEventId id); |
256 | 56 | epicsEventId id); | 62 | epicsShareFunc void epicsEventMustTrigger(epicsEventId id); |
257 | 57 | #define epicsEventMustWait(ID) { \ | 63 | #define epicsEventSignal(ID) epicsEventMustTrigger(ID) |
258 | 58 | epicsEventWaitStatus status = epicsEventWait(ID); \ | 64 | epicsShareFunc epicsEventStatus epicsEventWait( |
259 | 59 | assert(status == epicsEventWaitOK); \ | 65 | epicsEventId id); |
260 | 60 | } | 66 | epicsShareFunc void epicsEventMustWait(epicsEventId id); |
261 | 61 | epicsShareFunc epicsEventWaitStatus epicsShareAPI epicsEventWaitWithTimeout( | 67 | epicsShareFunc epicsEventStatus epicsEventWaitWithTimeout( |
262 | 62 | epicsEventId id, double timeOut); | 68 | epicsEventId id, double timeOut); |
264 | 63 | epicsShareFunc epicsEventWaitStatus epicsShareAPI epicsEventTryWait( | 69 | epicsShareFunc epicsEventStatus epicsEventTryWait( |
265 | 64 | epicsEventId id); | 70 | epicsEventId id); |
267 | 65 | epicsShareFunc void epicsShareAPI epicsEventShow( | 71 | epicsShareFunc void epicsEventShow( |
268 | 66 | epicsEventId id, unsigned int level); | 72 | epicsEventId id, unsigned int level); |
269 | 67 | 73 | ||
270 | 68 | #ifdef __cplusplus | 74 | #ifdef __cplusplus |
271 | 69 | 75 | ||
272 | === modified file 'src/libCom/osi/os/RTEMS/osdEvent.c' | |||
273 | --- src/libCom/osi/os/RTEMS/osdEvent.c 2010-10-05 19:27:37 +0000 | |||
274 | +++ src/libCom/osi/os/RTEMS/osdEvent.c 2011-02-08 21:39:58 +0000 | |||
275 | @@ -1,7 +1,8 @@ | |||
276 | 1 | /*************************************************************************\ | 1 | /*************************************************************************\ |
277 | 2 | * Copyright (c) 2002 The University of Saskatchewan | 2 | * Copyright (c) 2002 The University of Saskatchewan |
280 | 3 | * EPICS BASE Versions 3.13.7 | 3 | * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne |
281 | 4 | * and higher are distributed subject to a Software License Agreement found | 4 | * National Laboratory. |
282 | 5 | * EPICS BASE is distributed subject to a Software License Agreement found | ||
283 | 5 | * in file LICENSE that is included with this distribution. | 6 | * in file LICENSE that is included with this distribution. |
284 | 6 | \*************************************************************************/ | 7 | \*************************************************************************/ |
285 | 7 | /* | 8 | /* |
286 | @@ -18,7 +19,6 @@ | |||
287 | 18 | */ | 19 | */ |
288 | 19 | #define __RTEMS_VIOLATE_KERNEL_VISIBILITY__ 1 | 20 | #define __RTEMS_VIOLATE_KERNEL_VISIBILITY__ 1 |
289 | 20 | 21 | ||
290 | 21 | #include <assert.h> | ||
291 | 22 | #include <stdio.h> | 22 | #include <stdio.h> |
292 | 23 | #include <rtems.h> | 23 | #include <rtems.h> |
293 | 24 | #include <rtems/error.h> | 24 | #include <rtems/error.h> |
294 | @@ -84,13 +84,6 @@ | |||
295 | 84 | return (epicsEventId)sid; | 84 | return (epicsEventId)sid; |
296 | 85 | } | 85 | } |
297 | 86 | 86 | ||
298 | 87 | epicsEventId epicsEventMustCreate(epicsEventInitialState initialState) | ||
299 | 88 | { | ||
300 | 89 | epicsEventId id = epicsEventCreate (initialState); | ||
301 | 90 | assert (id); | ||
302 | 91 | return id; | ||
303 | 92 | } | ||
304 | 93 | |||
305 | 94 | void | 87 | void |
306 | 95 | epicsEventDestroy(epicsEventId id) | 88 | epicsEventDestroy(epicsEventId id) |
307 | 96 | { | 89 | { |
308 | @@ -102,18 +95,20 @@ | |||
309 | 102 | errlogPrintf ("Can't destroy semaphore: %s\n", rtems_status_text (sc)); | 95 | errlogPrintf ("Can't destroy semaphore: %s\n", rtems_status_text (sc)); |
310 | 103 | } | 96 | } |
311 | 104 | 97 | ||
314 | 105 | void | 98 | epicsEventStatus |
315 | 106 | epicsEventSignal(epicsEventId id) | 99 | epicsEventTrigger(epicsEventId id) |
316 | 107 | { | 100 | { |
317 | 108 | rtems_id sid = (rtems_id)id; | 101 | rtems_id sid = (rtems_id)id; |
318 | 109 | rtems_status_code sc; | 102 | rtems_status_code sc; |
319 | 110 | 103 | ||
320 | 111 | sc = rtems_semaphore_release (sid); | 104 | sc = rtems_semaphore_release (sid); |
323 | 112 | if (sc != RTEMS_SUCCESSFUL) | 105 | if (sc == RTEMS_SUCCESSFUL) |
324 | 113 | errlogPrintf ("Can't release semaphore: %s\n", rtems_status_text (sc)); | 106 | return epicsEventOK; |
325 | 107 | errlogPrintf ("Can't release semaphore: %s\n", rtems_status_text (sc)); | ||
326 | 108 | return epicsEventError; | ||
327 | 114 | } | 109 | } |
328 | 115 | 110 | ||
330 | 116 | epicsEventWaitStatus | 111 | epicsEventStatus |
331 | 117 | epicsEventWait(epicsEventId id) | 112 | epicsEventWait(epicsEventId id) |
332 | 118 | { | 113 | { |
333 | 119 | rtems_id sid = (rtems_id)id; | 114 | rtems_id sid = (rtems_id)id; |
334 | @@ -122,11 +117,11 @@ | |||
335 | 122 | SEMSTAT(0) | 117 | SEMSTAT(0) |
336 | 123 | sc = rtems_semaphore_obtain (sid, RTEMS_WAIT, RTEMS_NO_TIMEOUT); | 118 | sc = rtems_semaphore_obtain (sid, RTEMS_WAIT, RTEMS_NO_TIMEOUT); |
337 | 124 | if (sc != RTEMS_SUCCESSFUL) | 119 | if (sc != RTEMS_SUCCESSFUL) |
340 | 125 | return epicsEventWaitError; | 120 | return epicsEventError; |
341 | 126 | return epicsEventWaitOK; | 121 | return epicsEventOK; |
342 | 127 | } | 122 | } |
343 | 128 | 123 | ||
345 | 129 | epicsEventWaitStatus | 124 | epicsEventStatus |
346 | 130 | epicsEventWaitWithTimeout(epicsEventId id, double timeOut) | 125 | epicsEventWaitWithTimeout(epicsEventId id, double timeOut) |
347 | 131 | { | 126 | { |
348 | 132 | rtems_id sid = (rtems_id)id; | 127 | rtems_id sid = (rtems_id)id; |
349 | @@ -142,14 +137,14 @@ | |||
350 | 142 | delay++; | 137 | delay++; |
351 | 143 | sc = rtems_semaphore_obtain (sid, RTEMS_WAIT, delay); | 138 | sc = rtems_semaphore_obtain (sid, RTEMS_WAIT, delay); |
352 | 144 | if (sc == RTEMS_SUCCESSFUL) | 139 | if (sc == RTEMS_SUCCESSFUL) |
354 | 145 | return epicsEventWaitOK; | 140 | return epicsEventOK; |
355 | 146 | else if (sc == RTEMS_TIMEOUT) | 141 | else if (sc == RTEMS_TIMEOUT) |
356 | 147 | return epicsEventWaitTimeout; | 142 | return epicsEventWaitTimeout; |
357 | 148 | else | 143 | else |
359 | 149 | return epicsEventWaitError; | 144 | return epicsEventError; |
360 | 150 | } | 145 | } |
361 | 151 | 146 | ||
363 | 152 | epicsEventWaitStatus | 147 | epicsEventStatus |
364 | 153 | epicsEventTryWait(epicsEventId id) | 148 | epicsEventTryWait(epicsEventId id) |
365 | 154 | { | 149 | { |
366 | 155 | rtems_id sid = (rtems_id)id; | 150 | rtems_id sid = (rtems_id)id; |
367 | @@ -158,11 +153,11 @@ | |||
368 | 158 | SEMSTAT(2) | 153 | SEMSTAT(2) |
369 | 159 | sc = rtems_semaphore_obtain (sid, RTEMS_NO_WAIT, RTEMS_NO_TIMEOUT); | 154 | sc = rtems_semaphore_obtain (sid, RTEMS_NO_WAIT, RTEMS_NO_TIMEOUT); |
370 | 160 | if (sc == RTEMS_SUCCESSFUL) | 155 | if (sc == RTEMS_SUCCESSFUL) |
372 | 161 | return epicsEventWaitOK; | 156 | return epicsEventOK; |
373 | 162 | else if (sc == RTEMS_UNSATISFIED) | 157 | else if (sc == RTEMS_UNSATISFIED) |
374 | 163 | return epicsEventWaitTimeout; | 158 | return epicsEventWaitTimeout; |
375 | 164 | else | 159 | else |
377 | 165 | return epicsEventWaitError; | 160 | return epicsEventError; |
378 | 166 | } | 161 | } |
379 | 167 | 162 | ||
380 | 168 | void | 163 | void |
381 | 169 | 164 | ||
382 | === modified file 'src/libCom/osi/os/WIN32/osdEvent.c' | |||
383 | --- src/libCom/osi/os/WIN32/osdEvent.c 2010-10-05 19:27:37 +0000 | |||
384 | +++ src/libCom/osi/os/WIN32/osdEvent.c 2011-02-08 21:39:58 +0000 | |||
385 | @@ -1,10 +1,9 @@ | |||
386 | 1 | /*************************************************************************\ | 1 | /*************************************************************************\ |
388 | 2 | * Copyright (c) 2002 The University of Chicago, as Operator of Argonne | 2 | * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne |
389 | 3 | * National Laboratory. | 3 | * National Laboratory. |
390 | 4 | * Copyright (c) 2002 The Regents of the University of California, as | 4 | * Copyright (c) 2002 The Regents of the University of California, as |
391 | 5 | * Operator of Los Alamos National Laboratory. | 5 | * Operator of Los Alamos National Laboratory. |
394 | 6 | * EPICS BASE Versions 3.13.7 | 6 | * EPICS BASE is distributed subject to a Software License Agreement found |
393 | 7 | * and higher are distributed subject to a Software License Agreement found | ||
395 | 8 | * in file LICENSE that is included with this distribution. | 7 | * in file LICENSE that is included with this distribution. |
396 | 9 | \*************************************************************************/ | 8 | \*************************************************************************/ |
397 | 10 | /* osdEvent.c */ | 9 | /* osdEvent.c */ |
398 | @@ -27,7 +26,6 @@ | |||
399 | 27 | #define epicsExportSharedSymbols | 26 | #define epicsExportSharedSymbols |
400 | 28 | #include "shareLib.h" | 27 | #include "shareLib.h" |
401 | 29 | #include "epicsEvent.h" | 28 | #include "epicsEvent.h" |
402 | 30 | #include "epicsAssert.h" | ||
403 | 31 | 29 | ||
404 | 32 | typedef struct epicsEventOSD { | 30 | typedef struct epicsEventOSD { |
405 | 33 | HANDLE handle; | 31 | HANDLE handle; |
406 | @@ -36,7 +34,7 @@ | |||
407 | 36 | /* | 34 | /* |
408 | 37 | * epicsEventCreate () | 35 | * epicsEventCreate () |
409 | 38 | */ | 36 | */ |
411 | 39 | epicsShareFunc epicsEventId epicsShareAPI epicsEventCreate ( | 37 | epicsShareFunc epicsEventId epicsEventCreate ( |
412 | 40 | epicsEventInitialState initialState ) | 38 | epicsEventInitialState initialState ) |
413 | 41 | { | 39 | { |
414 | 42 | epicsEventOSD *pSem; | 40 | epicsEventOSD *pSem; |
415 | @@ -54,54 +52,43 @@ | |||
416 | 54 | } | 52 | } |
417 | 55 | 53 | ||
418 | 56 | /* | 54 | /* |
419 | 57 | * epicsEventMustCreate () | ||
420 | 58 | */ | ||
421 | 59 | epicsShareFunc epicsEventId epicsShareAPI epicsEventMustCreate ( | ||
422 | 60 | epicsEventInitialState initialState ) | ||
423 | 61 | { | ||
424 | 62 | epicsEventId id = epicsEventCreate ( initialState ); | ||
425 | 63 | assert ( id ); | ||
426 | 64 | return id; | ||
427 | 65 | } | ||
428 | 66 | |||
429 | 67 | /* | ||
430 | 68 | * epicsEventDestroy () | 55 | * epicsEventDestroy () |
431 | 69 | */ | 56 | */ |
433 | 70 | epicsShareFunc void epicsShareAPI epicsEventDestroy ( epicsEventId pSem ) | 57 | epicsShareFunc void epicsEventDestroy ( epicsEventId pSem ) |
434 | 71 | { | 58 | { |
435 | 72 | CloseHandle ( pSem->handle ); | 59 | CloseHandle ( pSem->handle ); |
436 | 73 | free ( pSem ); | 60 | free ( pSem ); |
437 | 74 | } | 61 | } |
438 | 75 | 62 | ||
439 | 76 | /* | 63 | /* |
441 | 77 | * epicsEventSignal () | 64 | * epicsEventTrigger () |
442 | 78 | */ | 65 | */ |
444 | 79 | epicsShareFunc void epicsShareAPI epicsEventSignal ( epicsEventId pSem ) | 66 | epicsShareFunc epicsEventStatus epicsEventTrigger ( epicsEventId pSem ) |
445 | 80 | { | 67 | { |
446 | 81 | BOOL status; | 68 | BOOL status; |
447 | 82 | status = SetEvent ( pSem->handle ); | 69 | status = SetEvent ( pSem->handle ); |
449 | 83 | assert ( status ); | 70 | return status ? epicsEventOK : epicsEventError; |
450 | 84 | } | 71 | } |
451 | 85 | 72 | ||
452 | 86 | /* | 73 | /* |
453 | 87 | * epicsEventWait () | 74 | * epicsEventWait () |
454 | 88 | */ | 75 | */ |
456 | 89 | epicsShareFunc epicsEventWaitStatus epicsShareAPI epicsEventWait ( epicsEventId pSem ) | 76 | epicsShareFunc epicsEventStatus epicsEventWait ( epicsEventId pSem ) |
457 | 90 | { | 77 | { |
458 | 91 | DWORD status; | 78 | DWORD status; |
459 | 92 | status = WaitForSingleObject (pSem->handle, INFINITE); | 79 | status = WaitForSingleObject (pSem->handle, INFINITE); |
460 | 93 | if ( status == WAIT_OBJECT_0 ) { | 80 | if ( status == WAIT_OBJECT_0 ) { |
462 | 94 | return epicsEventWaitOK; | 81 | return epicsEventOK; |
463 | 95 | } | 82 | } |
464 | 96 | else { | 83 | else { |
466 | 97 | return epicsEventWaitError; | 84 | return epicsEventError; |
467 | 98 | } | 85 | } |
468 | 99 | } | 86 | } |
469 | 100 | 87 | ||
470 | 101 | /* | 88 | /* |
471 | 102 | * epicsEventWaitWithTimeout () | 89 | * epicsEventWaitWithTimeout () |
472 | 103 | */ | 90 | */ |
474 | 104 | epicsShareFunc epicsEventWaitStatus epicsShareAPI epicsEventWaitWithTimeout ( | 91 | epicsShareFunc epicsEventStatus epicsEventWaitWithTimeout ( |
475 | 105 | epicsEventId pSem, double timeOut ) | 92 | epicsEventId pSem, double timeOut ) |
476 | 106 | { | 93 | { |
477 | 107 | static const unsigned mSecPerSec = 1000; | 94 | static const unsigned mSecPerSec = 1000; |
478 | @@ -122,38 +109,38 @@ | |||
479 | 122 | } | 109 | } |
480 | 123 | status = WaitForSingleObject ( pSem->handle, tmo ); | 110 | status = WaitForSingleObject ( pSem->handle, tmo ); |
481 | 124 | if ( status == WAIT_OBJECT_0 ) { | 111 | if ( status == WAIT_OBJECT_0 ) { |
483 | 125 | return epicsEventWaitOK; | 112 | return epicsEventOK; |
484 | 126 | } | 113 | } |
485 | 127 | else if ( status == WAIT_TIMEOUT ) { | 114 | else if ( status == WAIT_TIMEOUT ) { |
486 | 128 | return epicsEventWaitTimeout; | 115 | return epicsEventWaitTimeout; |
487 | 129 | } | 116 | } |
488 | 130 | else { | 117 | else { |
490 | 131 | return epicsEventWaitError; | 118 | return epicsEventError; |
491 | 132 | } | 119 | } |
492 | 133 | } | 120 | } |
493 | 134 | 121 | ||
494 | 135 | /* | 122 | /* |
495 | 136 | * epicsEventTryWait () | 123 | * epicsEventTryWait () |
496 | 137 | */ | 124 | */ |
498 | 138 | epicsShareFunc epicsEventWaitStatus epicsShareAPI epicsEventTryWait ( epicsEventId pSem ) | 125 | epicsShareFunc epicsEventStatus epicsEventTryWait ( epicsEventId pSem ) |
499 | 139 | { | 126 | { |
500 | 140 | DWORD status; | 127 | DWORD status; |
501 | 141 | 128 | ||
502 | 142 | status = WaitForSingleObject ( pSem->handle, 0 ); | 129 | status = WaitForSingleObject ( pSem->handle, 0 ); |
503 | 143 | if ( status == WAIT_OBJECT_0 ) { | 130 | if ( status == WAIT_OBJECT_0 ) { |
505 | 144 | return epicsEventWaitOK; | 131 | return epicsEventOK; |
506 | 145 | } | 132 | } |
507 | 146 | else if ( status == WAIT_TIMEOUT ) { | 133 | else if ( status == WAIT_TIMEOUT ) { |
508 | 147 | return epicsEventWaitTimeout; | 134 | return epicsEventWaitTimeout; |
509 | 148 | } | 135 | } |
510 | 149 | else { | 136 | else { |
512 | 150 | return epicsEventWaitError; | 137 | return epicsEventError; |
513 | 151 | } | 138 | } |
514 | 152 | } | 139 | } |
515 | 153 | 140 | ||
516 | 154 | /* | 141 | /* |
517 | 155 | * epicsEventShow () | 142 | * epicsEventShow () |
518 | 156 | */ | 143 | */ |
520 | 157 | epicsShareFunc void epicsShareAPI epicsEventShow ( epicsEventId id, unsigned level ) | 144 | epicsShareFunc void epicsEventShow ( epicsEventId id, unsigned level ) |
521 | 158 | { | 145 | { |
522 | 159 | } | 146 | } |
523 | 160 | 147 | ||
524 | === modified file 'src/libCom/osi/os/posix/osdEvent.c' | |||
525 | --- src/libCom/osi/os/posix/osdEvent.c 2009-04-23 18:49:40 +0000 | |||
526 | +++ src/libCom/osi/os/posix/osdEvent.c 2011-02-08 21:39:58 +0000 | |||
527 | @@ -1,5 +1,5 @@ | |||
528 | 1 | /*************************************************************************\ | 1 | /*************************************************************************\ |
530 | 2 | * Copyright (c) 2009 UChicago Argonne LLC, as Operator of Argonne | 2 | * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne |
531 | 3 | * National Laboratory. | 3 | * National Laboratory. |
532 | 4 | * Copyright (c) 2002 The Regents of the University of California, as | 4 | * Copyright (c) 2002 The Regents of the University of California, as |
533 | 5 | * Operator of Los Alamos National Laboratory. | 5 | * Operator of Los Alamos National Laboratory. |
534 | @@ -21,155 +21,142 @@ | |||
535 | 21 | 21 | ||
536 | 22 | #define epicsExportSharedSymbols | 22 | #define epicsExportSharedSymbols |
537 | 23 | #include "epicsEvent.h" | 23 | #include "epicsEvent.h" |
538 | 24 | #include "cantProceed.h" | ||
539 | 25 | #include "epicsTime.h" | 24 | #include "epicsTime.h" |
540 | 26 | #include "errlog.h" | 25 | #include "errlog.h" |
541 | 27 | #include "epicsAssert.h" | ||
542 | 28 | 26 | ||
543 | 29 | /* Until these can be demonstrated to work leave them undefined*/ | 27 | /* Until these can be demonstrated to work leave them undefined*/ |
544 | 30 | #undef _POSIX_THREAD_PROCESS_SHARED | 28 | #undef _POSIX_THREAD_PROCESS_SHARED |
545 | 31 | #undef _POSIX_THREAD_PRIO_INHERIT | 29 | #undef _POSIX_THREAD_PRIO_INHERIT |
546 | 32 | 30 | ||
547 | 33 | typedef struct epicsEventOSD { | ||
548 | 34 | pthread_mutex_t mutex; | ||
549 | 35 | pthread_cond_t cond; | ||
550 | 36 | int isFull; | ||
551 | 37 | }epicsEventOSD; | ||
552 | 38 | |||
553 | 39 | 31 | ||
554 | 40 | #define checkStatus(status,message) \ | ||
555 | 41 | if((status)) { \ | ||
556 | 42 | errlogPrintf("epicsEvent %s failed: error %s\n",(message),strerror((status)));} | ||
557 | 43 | |||
558 | 44 | #define checkStatusQuit(status,message,method) \ | ||
559 | 45 | if(status) { \ | ||
560 | 46 | errlogPrintf("epicsEvent %s failed: error %s\n",(message),strerror((status))); \ | ||
561 | 47 | cantProceed((method)); \ | ||
562 | 48 | } | ||
563 | 49 | |||
564 | 50 | static int mutexLock(pthread_mutex_t *id) | ||
565 | 51 | { | ||
566 | 52 | int status; | ||
567 | 53 | |||
568 | 54 | while(1) { | ||
569 | 55 | status = pthread_mutex_lock(id); | ||
570 | 56 | if(status!=EINTR) return status; | ||
571 | 57 | errlogPrintf("pthread_mutex_lock returned EINTR. Violates SUSv3\n"); | ||
572 | 58 | } | ||
573 | 59 | } | ||
574 | 60 | |||
575 | 61 | static int condTimedwait(pthread_cond_t *condId, pthread_mutex_t *mutexId, | ||
576 | 62 | struct timespec *time) | ||
577 | 63 | { | ||
578 | 64 | int status; | ||
579 | 65 | while(1) { | ||
580 | 66 | status = pthread_cond_timedwait(condId,mutexId,time); | ||
581 | 67 | if(status!=EINTR) return status; | ||
582 | 68 | errlogPrintf("pthread_cond_timedwait returned EINTR. Violates SUSv3\n"); | ||
583 | 69 | } | ||
584 | 70 | } | ||
585 | 71 | |||
586 | 72 | static int condWait(pthread_cond_t *condId, pthread_mutex_t *mutexId) | ||
587 | 73 | { | ||
588 | 74 | int status; | ||
589 | 75 | while(1) { | ||
590 | 76 | status = pthread_cond_wait(condId,mutexId); | ||
591 | 77 | if(status!=EINTR) return status; | ||
592 | 78 | errlogPrintf("pthread_cond_wait returned EINTR. Violates SUSv3\n"); | ||
593 | 79 | } | ||
594 | 80 | } | ||
595 | 81 | |||
596 | 82 | 32 | ||
624 | 83 | epicsShareFunc epicsEventId epicsShareAPI epicsEventCreate(epicsEventInitialState initialState) | 33 | struct epicsEventOSD { |
625 | 84 | { | 34 | pthread_mutex_t mutex; |
626 | 85 | epicsEventOSD *pevent; | 35 | pthread_cond_t cond; |
627 | 86 | int status; | 36 | int isFull; |
628 | 87 | 37 | }; | |
629 | 88 | pevent = callocMustSucceed(1,sizeof(*pevent),"epicsEventCreate"); | 38 | |
630 | 89 | status = pthread_mutex_init(&pevent->mutex,0); | 39 | #define printStatus(status, routine, func) \ |
631 | 90 | checkStatusQuit(status,"pthread_mutex_init","epicsEventCreate"); | 40 | errlogPrintf("%s: %s failed: %s\n", (func), (routine), strerror(status)) |
632 | 91 | status = pthread_cond_init(&pevent->cond,0); | 41 | |
633 | 92 | checkStatusQuit(status,"pthread_cond_init","epicsEventCreate"); | 42 | #define checkStatus(status, routine, func) \ |
634 | 93 | if(initialState==epicsEventFull) pevent->isFull = 1; | 43 | if (status) { \ |
635 | 94 | return((epicsEventId)pevent); | 44 | printStatus(status, routine, func); \ |
636 | 95 | } | 45 | } |
637 | 96 | 46 | ||
638 | 97 | epicsShareFunc epicsEventId epicsShareAPI epicsEventMustCreate(epicsEventInitialState initialState) | 47 | #define checkStatusReturn(status, routine, func) \ |
639 | 98 | { | 48 | if (status) { \ |
640 | 99 | epicsEventId id = epicsEventCreate (initialState); | 49 | printStatus(status, routine, func); \ |
641 | 100 | assert (id); | 50 | return epicsEventError; \ |
642 | 101 | return id; | 51 | } |
643 | 102 | } | 52 | |
644 | 103 | 53 | ||
645 | 104 | epicsShareFunc void epicsShareAPI epicsEventDestroy(epicsEventId pevent) | 54 | epicsShareFunc epicsEventId epicsEventCreate(epicsEventInitialState init) |
646 | 105 | { | 55 | { |
647 | 106 | int status; | 56 | epicsEventId pevent = malloc(sizeof(*pevent)); |
648 | 107 | 57 | ||
649 | 108 | status = pthread_mutex_destroy(&pevent->mutex); | 58 | if (pevent) { |
650 | 109 | checkStatus(status,"pthread_mutex_destroy"); | 59 | int status = pthread_mutex_init(&pevent->mutex, 0); |
651 | 60 | |||
652 | 61 | pevent->isFull = (init == epicsEventFull); | ||
653 | 62 | if (status) { | ||
654 | 63 | printStatus(status, "pthread_mutex_init", "epicsEventCreate"); | ||
655 | 64 | } else { | ||
656 | 65 | status = pthread_cond_init(&pevent->cond, 0); | ||
657 | 66 | if (!status) | ||
658 | 67 | return pevent; | ||
659 | 68 | printStatus(status, "pthread_cond_init", "epicsEventCreate"); | ||
660 | 69 | status = pthread_mutex_destroy(&pevent->mutex); | ||
661 | 70 | checkStatus(status, "pthread_mutex_destroy", "epicsEventCreate"); | ||
662 | 71 | } | ||
663 | 72 | free(pevent); | ||
664 | 73 | } | ||
665 | 74 | return NULL; | ||
666 | 75 | } | ||
667 | 76 | |||
668 | 77 | epicsShareFunc void epicsEventDestroy(epicsEventId pevent) | ||
669 | 78 | { | ||
670 | 79 | int status = pthread_mutex_destroy(&pevent->mutex); | ||
671 | 80 | |||
672 | 81 | checkStatus(status, "pthread_mutex_destroy", "epicsEventDestroy"); | ||
673 | 110 | status = pthread_cond_destroy(&pevent->cond); | 82 | status = pthread_cond_destroy(&pevent->cond); |
675 | 111 | checkStatus(status,"pthread_cond_destroy"); | 83 | checkStatus(status, "pthread_cond_destroy", "epicsEventDestroy"); |
676 | 112 | free(pevent); | 84 | free(pevent); |
677 | 113 | } | 85 | } |
678 | 114 | 86 | ||
680 | 115 | epicsShareFunc void epicsShareAPI epicsEventSignal(epicsEventId pevent) | 87 | epicsShareFunc epicsEventStatus epicsEventTrigger(epicsEventId pevent) |
681 | 116 | { | 88 | { |
683 | 117 | int status; | 89 | int status = pthread_mutex_lock(&pevent->mutex); |
684 | 118 | 90 | ||
688 | 119 | status = mutexLock(&pevent->mutex); | 91 | checkStatusReturn(status, "pthread_mutex_lock", "epicsEventTrigger"); |
689 | 120 | checkStatusQuit(status,"pthread_mutex_lock","epicsEventSignal"); | 92 | if (!pevent->isFull) { |
687 | 121 | if(!pevent->isFull) { | ||
690 | 122 | pevent->isFull = 1; | 93 | pevent->isFull = 1; |
691 | 123 | status = pthread_cond_signal(&pevent->cond); | 94 | status = pthread_cond_signal(&pevent->cond); |
692 | 124 | checkStatus(status,"pthread_cond_signal"); | ||
693 | 125 | } | ||
694 | 126 | status = pthread_mutex_unlock(&pevent->mutex); | ||
695 | 127 | checkStatusQuit(status,"pthread_mutex_unlock","epicsEventSignal"); | ||
696 | 128 | } | ||
697 | 129 | |||
698 | 130 | 95 | ||
746 | 131 | epicsShareFunc epicsEventWaitStatus epicsShareAPI epicsEventWait(epicsEventId pevent) | 96 | checkStatus(status, "pthread_cond_signal", "epicsEventTrigger"); |
747 | 132 | { | 97 | } |
748 | 133 | int status; | 98 | status = pthread_mutex_unlock(&pevent->mutex); |
749 | 134 | 99 | checkStatusReturn(status, "pthread_mutex_unlock", "epicsEventTrigger"); | |
750 | 135 | if(!pevent) return(epicsEventWaitError); | 100 | return epicsEventOK; |
751 | 136 | status = mutexLock(&pevent->mutex); | 101 | } |
752 | 137 | checkStatusQuit(status,"pthread_mutex_lock","epicsEventWait"); | 102 | |
753 | 138 | /*no need for while since caller must be prepared for no work*/ | 103 | epicsShareFunc epicsEventStatus epicsEventWait(epicsEventId pevent) |
754 | 139 | if(!pevent->isFull) { | 104 | { |
755 | 140 | status = condWait(&pevent->cond,&pevent->mutex); | 105 | epicsEventStatus result = epicsEventOK; |
756 | 141 | checkStatusQuit(status,"pthread_cond_wait","epicsEventWait"); | 106 | int status = pthread_mutex_lock(&pevent->mutex); |
757 | 142 | } | 107 | |
758 | 143 | pevent->isFull = 0; | 108 | checkStatusReturn(status, "pthread_mutex_lock", "epicsEventWait"); |
759 | 144 | status = pthread_mutex_unlock(&pevent->mutex); | 109 | while (!pevent->isFull) { |
760 | 145 | checkStatusQuit(status,"pthread_mutex_unlock","epicsEventWait"); | 110 | status = pthread_cond_wait(&pevent->cond, &pevent->mutex); |
761 | 146 | return(epicsEventWaitOK); | 111 | if (status) { |
762 | 147 | } | 112 | printStatus(status, "pthread_cond_wait", "epicsEventWait"); |
763 | 148 | 113 | result = epicsEventError; | |
764 | 149 | epicsShareFunc epicsEventWaitStatus epicsShareAPI epicsEventWaitWithTimeout(epicsEventId pevent, double timeout) | 114 | goto release; |
765 | 150 | { | 115 | } |
766 | 151 | struct timespec wakeTime; | 116 | } |
767 | 152 | int status = 0; | 117 | pevent->isFull = 0; |
768 | 153 | int unlockStatus; | 118 | result = epicsEventOK; |
769 | 154 | 119 | release: | |
770 | 155 | status = mutexLock(&pevent->mutex); | 120 | status = pthread_mutex_unlock(&pevent->mutex); |
771 | 156 | checkStatusQuit(status,"pthread_mutex_lock","epicsEventWaitWithTimeout"); | 121 | checkStatusReturn(status, "pthread_mutex_unlock", "epicsEventWait"); |
772 | 157 | if(!pevent->isFull) { | 122 | return result; |
773 | 158 | convertDoubleToWakeTime(timeout,&wakeTime); | 123 | } |
774 | 159 | status = condTimedwait( | 124 | |
775 | 160 | &pevent->cond,&pevent->mutex,&wakeTime); | 125 | epicsShareFunc epicsEventStatus epicsEventWaitWithTimeout(epicsEventId pevent, |
776 | 161 | } | 126 | double timeout) |
777 | 162 | if(status==0) pevent->isFull = 0; | 127 | { |
778 | 163 | unlockStatus = pthread_mutex_unlock(&pevent->mutex); | 128 | epicsEventStatus result = epicsEventOK; |
779 | 164 | checkStatusQuit(unlockStatus,"pthread_mutex_unlock","epicsEventWaitWithTimeout"); | 129 | int status = pthread_mutex_lock(&pevent->mutex); |
780 | 165 | if(status==0) return(epicsEventWaitOK); | 130 | |
781 | 166 | if(status==ETIMEDOUT) return(epicsEventWaitTimeout); | 131 | checkStatusReturn(status, "pthread_mutex_lock", "epicsEventWaitWithTimeout"); |
782 | 167 | checkStatus(status,"pthread_cond_timedwait"); | 132 | if (!pevent->isFull) { |
783 | 168 | return(epicsEventWaitError); | 133 | struct timespec wakeTime; |
784 | 169 | } | 134 | |
785 | 170 | 135 | convertDoubleToWakeTime(timeout, &wakeTime); | |
786 | 171 | epicsShareFunc epicsEventWaitStatus epicsShareAPI epicsEventTryWait(epicsEventId id) | 136 | while (!status && !pevent->isFull) { |
787 | 172 | { | 137 | status = pthread_cond_timedwait(&pevent->cond, &pevent->mutex, |
788 | 173 | return(epicsEventWaitWithTimeout(id,0.0)); | 138 | &wakeTime); |
789 | 174 | } | 139 | } |
790 | 175 | 140 | if (status) { | |
791 | 176 | epicsShareFunc void epicsShareAPI epicsEventShow(epicsEventId id,unsigned int level) | 141 | result = (status == ETIMEDOUT) ? |
792 | 177 | { | 142 | epicsEventWaitTimeout : epicsEventError; |
793 | 143 | goto release; | ||
794 | 144 | } | ||
795 | 145 | } | ||
796 | 146 | pevent->isFull = 0; | ||
797 | 147 | release: | ||
798 | 148 | status = pthread_mutex_unlock(&pevent->mutex); | ||
799 | 149 | checkStatusReturn(status, "pthread_mutex_unlock", "epicsEventWaitWithTimeout"); | ||
800 | 150 | return result; | ||
801 | 151 | } | ||
802 | 152 | |||
803 | 153 | epicsShareFunc epicsEventStatus epicsEventTryWait(epicsEventId id) | ||
804 | 154 | { | ||
805 | 155 | return epicsEventWaitWithTimeout(id, 0.0); | ||
806 | 156 | } | ||
807 | 157 | |||
808 | 158 | epicsShareFunc void epicsEventShow(epicsEventId pevent, unsigned int level) | ||
809 | 159 | { | ||
810 | 160 | printf("epicsEvent %p: %s\n", pevent, | ||
811 | 161 | pevent->isFull ? "full" : "empty"); | ||
812 | 162 | if (level > 0) | ||
813 | 163 | printf(" pthread_mutex = %p, pthread_cond = %p\n", | ||
814 | 164 | &pevent->mutex, &pevent->cond); | ||
815 | 178 | } | 165 | } |
816 | 179 | 166 | ||
817 | === modified file 'src/libCom/osi/os/vxWorks/osdEvent.c' | |||
818 | --- src/libCom/osi/os/vxWorks/osdEvent.c 2008-09-24 19:24:59 +0000 | |||
819 | +++ src/libCom/osi/os/vxWorks/osdEvent.c 2011-02-08 21:39:58 +0000 | |||
820 | @@ -1,10 +1,9 @@ | |||
821 | 1 | /*************************************************************************\ | 1 | /*************************************************************************\ |
823 | 2 | * Copyright (c) 2002 The University of Chicago, as Operator of Argonne | 2 | * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne |
824 | 3 | * National Laboratory. | 3 | * National Laboratory. |
825 | 4 | * Copyright (c) 2002 The Regents of the University of California, as | 4 | * Copyright (c) 2002 The Regents of the University of California, as |
826 | 5 | * Operator of Los Alamos National Laboratory. | 5 | * Operator of Los Alamos National Laboratory. |
829 | 6 | * EPICS BASE Versions 3.13.7 | 6 | * EPICS BASE is distributed subject to a Software License Agreement found |
828 | 7 | * and higher are distributed subject to a Software License Agreement found | ||
830 | 8 | * in file LICENSE that is included with this distribution. | 7 | * in file LICENSE that is included with this distribution. |
831 | 9 | \*************************************************************************/ | 8 | \*************************************************************************/ |
832 | 10 | /* os/vxWorks/osdEvent.c */ | 9 | /* os/vxWorks/osdEvent.c */ |
833 | @@ -29,19 +28,12 @@ | |||
834 | 29 | (initialState == epicsEventEmpty) ? SEM_EMPTY : SEM_FULL); | 28 | (initialState == epicsEventEmpty) ? SEM_EMPTY : SEM_FULL); |
835 | 30 | } | 29 | } |
836 | 31 | 30 | ||
837 | 32 | epicsEventId epicsEventMustCreate(epicsEventInitialState initialState) | ||
838 | 33 | { | ||
839 | 34 | epicsEventId id = epicsEventCreate(initialState); | ||
840 | 35 | assert(id); | ||
841 | 36 | return id; | ||
842 | 37 | } | ||
843 | 38 | |||
844 | 39 | void epicsEventDestroy(epicsEventId id) | 31 | void epicsEventDestroy(epicsEventId id) |
845 | 40 | { | 32 | { |
846 | 41 | semDelete((SEM_ID)id); | 33 | semDelete((SEM_ID)id); |
847 | 42 | } | 34 | } |
848 | 43 | 35 | ||
850 | 44 | epicsEventWaitStatus epicsEventWaitWithTimeout(epicsEventId id, double timeOut) | 36 | epicsEventStatus epicsEventWaitWithTimeout(epicsEventId id, double timeOut) |
851 | 45 | { | 37 | { |
852 | 46 | int rate = sysClkRateGet(); | 38 | int rate = sysClkRateGet(); |
853 | 47 | int status; | 39 | int status; |
854 | @@ -58,22 +50,22 @@ | |||
855 | 58 | } | 50 | } |
856 | 59 | status = semTake((SEM_ID)id, ticks); | 51 | status = semTake((SEM_ID)id, ticks); |
857 | 60 | if (status == OK) | 52 | if (status == OK) |
859 | 61 | return epicsEventWaitOK; | 53 | return epicsEventOK; |
860 | 62 | if (errno == S_objLib_OBJ_TIMEOUT || | 54 | if (errno == S_objLib_OBJ_TIMEOUT || |
861 | 63 | (errno == S_objLib_OBJ_UNAVAILABLE && ticks == 0)) | 55 | (errno == S_objLib_OBJ_UNAVAILABLE && ticks == 0)) |
862 | 64 | return epicsEventWaitTimeout; | 56 | return epicsEventWaitTimeout; |
864 | 65 | return epicsEventWaitError; | 57 | return epicsEventError; |
865 | 66 | } | 58 | } |
866 | 67 | 59 | ||
868 | 68 | epicsEventWaitStatus epicsEventTryWait(epicsEventId id) | 60 | epicsEventStatus epicsEventTryWait(epicsEventId id) |
869 | 69 | { | 61 | { |
870 | 70 | int status = semTake((SEM_ID)id, NO_WAIT); | 62 | int status = semTake((SEM_ID)id, NO_WAIT); |
871 | 71 | 63 | ||
872 | 72 | if (status == OK) | 64 | if (status == OK) |
874 | 73 | return epicsEventWaitOK; | 65 | return epicsEventOK; |
875 | 74 | if (errno == S_objLib_OBJ_UNAVAILABLE) | 66 | if (errno == S_objLib_OBJ_UNAVAILABLE) |
876 | 75 | return epicsEventWaitTimeout; | 67 | return epicsEventWaitTimeout; |
878 | 76 | return epicsEventWaitError; | 68 | return epicsEventError; |
879 | 77 | } | 69 | } |
880 | 78 | 70 | ||
881 | 79 | void epicsEventShow(epicsEventId id, unsigned int level) | 71 | void epicsEventShow(epicsEventId id, unsigned int level) |
882 | 80 | 72 | ||
883 | === modified file 'src/libCom/osi/os/vxWorks/osdEvent.h' | |||
884 | --- src/libCom/osi/os/vxWorks/osdEvent.h 2002-07-12 21:35:43 +0000 | |||
885 | +++ src/libCom/osi/os/vxWorks/osdEvent.h 2011-02-08 21:39:58 +0000 | |||
886 | @@ -1,10 +1,9 @@ | |||
887 | 1 | /*************************************************************************\ | 1 | /*************************************************************************\ |
889 | 2 | * Copyright (c) 2002 The University of Chicago, as Operator of Argonne | 2 | * Copyright (c) 2011 UChicago Argonne LLC, as Operator of Argonne |
890 | 3 | * National Laboratory. | 3 | * National Laboratory. |
891 | 4 | * Copyright (c) 2002 The Regents of the University of California, as | 4 | * Copyright (c) 2002 The Regents of the University of California, as |
892 | 5 | * Operator of Los Alamos National Laboratory. | 5 | * Operator of Los Alamos National Laboratory. |
895 | 6 | * EPICS BASE Versions 3.13.7 | 6 | * EPICS BASE is distributed subject to a Software License Agreement found |
894 | 7 | * and higher are distributed subject to a Software License Agreement found | ||
896 | 8 | * in file LICENSE that is included with this distribution. | 7 | * in file LICENSE that is included with this distribution. |
897 | 9 | \*************************************************************************/ | 8 | \*************************************************************************/ |
898 | 10 | /* os/vxWorks/osdEvent.h */ | 9 | /* os/vxWorks/osdEvent.h */ |
899 | @@ -14,12 +13,8 @@ | |||
900 | 14 | #include <vxWorks.h> | 13 | #include <vxWorks.h> |
901 | 15 | #include <semLib.h> | 14 | #include <semLib.h> |
902 | 16 | 15 | ||
909 | 17 | /* If the macro is replaced by inline it is necessary to say | 16 | #define epicsEventTrigger(ID) \ |
910 | 18 | static __inline__ | 17 | (semGive((SEM_ID)(ID)) == OK ? epicsEventOK : epicsEventError) |
905 | 19 | but then a warning message appears everywhere osdEvent.h is included | ||
906 | 20 | */ | ||
907 | 21 | |||
908 | 22 | #define epicsEventSignal(ID) semGive((SEM_ID)(ID)) | ||
911 | 23 | 18 | ||
912 | 24 | #define epicsEventWait(ID) \ | 19 | #define epicsEventWait(ID) \ |
914 | 25 | (semTake((SEM_ID)(ID),WAIT_FOREVER)==OK ? epicsEventWaitOK : epicsEventWaitError) | 20 | (semTake((SEM_ID)(ID), WAIT_FOREVER) == OK ? epicsEventOK : epicsEventError) |
If nobody has any comments on this branch it will be merged into 3.15 at the Codeathon next week.