ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
Revision: 1.3
Committed: Tue Oct 30 21:45:00 2007 UTC (16 years, 8 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.2: +2 -14 lines
Log Message:
*** empty log message ***

File Contents

# Content
1 #include <math.h>
2 #include <stdlib.h>
3
4 #include <stdio.h>
5
6 #include <errno.h>
7 #include <sys/time.h>
8 #include <time.h>
9
10 #ifdef CLOCK_MONOTONIC
11 # define HAVE_MONOTONIC 1
12 #endif
13
14 #define HAVE_EPOLL 1
15 #define HAVE_REALTIME 1
16 #define HAVE_SELECT 0
17
18 #define MAX_BLOCKTIME 60.
19
20 #include "ev.h"
21
22 struct ev_watcher {
23 EV_WATCHER (ev_watcher);
24 };
25
26 struct ev_watcher_list {
27 EV_WATCHER_LIST (ev_watcher_list);
28 };
29
30 ev_tstamp ev_now;
31 int ev_method;
32
33 static int have_monotonic; /* runtime */
34
35 static ev_tstamp method_fudge; /* stupid epoll-returns-early bug */
36 static void (*method_reify)(void);
37 static void (*method_poll)(ev_tstamp timeout);
38
39 ev_tstamp
40 ev_time (void)
41 {
42 #if HAVE_REALTIME
43 struct timespec ts;
44 clock_gettime (CLOCK_REALTIME, &ts);
45 return ts.tv_sec + ts.tv_nsec * 1e-9;
46 #else
47 struct timeval tv;
48 gettimeofday (&tv, 0);
49 return tv.tv_sec + tv.tv_usec * 1e-6;
50 #endif
51 }
52
53 static ev_tstamp
54 get_clock (void)
55 {
56 #if HAVE_MONOTONIC
57 if (have_monotonic)
58 {
59 struct timespec ts;
60 clock_gettime (CLOCK_MONOTONIC, &ts);
61 return ts.tv_sec + ts.tv_nsec * 1e-9;
62 }
63 #endif
64
65 return ev_time ();
66 }
67
68 #define array_needsize(base,cur,cnt,init) \
69 if ((cnt) > cur) \
70 { \
71 int newcnt = cur ? cur << 1 : 16; \
72 fprintf (stderr, "resize(" # base ") from %d to %d\n", cur, newcnt);\
73 base = realloc (base, sizeof (*base) * (newcnt)); \
74 init (base + cur, newcnt - cur); \
75 cur = newcnt; \
76 }
77
78 typedef struct
79 {
80 struct ev_io *head;
81 unsigned char wev, rev; /* want, received event set */
82 } ANFD;
83
84 static ANFD *anfds;
85 static int anfdmax;
86
87 static int *fdchanges;
88 static int fdchangemax, fdchangecnt;
89
90 static void
91 anfds_init (ANFD *base, int count)
92 {
93 while (count--)
94 {
95 base->head = 0;
96 base->wev = base->rev = EV_NONE;
97 ++base;
98 }
99 }
100
101 typedef struct
102 {
103 struct ev_watcher *w;
104 int events;
105 } ANPENDING;
106
107 static ANPENDING *pendings;
108 static int pendingmax, pendingcnt;
109
110 static void
111 event (struct ev_watcher *w, int events)
112 {
113 w->pending = ++pendingcnt;
114 array_needsize (pendings, pendingmax, pendingcnt, );
115 pendings [pendingcnt - 1].w = w;
116 pendings [pendingcnt - 1].events = events;
117 }
118
119 static void
120 fd_event (int fd, int events)
121 {
122 ANFD *anfd = anfds + fd;
123 struct ev_io *w;
124
125 for (w = anfd->head; w; w = w->next)
126 {
127 int ev = w->events & events;
128
129 if (ev)
130 event ((struct ev_watcher *)w, ev);
131 }
132 }
133
134 static struct ev_timer **timers;
135 static int timermax, timercnt;
136
137 static void
138 upheap (int k)
139 {
140 struct ev_timer *w = timers [k];
141
142 while (k && timers [k >> 1]->at > w->at)
143 {
144 timers [k] = timers [k >> 1];
145 timers [k]->active = k + 1;
146 k >>= 1;
147 }
148
149 timers [k] = w;
150 timers [k]->active = k + 1;
151
152 }
153
154 static void
155 downheap (int k)
156 {
157 struct ev_timer *w = timers [k];
158
159 while (k < (timercnt >> 1))
160 {
161 int j = k << 1;
162
163 if (j + 1 < timercnt && timers [j]->at > timers [j + 1]->at)
164 ++j;
165
166 if (w->at <= timers [j]->at)
167 break;
168
169 timers [k] = timers [j];
170 timers [k]->active = k + 1;
171 k = j;
172 }
173
174 timers [k] = w;
175 timers [k]->active = k + 1;
176 }
177
178 static struct ev_signal **signals;
179 static int signalmax, signalcnt;
180
181 static void
182 signals_init (struct ev_signal **base, int count)
183 {
184 while (count--)
185 *base++ = 0;
186 }
187
188 #if HAVE_EPOLL
189 # include "ev_epoll.c"
190 #endif
191 #if HAVE_SELECT
192 # include "ev_select.c"
193 #endif
194
195 int ev_init (int flags)
196 {
197 #if HAVE_MONOTONIC
198 {
199 struct timespec ts;
200 if (!clock_gettime (CLOCK_MONOTONIC, &ts))
201 have_monotonic = 1;
202 }
203 #endif
204
205 ev_now = ev_time ();
206
207 #if HAVE_EPOLL
208 if (epoll_init (flags))
209 return ev_method;
210 #endif
211 #if HAVE_SELECT
212 if (select_init (flags))
213 return ev_method;
214 #endif
215
216 ev_method = EVMETHOD_NONE;
217 return ev_method;
218 }
219
220 void ev_prefork (void)
221 {
222 }
223
224 void ev_postfork_parent (void)
225 {
226 }
227
228 void ev_postfork_child (void)
229 {
230 #if HAVE_EPOLL
231 epoll_postfork_child ();
232 #endif
233 }
234
235 static void
236 call_pending ()
237 {
238 int i;
239
240 for (i = 0; i < pendingcnt; ++i)
241 {
242 ANPENDING *p = pendings + i;
243
244 if (p->w)
245 {
246 p->w->pending = 0;
247 p->w->cb (p->w, p->events);
248 }
249 }
250
251 pendingcnt = 0;
252 }
253
254 static void
255 timer_reify (void)
256 {
257 while (timercnt && timers [0]->at <= ev_now)
258 {
259 struct ev_timer *w = timers [0];
260
261 /* first reschedule timer */
262 if (w->repeat)
263 {
264 if (w->is_abs)
265 w->at += ceil ((ev_now - w->at) / w->repeat + 1.) * w->repeat;
266 else
267 w->at = ev_now + w->repeat;
268
269 downheap (0);
270 }
271 else
272 evtimer_stop (w); /* nonrepeating: stop timer */
273
274 event ((struct ev_watcher *)w, EV_TIMEOUT);
275 }
276 }
277
278 int ev_loop_done;
279
280 int ev_loop (int flags)
281 {
282 double block;
283 ev_loop_done = flags & EVLOOP_ONESHOT;
284
285 do
286 {
287 /* update fd-related kernel structures */
288 method_reify (); fdchangecnt = 0;
289
290 /* calculate blocking time */
291 ev_now = ev_time ();
292
293 if (flags & EVLOOP_NONBLOCK)
294 block = 0.;
295 else if (!timercnt)
296 block = MAX_BLOCKTIME;
297 else
298 {
299 block = timers [0]->at - ev_now + method_fudge;
300 if (block < 0.) block = 0.;
301 else if (block > MAX_BLOCKTIME) block = MAX_BLOCKTIME;
302 }
303
304 method_poll (block);
305
306 /* put pending timers into pendign queue and reschedule them */
307 timer_reify ();
308
309 ev_now = ev_time ();
310 call_pending ();
311 }
312 while (!ev_loop_done);
313 }
314
315 static void
316 wlist_add (struct ev_watcher_list **head, struct ev_watcher_list *elem)
317 {
318 elem->next = *head;
319 *head = elem;
320 }
321
322 static void
323 wlist_del (struct ev_watcher_list **head, struct ev_watcher_list *elem)
324 {
325 while (*head)
326 {
327 if (*head == elem)
328 {
329 *head = elem->next;
330 return;
331 }
332
333 head = &(*head)->next;
334 }
335 }
336
337 static void
338 ev_start (struct ev_watcher *w, int active)
339 {
340 w->pending = 0;
341 w->active = active;
342 }
343
344 static void
345 ev_stop (struct ev_watcher *w)
346 {
347 if (w->pending)
348 pendings [w->pending - 1].w = 0;
349
350 w->active = 0;
351 /* nop */
352 }
353
354 void
355 evio_start (struct ev_io *w)
356 {
357 if (ev_is_active (w))
358 return;
359
360 int fd = w->fd;
361
362 ev_start ((struct ev_watcher *)w, 1);
363 array_needsize (anfds, anfdmax, fd + 1, anfds_init);
364 wlist_add ((struct ev_watcher_list **)&anfds[fd].head, (struct ev_watcher_list *)w);
365
366 ++fdchangecnt;
367 array_needsize (fdchanges, fdchangemax, fdchangecnt, );
368 fdchanges [fdchangecnt - 1] = fd;
369 }
370
371 void
372 evio_stop (struct ev_io *w)
373 {
374 if (!ev_is_active (w))
375 return;
376
377 wlist_del ((struct ev_watcher_list **)&anfds[w->fd].head, (struct ev_watcher_list *)w);
378 ev_stop ((struct ev_watcher *)w);
379
380 ++fdchangecnt;
381 array_needsize (fdchanges, fdchangemax, fdchangecnt, );
382 fdchanges [fdchangecnt - 1] = w->fd;
383 }
384
385 void
386 evtimer_start (struct ev_timer *w)
387 {
388 if (ev_is_active (w))
389 return;
390
391 if (w->is_abs)
392 {
393 /* this formula differs from the one in timer_reify becuse we do not round up */
394 if (w->repeat)
395 w->at += ceil ((ev_now - w->at) / w->repeat) * w->repeat;
396 }
397 else
398 w->at += ev_now;
399
400 ev_start ((struct ev_watcher *)w, ++timercnt);
401 array_needsize (timers, timermax, timercnt, );
402 timers [timercnt - 1] = w;
403 upheap (timercnt - 1);
404 }
405
406 void
407 evtimer_stop (struct ev_timer *w)
408 {
409 if (!ev_is_active (w))
410 return;
411
412 if (w->active < timercnt--)
413 {
414 timers [w->active - 1] = timers [timercnt];
415 downheap (w->active - 1);
416 }
417
418 ev_stop ((struct ev_watcher *)w);
419 }
420
421 void
422 evsignal_start (struct ev_signal *w)
423 {
424 if (ev_is_active (w))
425 return;
426
427 ev_start ((struct ev_watcher *)w, 1);
428 array_needsize (signals, signalmax, w->signum, signals_init);
429 wlist_add ((struct ev_watcher_list **)&signals [w->signum - 1], (struct ev_watcher_list *)w);
430 }
431
432 void
433 evsignal_stop (struct ev_signal *w)
434 {
435 if (!ev_is_active (w))
436 return;
437
438 wlist_del ((struct ev_watcher_list **)&signals [w->signum - 1], (struct ev_watcher_list *)w);
439 ev_stop ((struct ev_watcher *)w);
440 }
441
442 /*****************************************************************************/
443 #if 1
444
445 static void
446 sin_cb (struct ev_io *w, int revents)
447 {
448 fprintf (stderr, "sin %d, revents %d\n", w->fd, revents);
449 }
450
451 static void
452 ocb (struct ev_timer *w, int revents)
453 {
454 fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data);
455 }
456
457 int main (void)
458 {
459 struct ev_io sin;
460
461 ev_init (0);
462
463 evw_init (&sin, sin_cb, 55);
464 evio_set (&sin, 0, EV_READ);
465 evio_start (&sin);
466
467 struct ev_timer t[1000];
468
469 int i;
470 for (i = 0; i < 1000; ++i)
471 {
472 struct ev_timer *w = t + i;
473 evw_init (w, ocb, i);
474 evtimer_set_rel (w, drand48 (), 0);
475 evtimer_start (w);
476 if (drand48 () < 0.5)
477 evtimer_stop (w);
478 }
479
480 ev_loop (0);
481
482 return 0;
483 }
484
485 #endif
486
487
488
489