| … | |
… | |
| 66 | } |
66 | } |
| 67 | |
67 | |
| 68 | #define array_needsize(base,cur,cnt,init) \ |
68 | #define array_needsize(base,cur,cnt,init) \ |
| 69 | if ((cnt) > cur) \ |
69 | if ((cnt) > cur) \ |
| 70 | { \ |
70 | { \ |
| 71 | int newcnt = cur; \ |
71 | int newcnt = cur ? cur << 1 : 16; \ |
| 72 | do \ |
|
|
| 73 | { \ |
|
|
| 74 | newcnt += (newcnt >> 1) + 16; \ |
|
|
| 75 | } \ |
|
|
| 76 | while ((cnt) > newcnt); \ |
|
|
| 77 | fprintf (stderr, "resize(" # base ") from %d to %d\n", cur, newcnt);\ |
72 | fprintf (stderr, "resize(" # base ") from %d to %d\n", cur, newcnt);\ |
| 78 | base = realloc (base, sizeof (*base) * (newcnt)); \ |
73 | base = realloc (base, sizeof (*base) * (newcnt)); \ |
| 79 | init (base + cur, newcnt - cur); \ |
74 | init (base + cur, newcnt - cur); \ |
| 80 | cur = newcnt; \ |
75 | cur = newcnt; \ |
| 81 | } |
76 | } |
| … | |
… | |
| 159 | static void |
154 | static void |
| 160 | downheap (int k) |
155 | downheap (int k) |
| 161 | { |
156 | { |
| 162 | struct ev_timer *w = timers [k]; |
157 | struct ev_timer *w = timers [k]; |
| 163 | |
158 | |
| 164 | while (k <= (timercnt >> 1)) |
159 | while (k < (timercnt >> 1)) |
| 165 | { |
160 | { |
| 166 | int j = k << 1; |
161 | int j = k << 1; |
| 167 | |
162 | |
| 168 | if (j + 1 < timercnt && timers [j]->at > timers [j + 1]->at) |
163 | if (j + 1 < timercnt && timers [j]->at > timers [j + 1]->at) |
| 169 | ++j; |
164 | ++j; |
| 170 | |
165 | |
| 171 | if (w->at <= timers [j]->at) |
166 | if (w->at <= timers [j]->at) |
| 172 | break; |
167 | break; |
| 173 | |
168 | |
| 174 | timers [k] = timers [j]; |
169 | timers [k] = timers [j]; |
| 175 | timers [k]->active = k; |
170 | timers [k]->active = k + 1; |
| 176 | k = j; |
171 | k = j; |
| 177 | } |
172 | } |
| 178 | |
173 | |
| 179 | timers [k] = w; |
174 | timers [k] = w; |
| 180 | timers [k]->active = k + 1; |
175 | timers [k]->active = k + 1; |
| … | |
… | |
| 261 | { |
256 | { |
| 262 | while (timercnt && timers [0]->at <= ev_now) |
257 | while (timercnt && timers [0]->at <= ev_now) |
| 263 | { |
258 | { |
| 264 | struct ev_timer *w = timers [0]; |
259 | struct ev_timer *w = timers [0]; |
| 265 | |
260 | |
|
|
261 | fprintf (stderr, "0 %f, %d c%d\n", w->at, w->active, timercnt);//D |
| 266 | /* first reschedule timer */ |
262 | /* first reschedule timer */ |
| 267 | if (w->repeat) |
263 | if (w->repeat) |
| 268 | { |
264 | { |
| 269 | fprintf (stderr, "a %f now %f repeat %f, %f\n", w->at, ev_now, w->repeat, w->repeat *1e30);//D |
265 | fprintf (stderr, "a %f now %f repeat %f, %f\n", w->at, ev_now, w->repeat, w->repeat *1e30);//D |
| 270 | if (w->is_abs) |
266 | if (w->is_abs) |
| 271 | w->at += floor ((ev_now - w->at) / w->repeat + 1.) * w->repeat; |
267 | w->at += ceil ((ev_now - w->at) / w->repeat + 1.) * w->repeat; |
| 272 | else |
268 | else |
| 273 | w->at = ev_now + w->repeat; |
269 | w->at = ev_now + w->repeat; |
| 274 | |
270 | |
| 275 | fprintf (stderr, "b %f\n", w->at);//D |
271 | fprintf (stderr, "b %f\n", w->at);//D |
| 276 | |
272 | |
| 277 | downheap (0); |
273 | downheap (0); |
| 278 | } |
274 | } |
| 279 | else |
275 | else |
|
|
276 | { |
|
|
277 | fprintf (stderr, "c %f, %d c%d\n", w->at, w->active, timercnt);//D |
| 280 | evtimer_stop (w); /* nonrepeating: stop timer */ |
278 | evtimer_stop (w); /* nonrepeating: stop timer */ |
|
|
279 | } |
| 281 | |
280 | |
| 282 | event ((struct ev_watcher *)w, EV_TIMEOUT); |
281 | event ((struct ev_watcher *)w, EV_TIMEOUT); |
| 283 | } |
282 | } |
| 284 | } |
283 | } |
| 285 | |
284 | |
| … | |
… | |
| 398 | return; |
397 | return; |
| 399 | |
398 | |
| 400 | fprintf (stderr, "t1 %f a %d\n", w->at, w->is_abs);//D |
399 | fprintf (stderr, "t1 %f a %d\n", w->at, w->is_abs);//D |
| 401 | if (w->is_abs) |
400 | if (w->is_abs) |
| 402 | { |
401 | { |
|
|
402 | /* this formula differs from the one in timer_reify becuse we do not round up */ |
| 403 | if (w->repeat) |
403 | if (w->repeat) |
| 404 | w->at += ceil ((ev_now - w->at) / w->repeat) * w->repeat; |
404 | w->at += ceil ((ev_now - w->at) / w->repeat) * w->repeat; |
| 405 | } |
405 | } |
| 406 | else |
406 | else |
| 407 | w->at += ev_now; |
407 | w->at += ev_now; |
| … | |
… | |
| 414 | } |
414 | } |
| 415 | |
415 | |
| 416 | void |
416 | void |
| 417 | evtimer_stop (struct ev_timer *w) |
417 | evtimer_stop (struct ev_timer *w) |
| 418 | { |
418 | { |
|
|
419 | fprintf (stderr, "-topping %d, %d\n", w->active, timercnt);//D |
| 419 | if (!ev_is_active (w)) |
420 | if (!ev_is_active (w)) |
| 420 | return; |
421 | return; |
| 421 | |
422 | |
|
|
423 | fprintf (stderr, "stopping %d, %d\n", w->active, timercnt);//D |
|
|
424 | if (w->active < timercnt) |
|
|
425 | { |
| 422 | timers [w->active - 1] = timers [--timercnt]; |
426 | timers [w->active - 1] = timers [--timercnt]; |
| 423 | downheap (w->active - 1); |
427 | downheap (w->active - 1); |
|
|
428 | } |
|
|
429 | |
| 424 | ev_stop ((struct ev_watcher *)w); |
430 | ev_stop ((struct ev_watcher *)w); |
| 425 | } |
431 | } |
| 426 | |
432 | |
| 427 | void |
433 | void |
| 428 | evsignal_start (struct ev_signal *w) |
434 | evsignal_start (struct ev_signal *w) |
| … | |
… | |
| 468 | |
474 | |
| 469 | evw_init (&sin, sin_cb, 55); |
475 | evw_init (&sin, sin_cb, 55); |
| 470 | evio_set (&sin, 0, EV_READ); |
476 | evio_set (&sin, 0, EV_READ); |
| 471 | evio_start (&sin); |
477 | evio_start (&sin); |
| 472 | |
478 | |
| 473 | struct ev_timer t1; |
479 | struct ev_timer t[1000]; |
|
|
480 | |
|
|
481 | int i; |
|
|
482 | for (i = 0; i < 1000; ++i) |
|
|
483 | { |
|
|
484 | struct ev_timer *w = t + i; |
| 474 | evw_init (&t1, ocb, 1); |
485 | evw_init (w, ocb, i); |
| 475 | evtimer_set_rel (&t1, 1, 0); |
486 | evtimer_set_rel (w, drand48 (), 0); |
| 476 | evtimer_start (&t1); |
487 | evtimer_start (w); |
| 477 | |
488 | if (drand48 () < 0.5) |
| 478 | struct ev_timer t2; |
489 | evtimer_stop (w); |
| 479 | evw_init (&t2, ocb, 2); |
490 | } |
| 480 | evtimer_set_abs (&t2, ev_time () + 2, 0); |
|
|
| 481 | evtimer_start (&t2); |
|
|
| 482 | |
491 | |
| 483 | ev_loop (0); |
492 | ev_loop (0); |
| 484 | |
493 | |
| 485 | return 0; |
494 | return 0; |
| 486 | } |
495 | } |
