timestamp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2015 Wind River Systems, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
/*
 * @file macroses for measuring time in benchmarking tests
 *
 * This file contains the macroses for taking and converting time for
 * benchmarking tests.
 */
 
#ifndef _TIMESTAMP_H_
#define _TIMESTAMP_H_
#include <zephyr/kernel.h>
 
#include <limits.h>
#if defined(__GNUC__)
#include <zephyr/test_asm_inline_gcc.h>
#else
#include <zephyr/test_asm_inline_other.h>
#endif
 
 
#define TICK_SYNCH()  k_sleep(K_TICKS(1))
 
#define OS_GET_TIME() k_cycle_get_32()
 
/* time necessary to read the time */
extern uint32_t tm_off;
 
static inline uint32_t TIME_STAMP_DELTA_GET(uint32_t ts)
{
        uint32_t t;
 
        /* serialize so OS_GET_TIME() is not reordered */
        timestamp_serialize();
 
        t = OS_GET_TIME();
        uint32_t res = (t >= ts) ? (t - ts) : (ULONG_MAX - ts + t);
 
        if (ts > 0) {
                res -= tm_off;
        }
        return res;
}
 
/*
 * Routine initializes the benchmark timing measurement
 * The function sets up the global variable tm_off
 */
static inline void bench_test_init(void)
{
        uint32_t t = OS_GET_TIME();
 
        tm_off = OS_GET_TIME() - t;
}
 
 
/* timestamp for checks */
static int64_t timestamp_check;
 
/*
 * Routines are invoked before and after the benchmark and check
 * if benchmarking code took less time than necessary for the
 * high precision timer register overflow.
 * Functions modify the timestamp_check global variable.
 */
static inline void bench_test_start(void)
{
        timestamp_check = 0;
        /* before reading time we synchronize to the start of the timer tick */
        TICK_SYNCH();
        timestamp_check = k_uptime_delta(&timestamp_check);
}
 
 
/* returns 0 if the completed within a second and -1 if not */
static inline int bench_test_end(void)
{
        timestamp_check = k_uptime_delta(&timestamp_check);
 
        /* Flag an error if the test ran for more than a second.
         * (Note: Existing benchmarks have CONFIG_SYS_CLOCK_TICKS_PER_SEC=1 set,
         * in such configs this check can be an indicator of whether
         * timer tick interrupt overheads too are getting accounted towards
         * benchmark time)
         */
        if (timestamp_check >= MSEC_PER_SEC) {
                return -1;
        }
        return 0;
}
 
/*
 * Returns -1 if number of ticks cause high precision timer counter
 * overflow and 0 otherwise
 * Called after bench_test_end to see if we still can use timing
 * results or is it completely invalid
 */
static inline int high_timer_overflow(void)
{
        /* Check if the time elapsed in msec is sufficient to trigger an
         *  overflow of the high precision timer
         */
        if (timestamp_check >= (k_cyc_to_ns_floor64(UINT_MAX) /
                                (NSEC_PER_USEC * USEC_PER_MSEC))) {
                return -1;
        }
        return 0;
}
 
#endif /* _TIMESTAMP_H_ */