michaelh/zephyr
1
0
Fork 0
Code Releases Activity

sys_clock.h: Make "global variable" APIs into proper functions

Browse source 
The existing API defined sys_clock_{hw_cycles,ticks}_per_sec as simple
"variables" to be shared, except that they were only real storage in
certain modes (the HPET driver, basically) and everywhere else they
were a build constant.

Properly, these should be an API defined by the timer driver (who
controls those rates) and consumed by the clock subsystem.  So give
them function syntax as a stepping stone to get there.

Note that this also removes the deprecated variable
_sys_clock_us_per_tick rather than give it the same treatment.

Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
This commit is contained in:
Andy Ross 2018-09-19 10:52:07 -07:00 • committed by Anas Nashif
commit 220d4f8347
14 changed files with 57 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

2
drivers/adc/adc_ti_adc108s102.c
View file

@ -186,7 +186,7 @@ static int ti_adc108s102_read(struct device *dev,
/* convert to milliseconds */
delay = (s32_t)((MSEC_PER_SEC * (u64_t)delay) /
sys_clock_ticks_per_sec);
sys_clock_ticks_per_sec());
k_sleep(delay);

4
drivers/sensor/dht/dht.c
View file

@ -34,7 +34,7 @@ static s8_t dht_measure_signal_duration(struct dht_data *drv_data,
u32_t elapsed_cycles;
u32_t max_wait_cycles = (u32_t)(
(u64_t)DHT_SIGNAL_MAX_WAIT_DURATION *
(u64_t)sys_clock_hw_cycles_per_sec /
(u64_t)sys_clock_hw_cycles_per_sec() /
(u64_t)USEC_PER_SEC
);
u32_t start_cycles = k_cycle_get_32();
@ -50,7 +50,7 @@ static s8_t dht_measure_signal_duration(struct dht_data *drv_data,
return (u64_t)elapsed_cycles *
(u64_t)USEC_PER_SEC /
(u64_t)sys_clock_hw_cycles_per_sec;
(u64_t)sys_clock_hw_cycles_per_sec();
}
static int dht_sample_fetch(struct device *dev, enum sensor_channel chan)

7
drivers/timer/hpet.c
View file

@ -159,6 +159,7 @@
#define HPET_IOAPIC_FLAGS (IOAPIC_LEVEL | IOAPIC_LOW)
#endif
extern int z_clock_hw_cycles_per_sec;
#ifdef CONFIG_INT_LATENCY_BENCHMARK
static u32_t main_count_first_irq_value;
@ -583,7 +584,7 @@ int _sys_clock_driver_init(struct device *device)
* Get tick time (in femptoseconds).
*/
tickFempto = 1000000000000000ull / sys_clock_ticks_per_sec;
tickFempto = 1000000000000000ull / sys_clock_ticks_per_sec();
/*
* This driver shall read the COUNTER_CLK_PERIOD value from the general
@ -613,8 +614,8 @@ int _sys_clock_driver_init(struct device *device)
/* Initialize sys_clock_hw_cycles_per_tick/sec */
sys_clock_hw_cycles_per_tick = counter_load_value;
sys_clock_hw_cycles_per_sec = sys_clock_hw_cycles_per_tick *
sys_clock_ticks_per_sec;
z_clock_hw_cycles_per_sec = sys_clock_hw_cycles_per_tick *
sys_clock_ticks_per_sec();
#ifdef CONFIG_INT_LATENCY_BENCHMARK

2
drivers/timer/loapic_timer.c
View file

@ -765,7 +765,7 @@ u32_t _timer_cycle_get_32(void)
u64_t tsc;
/* 64-bit math to avoid overflows */
tsc = _tsc_read() * (u64_t)sys_clock_hw_cycles_per_sec /
tsc = _tsc_read() * (u64_t)sys_clock_hw_cycles_per_sec() /
(u64_t) CONFIG_TSC_CYCLES_PER_SEC;
return (u32_t)tsc;
#else

2
drivers/timer/native_posix_timer.c
View file

@ -103,7 +103,7 @@ int _sys_clock_driver_init(struct device *device)
{
ARG_UNUSED(device);
tick_period = 1000000ul / sys_clock_ticks_per_sec;
tick_period = 1000000ul / sys_clock_ticks_per_sec();
hwtimer_enable(tick_period);

44
include/sys_clock.h
View file

@ -26,20 +26,30 @@ extern "C" {
#include <toolchain.h>
#include <zephyr/types.h>
static inline int sys_clock_ticks_per_sec(void)
{
#ifdef CONFIG_TICKLESS_KERNEL
return 1000000 / (CONFIG_TICKLESS_KERNEL_TIME_UNIT_IN_MICRO_SECS);
#else
return CONFIG_SYS_CLOCK_TICKS_PER_SEC;
#endif
}
#ifdef CONFIG_TICKLESS_KERNEL
#define sys_clock_ticks_per_sec \
(1000000 / (CONFIG_TICKLESS_KERNEL_TIME_UNIT_IN_MICRO_SECS))
extern int _sys_clock_always_on;
extern void _enable_sys_clock(void);
#else
#define sys_clock_ticks_per_sec CONFIG_SYS_CLOCK_TICKS_PER_SEC
#endif
static inline int sys_clock_hw_cycles_per_sec(void)
{
#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
extern int sys_clock_hw_cycles_per_sec;
extern int z_clock_hw_cycles_per_sec;
return z_clock_hw_cycles_per_sec;
#else
#define sys_clock_hw_cycles_per_sec CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC
return CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC;
#endif
}
#if defined(CONFIG_SYS_CLOCK_EXISTS) && \
(CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC == 0)
@ -74,9 +84,9 @@ extern int sys_clock_hw_cycles_per_sec;
*/
#if !defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
#if (sys_clock_hw_cycles_per_sec % sys_clock_ticks_per_sec) != 0
#if (CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC % CONFIG_SYS_CLOCK_TICKS_PER_SEC) != 0
#define _NEED_PRECISE_TICK_MS_CONVERSION
#elif (MSEC_PER_SEC % sys_clock_ticks_per_sec) != 0
#elif (MSEC_PER_SEC % CONFIG_SYS_CLOCK_TICKS_PER_SEC) != 0
#define _NON_OPTIMIZED_TICKS_PER_SEC
#endif
#endif
@ -94,12 +104,12 @@ static ALWAYS_INLINE s32_t _ms_to_ticks(s32_t ms)
#ifdef _NEED_PRECISE_TICK_MS_CONVERSION
/* use 64-bit math to keep precision */
return (s32_t)ceiling_fraction(
(s64_t)ms * sys_clock_hw_cycles_per_sec,
((s64_t)MSEC_PER_SEC * sys_clock_hw_cycles_per_sec) /
sys_clock_ticks_per_sec);
(s64_t)ms * sys_clock_hw_cycles_per_sec(),
((s64_t)MSEC_PER_SEC * sys_clock_hw_cycles_per_sec()) /
sys_clock_ticks_per_sec());
#else
/* simple division keeps precision */
s32_t ms_per_tick = MSEC_PER_SEC / sys_clock_ticks_per_sec;
s32_t ms_per_tick = MSEC_PER_SEC / sys_clock_ticks_per_sec();
return (s32_t)ceiling_fraction(ms, ms_per_tick);
#endif
@ -116,10 +126,10 @@ static inline s64_t __ticks_to_ms(s64_t ticks)
#ifdef _NEED_PRECISE_TICK_MS_CONVERSION
/* use 64-bit math to keep precision */
return (u64_t)ticks * MSEC_PER_SEC / sys_clock_ticks_per_sec;
return (u64_t)ticks * MSEC_PER_SEC / sys_clock_ticks_per_sec();
#else
/* simple multiplication keeps precision */
u32_t ms_per_tick = MSEC_PER_SEC / sys_clock_ticks_per_sec;
u32_t ms_per_tick = MSEC_PER_SEC / sys_clock_ticks_per_sec();
return (u64_t)ticks * ms_per_tick;
#endif
@ -155,7 +165,7 @@ extern int sys_clock_hw_cycles_per_tick;
/* SYS_CLOCK_HW_CYCLES_TO_NS64 converts CPU clock cycles to nanoseconds */
#define SYS_CLOCK_HW_CYCLES_TO_NS64(X) \
(((u64_t)(X) * NSEC_PER_SEC) / sys_clock_hw_cycles_per_sec)
(((u64_t)(X) * NSEC_PER_SEC) / sys_clock_hw_cycles_per_sec())
/*
* SYS_CLOCK_HW_CYCLES_TO_NS_AVG converts CPU clock cycles to nanoseconds
@ -206,11 +216,11 @@ extern s32_t _timeout_remaining_get(struct _timeout *timeout);
/*
* Number of ticks for x seconds. NOTE: With MSEC() or USEC(),
* since it does an integer division, x must be greater or equal to
* 1000/sys_clock_ticks_per_sec to get a non-zero value.
* 1000/sys_clock_ticks_per_sec() to get a non-zero value.
* You may want to raise CONFIG_SYS_CLOCK_TICKS_PER_SEC depending on
* your requirements.
*/
#define SECONDS(x) ((x) * sys_clock_ticks_per_sec)
#define SECONDS(x) ((x) * sys_clock_ticks_per_sec())
#define MSEC(x) (SECONDS(x) / MSEC_PER_SEC)
#define USEC(x) (MSEC(x) / USEC_PER_MSEC)

8
kernel/sys_clock.c
View file

@ -21,18 +21,16 @@
#endif
#ifdef CONFIG_SYS_CLOCK_EXISTS
int sys_clock_us_per_tick = 1000000 / sys_clock_ticks_per_sec;
int sys_clock_hw_cycles_per_tick =
CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC / sys_clock_ticks_per_sec;
CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC / CONFIG_SYS_CLOCK_TICKS_PER_SEC;
#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
int sys_clock_hw_cycles_per_sec = CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC;
int z_clock_hw_cycles_per_sec = CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC;
#endif
#else
/* don't initialize to avoid division-by-zero error */
int sys_clock_us_per_tick;
int sys_clock_hw_cycles_per_tick;
#if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
int sys_clock_hw_cycles_per_sec;
int z_clock_hw_cycles_per_sec;
#endif
#endif

2
kernel/thread.c
View file

@ -104,7 +104,7 @@ int saved_always_on = k_enable_sys_clock_always_on();
/* use 64-bit math to prevent overflow when multiplying */
u32_t cycles_to_wait = (u32_t)(
(u64_t)usec_to_wait *
(u64_t)sys_clock_hw_cycles_per_sec /
(u64_t)sys_clock_hw_cycles_per_sec() /
(u64_t)USEC_PER_SEC
);
u32_t start_cycles = k_cycle_get_32();

4
samples/net/zperf/src/zperf_internal.h
View file

@ -40,7 +40,7 @@
#define HW_CYCLES_TO_USEC(__hw_cycle__) \
( \
((u64_t)(__hw_cycle__) * (u64_t)USEC_PER_SEC) / \
((u64_t)sys_clock_hw_cycles_per_sec) \
((u64_t)sys_clock_hw_cycles_per_sec()) \
)
#define HW_CYCLES_TO_SEC(__hw_cycle__) \
@ -51,7 +51,7 @@
#define USEC_TO_HW_CYCLES(__usec__) \
( \
((u64_t)(__usec__) * (u64_t)sys_clock_hw_cycles_per_sec) / \
((u64_t)(__usec__) * (u64_t)sys_clock_hw_cycles_per_sec()) / \
((u64_t)USEC_PER_SEC) \
)

10
tests/benchmarks/app_kernel/src/master.h
View file

@ -35,10 +35,10 @@
/* length of the output line */
#define SLINE_LEN 256
#define SLEEP_TIME ((sys_clock_ticks_per_sec / 4) > 0 ? \
sys_clock_ticks_per_sec / 4 : 1)
#define WAIT_TIME ((sys_clock_ticks_per_sec / 10) > 0 ? \
sys_clock_ticks_per_sec / 10 : 1)
#define SLEEP_TIME ((sys_clock_ticks_per_sec() / 4) > 0 ? \
sys_clock_ticks_per_sec() / 4 : 1)
#define WAIT_TIME ((sys_clock_ticks_per_sec() / 10) > 0 ? \
sys_clock_ticks_per_sec() / 10 : 1)
#define NR_OF_NOP_RUNS 10000
#define NR_OF_FIFO_RUNS 500
#define NR_OF_SEMA_RUNS 500
@ -48,7 +48,7 @@
#define NR_OF_EVENT_RUNS 1000
#define NR_OF_MBOX_RUNS 128
#define NR_OF_PIPE_RUNS 256
/* #define SEMA_WAIT_TIME (5 * sys_clock_ticks_per_sec) */
/* #define SEMA_WAIT_TIME (5 * sys_clock_ticks_per_sec()) */
#define SEMA_WAIT_TIME (5000)
/* global data */
extern char msg[MAX_MSG];

2
tests/kernel/common/src/clock.c
View file

@ -124,7 +124,7 @@ void test_clock_cycle(void)
if (c1 > c0) {
/* delta cycle should be greater than 1 milli-second*/
zassert_true((c1 - c0) >
(sys_clock_hw_cycles_per_sec / MSEC_PER_SEC), NULL);
(sys_clock_hw_cycles_per_sec() / MSEC_PER_SEC), NULL);
/* delta NS should be greater than 1 milli-second */
zassert_true(SYS_CLOCK_HW_CYCLES_TO_NS(c1 - c0) >
(NSEC_PER_SEC / MSEC_PER_SEC), NULL);

4
tests/kernel/mem_pool/mem_pool/src/main.c
View file

@ -22,8 +22,8 @@
#include <tc_util.h>
#include <misc/util.h>
#define ONE_SECOND (sys_clock_ticks_per_sec)
#define TENTH_SECOND (sys_clock_ticks_per_sec / 10)
#define ONE_SECOND (CONFIG_SYS_CLOCK_TICKS_PER_SEC)
#define TENTH_SECOND (CONFIG_SYS_CLOCK_TICKS_PER_SEC / 10)
#define NUM_BLOCKS 64

10
tests/kernel/timer/timer_monotonic/src/main.c
View file

@ -19,10 +19,10 @@ int test_frequency(void)
end = k_cycle_get_32();
delta = end - start;
pct = (u64_t)delta * 100 / sys_clock_hw_cycles_per_sec;
pct = (u64_t)delta * 100 / sys_clock_hw_cycles_per_sec();
printk("delta: %u expected: %u %u%%\n", delta,
sys_clock_hw_cycles_per_sec, pct);
sys_clock_hw_cycles_per_sec(), pct);
/* Heuristic: if we're more than 10% off, throw an error */
if (pct < 90 || pct > 110) {
@ -45,7 +45,7 @@ int test_frequency(void)
*
* @ingroup kernel_timer_tests
*
* @see k_cycle_get_32(), sys_clock_hw_cycles_per_sec
* @see k_cycle_get_32(), sys_clock_hw_cycles_per_sec()
*/
void test_timer(void)
{
@ -56,8 +56,8 @@ void test_timer(void)
TC_PRINT("sys_clock_hw_cycles_per_tick = %d\n",
sys_clock_hw_cycles_per_tick);
TC_PRINT("sys_clock_hw_cycles_per_sec = %d\n",
sys_clock_hw_cycles_per_sec);
TC_PRINT("sys_clock_hw_cycles_per_sec() = %d\n",
sys_clock_hw_cycles_per_sec());
TC_START("test monotonic timer");

2
tests/ztest/include/ztest.h
View file

@ -39,6 +39,8 @@ extern "C" {
#define CONFIG_NUM_COOP_PRIORITIES 16
#define CONFIG_COOP_ENABLED 1
#define CONFIG_PREEMPT_ENABLED 1
#define CONFIG_SYS_CLOCK_TICKS_PER_SEC 100
#define CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC 10000000
/* FIXME: Properly integrate with Zephyr's arch specific code */
#define CONFIG_X86 1
#define PRINT printf