24 Mar, 2012

1 commit

  • Ensure that the software state for sched_clock() is updated at the
    point of suspend so that we avoid losing ticks since the last update.

    This prevents the platform dependent possibility that sched_clock()
    may appear to go backwards across a suspend/resume cycle.

    Acked-by: Linus Walleij
    Signed-off-by: Russell King

    Russell King
     

19 Dec, 2011

1 commit

  • sched_clock() is yet another blocker on the road to the single
    image. This patch implements an idea by Russell King:

    http://www.spinics.net/lists/linux-omap/msg49561.html

    Instead of asking the platform to implement both sched_clock()
    itself and the rollover callback, simply register a read()
    function, and let the ARM code care about sched_clock() itself,
    the conversion to ns and the rollover. sched_clock() uses
    this read() function as an indirection to the platform code.
    If the platform doesn't provide a read(), the code falls back
    to the jiffy counter (just like the default sched_clock).

    This allow some simplifications and possibly some footprint gain
    when multiple platforms are compiled in. Among the drawbacks,
    the removal of the *_fixed_sched_clock optimization which could
    negatively impact some platforms (sa1100, tegra, versatile
    and omap).

    Tested on 11MPCore, OMAP4 and Tegra.

    Cc: Imre Kaloz
    Cc: Eric Miao
    Cc: Colin Cross
    Cc: Erik Gilling
    Cc: Olof Johansson
    Cc: Sascha Hauer
    Cc: Alessandro Rubini
    Cc: STEricsson
    Cc: Lennert Buytenhek
    Cc: Ben Dooks
    Tested-by: Jamie Iles
    Tested-by: Tony Lindgren
    Tested-by: Kyungmin Park
    Acked-by: Linus Walleij
    Acked-by: Nicolas Pitre
    Acked-by: Krzysztof Halasa
    Acked-by: Kukjin Kim
    Signed-off-by: Marc Zyngier
    Signed-off-by: Russell King

    Marc Zyngier
     

12 Jan, 2011

2 commits

  • The purpose of the minsec argument is to prevent 64-bit math overflow
    when the number of cycles is multiplied up. However, the multipler
    is 32-bit, and in the sched_clock() case, the cycle counter is up to
    32-bit as well. So the math can never overflow.

    With a value of 60, and clock rates greater than 71MHz, the calculated
    multiplier is unnecessarily reduced in value, which reduces accuracy by
    maybe 70ppt. It's almost not worth bothering with as the oscillator
    driving the counter won't be any more than 1ppm - unless you're using
    a rubidium lamp or caesium fountain frequency standard.

    So, set the minsec argument to zero.

    Signed-off-by: Russell King

    Russell King
     
  • sched_clock is supposed to be initialized early - in the recently added
    init_early platform hook. However, in doing so we end up calling
    mod_timer() before the timer lists are initialized, resulting in an
    oops.

    Split the initialization in two - the part which the platform calls
    early which starts things off. The addition of the timer can be
    delayed until after we have more of the kernel initialized - when the
    normal time sources are initialized.

    Signed-off-by: Russell King

    Russell King
     

23 Dec, 2010

1 commit

  • Provide common sched_clock() infrastructure for platforms to use to
    create a 64-bit ns based sched_clock() implementation from a counter
    running at a non-variable clock rate.

    This implementation is based upon maintaining an epoch for the counter
    and an epoch for the nanosecond time. When we desire a sched_clock()
    time, we calculate the number of counter ticks since the last epoch
    update, convert this to nanoseconds and add to the epoch nanoseconds.

    We regularly refresh these epochs within the counter wrap interval.
    We perform a similar calculation as above, and store the new epochs.

    We read and write the epochs in such a way that sched_clock() can easily
    (and locklessly) detect when an update is in progress, and repeat the
    loading of these constants when they're known not to be stable. The
    one caveat is that sched_clock() is not called in the middle of an
    update. We achieve that by disabling IRQs.

    Finally, if the clock rate is known at compile time, the counter to ns
    conversion factors can be specified, allowing sched_clock() to be tightly
    optimized. We ensure that these factors are correct by providing an
    initialization function which performs a run-time check.

    Acked-by: Peter Zijlstra
    Tested-by: Santosh Shilimkar
    Tested-by: Will Deacon
    Tested-by: Mikael Pettersson
    Tested-by: Eric Miao
    Tested-by: Olof Johansson
    Tested-by: Jamie Iles
    Reviewed-by: Nicolas Pitre
    Signed-off-by: Russell King

    Russell King