You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nuttx.apache.org by xi...@apache.org on 2024/10/01 03:40:01 UTC
(nuttx-apps) 07/07: testing/ostest: Fix timing assertions in wdog_test
This is an automated email from the ASF dual-hosted git repository.
xiaoxiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx-apps.git
commit 34e70e7f0c52162f306f9b64bf17df73afd4e052
Author: ouyangxiangzhen <ou...@xiaomi.com>
AuthorDate: Wed Aug 7 15:02:19 2024 +0800
testing/ostest: Fix timing assertions in wdog_test
This patch removed timing assertions in wdog_test.
Signed-off-by: ouyangxiangzhen <ou...@xiaomi.com>
---
testing/ostest/wdog.c | 148 +++++++++++++++++++++++++++++++++++++-------------
1 file changed, 109 insertions(+), 39 deletions(-)
diff --git a/testing/ostest/wdog.c b/testing/ostest/wdog.c
index 1d5cf4ccd..49478ae49 100644
--- a/testing/ostest/wdog.c
+++ b/testing/ostest/wdog.c
@@ -26,9 +26,10 @@
#include <nuttx/arch.h>
#include <nuttx/wdog.h>
+#include <assert.h>
#include <pthread.h>
#include <stdio.h>
-#include <assert.h>
+#include <syslog.h>
#include <unistd.h>
/****************************************************************************
@@ -36,12 +37,12 @@
****************************************************************************/
#define WDOGTEST_RAND_ITER 1024
-#define WDOGTEST_THREAD_NR 8
-#define WDOGTEST_TOLERENT_LATENCY_US 5000
+#define WDOGTEST_THREAD_NR (CONFIG_SMP_NCPUS * 4)
+#define WDOGTEST_TOLERENT_TICK 10
#define wdtest_assert(x) _ASSERT(x, __FILE__, __LINE__)
-#define wdtest_printf(...) printf(__VA_ARGS__)
+#define wdtest_printf(...) syslog(LOG_WARNING, __VA_ARGS__)
#define wdtest_delay(delay_ns) usleep(delay_ns / 1000 + 1)
@@ -64,63 +65,131 @@ typedef struct wdtest_param_s
#ifdef CONFIG_BUILD_FLAT
static void wdtest_callback(wdparm_t param)
{
- struct timespec tp;
FAR wdtest_param_t *wdtest_param = (FAR wdtest_param_t *)param;
- clock_gettime(CLOCK_MONOTONIC, &tp);
+ /* Increment the callback count */
wdtest_param->callback_cnt += 1;
- wdtest_param->triggered_tick = clock_time2ticks(&tp);
+
+ /* Record the system tick at which the callback was triggered */
+
+ wdtest_param->triggered_tick = clock_systime_ticks();
+}
+
+static void wdtest_checkdelay(sclock_t diff, sclock_t delay_tick)
+{
+ /* Ensure the watchdog trigger time is not earlier than expected. */
+
+ wdtest_assert(diff - delay_tick >= 0);
+
+ /* If the timer latency exceeds the tolerance, print a warning. */
+
+ if (diff - delay_tick > WDOGTEST_TOLERENT_TICK)
+ {
+ wdtest_printf("WARNING: wdog latency ticks %lld "
+ "(> %u may indicate timing error)\n",
+ (long long)diff - delay_tick,
+ WDOGTEST_TOLERENT_TICK);
+ }
}
static void wdtest_once(FAR struct wdog_s *wdog, FAR wdtest_param_t *param,
sclock_t delay_ns)
{
- uint64_t cnt;
- long long diff;
- clock_t wdset_tick;
- struct timespec tp;
- clock_t delay_ticks = (clock_t)NSEC2TICK((clock_t)delay_ns);
+ uint64_t cnt;
+ sclock_t diff;
+ clock_t wdset_tick;
+ irqstate_t flags;
+ sclock_t delay_tick = (sclock_t)NSEC2TICK((clock_t)delay_ns);
wdtest_printf("wdtest_once %lld ns\n", (long long)delay_ns);
- clock_gettime(CLOCK_MONOTONIC, &tp);
+ /* Save the current callback count. */
- wdset_tick = clock_time2ticks(&tp);
cnt = param->callback_cnt;
- wdtest_assert(wd_start(wdog, delay_ticks, wdtest_callback,
+ /* Enter a critical section to prevent interruptions. */
+
+ flags = enter_critical_section();
+
+ /* Record the current system tick before setting the watchdog. */
+
+ wdset_tick = clock_systime_ticks();
+
+ wdtest_assert(wd_start(wdog, delay_tick, wdtest_callback,
(wdparm_t)param) == OK);
- wdtest_delay(delay_ns);
+ leave_critical_section(flags);
- diff = (long long)(param->triggered_tick - wdset_tick);
+ /* Wait until the callback is triggered exactly once. */
- wdtest_assert(cnt + 1 == param->callback_cnt);
+ while (cnt + 1 != param->callback_cnt)
+ {
+ wdtest_delay(delay_ns);
+ }
+
+ /* Check if the delay is within the acceptable tolerance. */
- /* Ensure diff - delay_ticks >= 0. */
+ diff = (sclock_t)(param->triggered_tick - wdset_tick);
- wdtest_assert(diff - (long long)delay_ticks >= 0);
- wdtest_printf("wdtest_once latency ticks %lld\n", diff - delay_ticks);
+ wdtest_checkdelay(diff, delay_tick);
}
static void wdtest_rand(FAR struct wdog_s *wdog, FAR wdtest_param_t *param,
sclock_t rand_ns)
{
- int idx;
- sclock_t delay_ns;
+ uint64_t cnt;
+ int idx;
+ sclock_t delay_ns;
+ clock_t wdset_tick;
+ sclock_t delay_tick;
+ sclock_t diff;
+ irqstate_t flags;
+
+ /* Perform multiple iterations with random delays. */
for (idx = 0; idx < WDOGTEST_RAND_ITER; idx++)
{
+ cnt = param->callback_cnt;
+
+ /* Generate a random delay within the specified range. */
+
delay_ns = rand() % rand_ns;
- wdtest_assert(wd_start(wdog, NSEC2TICK(delay_ns), wdtest_callback,
+ delay_tick = NSEC2TICK(delay_ns);
+
+ /* Enter critical section if the callback count is odd. */
+
+ if (cnt % 2)
+ {
+ flags = enter_critical_section();
+ }
+
+ wdset_tick = clock_systime_ticks();
+ wdtest_assert(wd_start(wdog, delay_tick, wdtest_callback,
(wdparm_t)param) == 0);
+ if (cnt % 2)
+ {
+ leave_critical_section(flags);
+ }
- /* Wait or Cancel 50/50 */
+ /* Decide to wait for the callback or cancel the watchdog. */
if (delay_ns % 2)
{
- wdtest_delay(delay_ns);
+ /* Wait for the callback. */
+
+ while (cnt + 1 != param->callback_cnt)
+ {
+ wdtest_delay(delay_ns);
+ }
+
+ /* Check the delay if the callback count is odd. */
+
+ if (cnt % 2)
+ {
+ diff = (sclock_t)(param->triggered_tick - wdset_tick);
+ wdtest_checkdelay(diff, delay_tick);
+ }
}
else
{
@@ -131,14 +200,11 @@ static void wdtest_rand(FAR struct wdog_s *wdog, FAR wdtest_param_t *param,
static void wdtest_callback_recursive(wdparm_t param)
{
- struct timespec tp;
FAR wdtest_param_t *wdtest_param = (FAR wdtest_param_t *)param;
sclock_t interval = wdtest_param->interval;
- clock_gettime(CLOCK_MONOTONIC, &tp);
-
wdtest_param->callback_cnt += 1;
- wdtest_param->triggered_tick = clock_time2ticks(&tp);
+ wdtest_param->triggered_tick = clock_systime_ticks();
wd_start(wdtest_param->wdog, interval,
wdtest_callback_recursive, param);
@@ -149,24 +215,29 @@ static void wdtest_recursive(FAR struct wdog_s *wdog,
sclock_t delay_ns,
unsigned int times)
{
- uint64_t cnt;
- struct timespec tp;
- clock_t wdset_tick;
+ uint64_t cnt;
+ clock_t wdset_tick;
+ irqstate_t flags;
wdtest_printf("wdtest_recursive %lldus\n", (long long)delay_ns);
+
cnt = param->callback_cnt;
+
param->wdog = wdog;
param->interval = (sclock_t)NSEC2TICK((clock_t)delay_ns);
wdtest_assert(param->interval >= 0);
- clock_gettime(CLOCK_MONOTONIC, &tp);
- wdset_tick = clock_time2ticks(&tp);
+ flags = enter_critical_section();
+
+ wdset_tick = clock_systime_ticks();
wdtest_assert(wd_start(param->wdog, param->interval,
wdtest_callback_recursive,
(wdparm_t)param) == OK);
+ leave_critical_section(flags);
+
wdtest_delay(times * delay_ns);
wdtest_assert(wd_cancel(param->wdog) == 0);
@@ -208,7 +279,6 @@ static void wdog_test_run(FAR wdtest_param_t *param)
wdtest_once(&test_wdog, param, 100);
wdtest_once(&test_wdog, param, 1000);
wdtest_once(&test_wdog, param, 10000);
- wdtest_delay(10);
/* Delay > 0, middle 100us */
@@ -242,11 +312,11 @@ static void wdog_test_run(FAR wdtest_param_t *param)
wdtest_assert(rest < delay && rest > (delay >> 1));
- wdtest_printf("wd_start with maximum delay, cancel %lld\n",
- (long long)rest);
-
wdtest_assert(wd_cancel(&test_wdog) == 0);
+ wdtest_printf("wd_start with maximum delay, cancel OK, rest %lld\n",
+ (long long)rest);
+
/* Delay wraparound (delay < 0) */
delay = (sclock_t)((clock_t)delay + 1);