ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
(Generate patch)

Comparing libev/ev.c (file contents):
Revision 1.74 by root, Tue Nov 6 16:51:20 2007 UTC vs.
Revision 1.77 by root, Thu Nov 8 00:44:17 2007 UTC

… …
541 541
542 if (!gotsig) 542 if (!gotsig)
543 { 543 {
544 int old_errno = errno; 544 int old_errno = errno;
545 gotsig = 1; 545 gotsig = 1;
546#ifdef WIN32
547 send (sigpipe [1], &signum, 1, MSG_DONTWAIT);
548#else
546 write (sigpipe [1], &signum, 1); 549 write (sigpipe [1], &signum, 1);
550#endif
547 errno = old_errno; 551 errno = old_errno;
548 } 552 }
549} 553}
550 554
551static void 555static void
552sigcb (EV_P_ struct ev_io *iow, int revents) 556sigcb (EV_P_ struct ev_io *iow, int revents)
553{ 557{
554 WL w; 558 WL w;
555 int signum; 559 int signum;
556 560
561#ifdef WIN32
562 recv (sigpipe [0], &revents, 1, MSG_DONTWAIT);
563#else
557 read (sigpipe [0], &revents, 1); 564 read (sigpipe [0], &revents, 1);
565#endif
558 gotsig = 0; 566 gotsig = 0;
559 567
560 for (signum = signalmax; signum--; ) 568 for (signum = signalmax; signum--; )
561 if (signals [signum].gotsig) 569 if (signals [signum].gotsig)
562 { 570 {
… …
888 if (method) 896 if (method)
889 postfork = 1; 897 postfork = 1;
890} 898}
891 899
892/*****************************************************************************/ 900/*****************************************************************************/
901
902static int
903any_pending (EV_P)
904{
905 int pri;
906
907 for (pri = NUMPRI; pri--; )
908 if (pendingcnt [pri])
909 return 1;
910
911 return 0;
912}
893 913
894static void 914static void
895call_pending (EV_P) 915call_pending (EV_P)
896{ 916{
897 int pri; 917 int pri;
… …
940 struct ev_periodic *w = periodics [0]; 960 struct ev_periodic *w = periodics [0];
941 961
942 assert (("inactive timer on periodic heap detected", ev_is_active (w))); 962 assert (("inactive timer on periodic heap detected", ev_is_active (w)));
943 963
944 /* first reschedule or stop timer */ 964 /* first reschedule or stop timer */
965 if (w->reschedule_cb)
966 {
967 ev_tstamp at = ((WT)w)->at = w->reschedule_cb (w, rt_now + 0.0001);
968
969 assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > rt_now));
970 downheap ((WT *)periodics, periodiccnt, 0);
971 }
945 if (w->interval) 972 else if (w->interval)
946 { 973 {
947 ((WT)w)->at += floor ((rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval; 974 ((WT)w)->at += floor ((rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;
948 assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > rt_now)); 975 assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > rt_now));
949 downheap ((WT *)periodics, periodiccnt, 0); 976 downheap ((WT *)periodics, periodiccnt, 0);
950 } 977 }
… …
963 /* adjust periodics after time jump */ 990 /* adjust periodics after time jump */
964 for (i = 0; i < periodiccnt; ++i) 991 for (i = 0; i < periodiccnt; ++i)
965 { 992 {
966 struct ev_periodic *w = periodics [i]; 993 struct ev_periodic *w = periodics [i];
967 994
995 if (w->reschedule_cb)
996 ((WT)w)->at = w->reschedule_cb (w, rt_now);
968 if (w->interval) 997 else if (w->interval)
969 {
970 ev_tstamp diff = ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval; 998 ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
971
972 if (fabs (diff) >= 1e-4)
973 {
974 ev_periodic_stop (EV_A_ w);
975 ev_periodic_start (EV_A_ w);
976
977 i = 0; /* restart loop, inefficient, but time jumps should be rare */
978 }
979 }
980 } 999 }
1000
1001 /* now rebuild the heap */
1002 for (i = periodiccnt >> 1; i--; )
1003 downheap ((WT *)periodics, periodiccnt, i);
981} 1004}
982 1005
983inline int 1006inline int
984time_update_monotonic (EV_P) 1007time_update_monotonic (EV_P)
985{ 1008{
… …
1081 /* update fd-related kernel structures */ 1104 /* update fd-related kernel structures */
1082 fd_reify (EV_A); 1105 fd_reify (EV_A);
1083 1106
1084 /* calculate blocking time */ 1107 /* calculate blocking time */
1085 1108
1086 /* we only need this for !monotonic clockor timers, but as we basically 1109 /* we only need this for !monotonic clock or timers, but as we basically
1087 always have timers, we just calculate it always */ 1110 always have timers, we just calculate it always */
1088#if EV_USE_MONOTONIC 1111#if EV_USE_MONOTONIC
1089 if (expect_true (have_monotonic)) 1112 if (expect_true (have_monotonic))
1090 time_update_monotonic (EV_A); 1113 time_update_monotonic (EV_A);
1091 else 1114 else
… …
1124 /* queue pending timers and reschedule them */ 1147 /* queue pending timers and reschedule them */
1125 timers_reify (EV_A); /* relative timers called last */ 1148 timers_reify (EV_A); /* relative timers called last */
1126 periodics_reify (EV_A); /* absolute timers called first */ 1149 periodics_reify (EV_A); /* absolute timers called first */
1127 1150
1128 /* queue idle watchers unless io or timers are pending */ 1151 /* queue idle watchers unless io or timers are pending */
1129 if (!pendingcnt) 1152 if (idlecnt && !any_pending (EV_A))
1130 queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE); 1153 queue_events (EV_A_ (W *)idles, idlecnt, EV_IDLE);
1131 1154
1132 /* queue check watchers, to be executed first */ 1155 /* queue check watchers, to be executed first */
1133 if (checkcnt) 1156 if (checkcnt)
1134 queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK); 1157 queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
… …
1289ev_periodic_start (EV_P_ struct ev_periodic *w) 1312ev_periodic_start (EV_P_ struct ev_periodic *w)
1290{ 1313{
1291 if (ev_is_active (w)) 1314 if (ev_is_active (w))
1292 return; 1315 return;
1293 1316
1317 if (w->reschedule_cb)
1318 ((WT)w)->at = w->reschedule_cb (w, rt_now);
1319 else if (w->interval)
1320 {
1294 assert (("ev_periodic_start called with negative interval value", w->interval >= 0.)); 1321 assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
1295
1296 /* this formula differs from the one in periodic_reify because we do not always round up */ 1322 /* this formula differs from the one in periodic_reify because we do not always round up */
1297 if (w->interval)
1298 ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval; 1323 ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
1324 }
1299 1325
1300 ev_start (EV_A_ (W)w, ++periodiccnt); 1326 ev_start (EV_A_ (W)w, ++periodiccnt);
1301 array_needsize (struct ev_periodic *, periodics, periodicmax, periodiccnt, (void)); 1327 array_needsize (struct ev_periodic *, periodics, periodicmax, periodiccnt, (void));
1302 periodics [periodiccnt - 1] = w; 1328 periodics [periodiccnt - 1] = w;
1303 upheap ((WT *)periodics, periodiccnt - 1); 1329 upheap ((WT *)periodics, periodiccnt - 1);
… …
1319 periodics [((W)w)->active - 1] = periodics [periodiccnt]; 1345 periodics [((W)w)->active - 1] = periodics [periodiccnt];
1320 downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1); 1346 downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
1321 } 1347 }
1322 1348
1323 ev_stop (EV_A_ (W)w); 1349 ev_stop (EV_A_ (W)w);
1350}
1351
1352void
1353ev_periodic_again (EV_P_ struct ev_periodic *w)
1354{
1355 ev_periodic_stop (EV_A_ w);
1356 ev_periodic_start (EV_A_ w);
1324} 1357}
1325 1358
1326void 1359void
1327ev_idle_start (EV_P_ struct ev_idle *w) 1360ev_idle_start (EV_P_ struct ev_idle *w)
1328{ 1361{

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines