… | |
… | |
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 | } |