lkml.org 
[lkml]   [2005]   [Sep]   [22]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Subject[RFC][PATCH 1/2] Reduced NTP rework (part 1)
    From
    Date
    Roman, All,

    With Roman's suggestions, I've been working on reducing the footprint
    of my timeofday patches. This is the first of two patches that I wanted
    to float by the list for feedback before I merge it into my patchset.

    This patch reworks some of the interrupt time NTP adjustments so that it
    could be re-used with the timeofday patches. The motivation of the
    change is to logically separate the code which adjusts xtime and the
    code that decides (based on the NTP state variables) how much per tick
    to adjust xtime.

    Thus this patch should not affect the existing behavior, but just
    separate the logical functionality so it can be re-used.

    This is mainly for review, so I don't think anyone will really use it,
    but it applies ontop of my ntp-shift-right_A3 cleanup patch I sent out
    earlier.

    thanks
    -john

    linux-2.6.14-rc2_timeofday-ntp-part1_B6test.patch
    ============================================
    diff --git a/kernel/timer.c b/kernel/timer.c
    --- a/kernel/timer.c
    +++ b/kernel/timer.c
    @@ -742,46 +742,47 @@ static void second_overflow(void)
    #endif
    }

    -/* in the NTP reference this is called "hardclock()" */
    -static void update_wall_time_one_tick(void)
    +long time_adjust_step;
    +
    +static void ntp_advance(unsigned long interval_ns)
    {
    - long time_adjust_step, delta_nsec;
    + static unsigned long interval_sum;

    - if ( (time_adjust_step = time_adjust) != 0 ) {
    - /* We are doing an adjtime thing.
    - *
    - * Prepare time_adjust_step to be within bounds.
    - * Note that a positive time_adjust means we want the clock
    - * to run faster.
    - *
    - * Limit the amount of the step to be in the range
    - * -tickadj .. +tickadj
    - */
    - time_adjust_step = min(time_adjust_step, (long)tickadj);
    - time_adjust_step = max(time_adjust_step, (long)-tickadj);
    + /* increment the interval sum */
    + interval_sum += interval_ns;

    - /* Reduce by this step the amount of time left */
    - time_adjust -= time_adjust_step;
    - }
    - delta_nsec = tick_nsec + time_adjust_step * 1000;
    - /*
    - * Advance the phase, once it gets to one microsecond, then
    - * advance the tick more.
    - */
    - time_phase += time_adj;
    - if ((time_phase >= FINENSEC) || (time_phase <= -FINENSEC)) {
    - long ltemp = shift_right(time_phase, (SHIFT_SCALE - 10));
    - time_phase -= ltemp << (SHIFT_SCALE - 10);
    - delta_nsec += ltemp;
    + /* calculate the per tick singleshot adjtime adjustment step */
    + while (interval_ns >= tick_nsec) {
    + time_adjust_step = time_adjust;
    + if (time_adjust_step) {
    + /* We are doing an adjtime thing.
    + *
    + * Prepare time_adjust_step to be within bounds.
    + * Note that a positive time_adjust means we want the clock
    + * to run faster.
    + *
    + * Limit the amount of the step to be in the range
    + * -tickadj .. +tickadj
    + */
    + time_adjust_step = min(time_adjust_step, (long)tickadj);
    + time_adjust_step = max(time_adjust_step, (long)-tickadj);
    +
    + /* Reduce by this step the amount of time left */
    + time_adjust -= time_adjust_step;
    + }
    + interval_ns -= tick_nsec;
    }
    - xtime.tv_nsec += delta_nsec;
    - time_interpolator_update(delta_nsec);

    /* Changes by adjtime() do not take effect till next tick. */
    - if (time_next_adjust != 0) {
    + if (time_next_adjust) {
    time_adjust = time_next_adjust;
    time_next_adjust = 0;
    }
    +
    + while (interval_sum > NSEC_PER_SEC) {
    + interval_sum -= NSEC_PER_SEC;
    + second_overflow();
    + }
    }

    /*
    @@ -793,14 +794,35 @@ static void update_wall_time_one_tick(vo
    */
    static void update_wall_time(unsigned long ticks)
    {
    + long delta_nsec;
    +
    do {
    ticks--;
    - update_wall_time_one_tick();
    +
    + /* Calculate the nsec delta using the
    + * precomputed NTP adjustments:
    + * tick_nsec, time_adjust_step, time_adj
    + */
    + delta_nsec = tick_nsec + time_adjust_step * 1000;
    + /*
    + * Advance the phase, once it gets to one microsecond, then
    + * advance the tick more.
    + */
    + time_phase += time_adj;
    + if ((time_phase >= FINENSEC) || (time_phase <= -FINENSEC)) {
    + long ltemp = shift_right(time_phase, (SHIFT_SCALE - 10));
    + time_phase -= ltemp << (SHIFT_SCALE - 10);
    + delta_nsec += ltemp;
    + }
    +
    + xtime.tv_nsec += delta_nsec;
    if (xtime.tv_nsec >= 1000000000) {
    xtime.tv_nsec -= 1000000000;
    xtime.tv_sec++;
    - second_overflow();
    }
    + ntp_advance(tick_nsec);
    + time_interpolator_update(delta_nsec);
    +
    } while (ticks);
    }


    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2005-09-22 22:01    [W:0.028 / U:0.892 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site