

@ 1306,69 +1306,61 @@ idle_reify (EV_P) 



} 



#endif 







int inline_size 



time_update_monotonic (EV_P) 



{ 



mn_now = get_clock (); 







if (expect_true (mn_now  now_floor < MIN_TIMEJUMP * .5)) 



{ 



ev_rt_now = rtmn_diff + mn_now; 



return 0; 



} 



else 



{ 



now_floor = mn_now; 



ev_rt_now = ev_time (); 



return 1; 



} 



} 







void inline_size 



time_update (EV_P) 



void inline_speed 



time_update (EV_P_ ev_tstamp max_block) 



{ 



int i; 







#if EV_USE_MONOTONIC 



if (expect_true (have_monotonic)) 



{ 



if (time_update_monotonic (EV_A)) 



ev_tstamp odiff = rtmn_diff; 







mn_now = get_clock (); 







/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */ 



/* interpolate in the meantime */ 



if (expect_true (mn_now  now_floor < MIN_TIMEJUMP * .5)) 



{ 



ev_tstamp odiff = rtmn_diff; 







/* loop a few times, before making important decisions. 



* on the choice of "4": one iteration isn't enough, 



* in case we get preempted during the calls to 



* ev_time and get_clock. a second call is almost guaranteed 



* to succeed in that case, though. and looping a few more times 



* doesn't hurt either as we only do this on timejumps or 



* in the unlikely event of having been preempted here. 



*/ 



for (i = 4; i; ) 



{ 



rtmn_diff = ev_rt_now  mn_now; 



ev_rt_now = rtmn_diff + mn_now; 



return; 



} 







if (fabs (odiff  rtmn_diff) < MIN_TIMEJUMP) 



return; /* all is well */ 



now_floor = mn_now; 



ev_rt_now = ev_time (); 







ev_rt_now = ev_time (); 



mn_now = get_clock (); 



now_floor = mn_now; 



} 



/* loop a few times, before making important decisions. 



* on the choice of "4": one iteration isn't enough, 



* in case we get preempted during the calls to 



* ev_time and get_clock. a second call is almost guaranteed 



* to succeed in that case, though. and looping a few more times 



* doesn't hurt either as we only do this on timejumps or 



* in the unlikely event of having been preempted here. 



*/ 



for (i = 4; i; ) 



{ 



rtmn_diff = ev_rt_now  mn_now; 







if (fabs (odiff  rtmn_diff) < MIN_TIMEJUMP) 



return; /* all is well */ 







ev_rt_now = ev_time (); 



mn_now = get_clock (); 



now_floor = mn_now; 



} 







# if EV_PERIODIC_ENABLE 



periodics_reschedule (EV_A); 



periodics_reschedule (EV_A); 



# endif 



/* no timer adjustment, as the monotonic clock doesn't jump */ 



/* timers_reschedule (EV_A_ rtmn_diff  odiff) */ 



} 



/* no timer adjustment, as the monotonic clock doesn't jump */ 



/* timers_reschedule (EV_A_ rtmn_diff  odiff) */ 



} 



else 



#endif 



{ 



ev_rt_now = ev_time (); 







if (expect_false (mn_now > ev_rt_now  mn_now < ev_rt_now  MAX_BLOCKTIME  MIN_TIMEJUMP)) 



if (expect_false (mn_now > ev_rt_now  ev_rt_now > mn_now + max_block + MIN_TIMEJUMP)) 



{ 



#if EV_PERIODIC_ENABLE 



periodics_reschedule (EV_A); 


@ 1452,15 +1444,7 @@ ev_loop (EV_P_ int flags) 



else 



{ 



/* update time to cancel out callback processing overhead */ 



#if EV_USE_MONOTONIC 



if (expect_true (have_monotonic)) 



time_update_monotonic (EV_A); 



else 



#endif 



{ 



ev_rt_now = ev_time (); 



mn_now = ev_rt_now; 



} 



time_update (EV_A_ 1e100); 







block = MAX_BLOCKTIME; 






@ 1483,10 +1467,10 @@ ev_loop (EV_P_ int flags) 







++loop_count; 



backend_poll (EV_A_ block); 



} 







/* update ev_rt_now, do magic */ 



time_update (EV_A); 



/* update ev_rt_now, do magic */ 



time_update (EV_A_ block); 



} 







/* queue pending timers and reschedule them */ 



timers_reify (EV_A); /* relative timers called last */ 


