michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests: latency_measure: Configurable iterations

Browse source 
Updates the latency_measure benchmark to make the number of
iterations for which each test executes to be configurable.
This allows someone to make a tradeoff between accuracy
and execution time (can be useful for simulators).

Signed-off-by: Peter Mitsis <peter.mitsis@intel.com>
This commit is contained in:
Peter Mitsis 2024-01-24 09:57:55 -05:00 • committed by Henrik Brix Andersen
commit 4c5a96ec65
2 changed files with 44 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

10
tests/benchmarks/latency_measure/Kconfig Normal file
View file

@ -0,0 +1,10 @@
# Copyright (c) 2024 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
mainmenu "Latency Measure Benchmark"
source "Kconfig.zephyr"
config BENCHMARK_NUM_ITERATIONS
int "Number of iterations to gather data"
default 1000

70
tests/benchmarks/latency_measure/src/main.c
View file

@ -16,8 +16,6 @@
#include "timing_sc.h" #include "timing_sc.h"
#include <zephyr/tc_util.h> #include <zephyr/tc_util.h>
#define NUM_ITERATIONS 10000
#define STACK_SIZE (1024 + CONFIG_TEST_EXTRA_STACK_SIZE) #define STACK_SIZE (1024 + CONFIG_TEST_EXTRA_STACK_SIZE)
uint32_t tm_off; uint32_t tm_off;
@ -79,77 +77,77 @@ static void test_thread(void *arg1, void *arg2, void *arg3)
TC_START("Time Measurement"); TC_START("Time Measurement");
TC_PRINT("Timing results: Clock frequency: %u MHz\n", freq); TC_PRINT("Timing results: Clock frequency: %u MHz\n", freq);
timestamp_overhead_init(NUM_ITERATIONS); timestamp_overhead_init(CONFIG_BENCHMARK_NUM_ITERATIONS);
/* Preemptive threads context switching */ /* Preemptive threads context switching */
thread_switch_yield(NUM_ITERATIONS, false); thread_switch_yield(CONFIG_BENCHMARK_NUM_ITERATIONS, false);
/* Cooperative threads context switching */ /* Cooperative threads context switching */
thread_switch_yield(NUM_ITERATIONS, true); thread_switch_yield(CONFIG_BENCHMARK_NUM_ITERATIONS, true);
int_to_thread(NUM_ITERATIONS); int_to_thread(CONFIG_BENCHMARK_NUM_ITERATIONS);
/* Thread creation, starting, suspending, resuming and aborting. */ /* Thread creation, starting, suspending, resuming and aborting. */
thread_ops(NUM_ITERATIONS, 0, 0); thread_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
thread_ops(NUM_ITERATIONS, 0, K_USER); thread_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, K_USER);
thread_ops(NUM_ITERATIONS, K_USER, K_USER); thread_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, K_USER);
thread_ops(NUM_ITERATIONS, K_USER, 0); thread_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, 0);
#endif #endif
fifo_ops(NUM_ITERATIONS, 0); fifo_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
fifo_ops(NUM_ITERATIONS, K_USER); fifo_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER);
#endif #endif
fifo_blocking_ops(NUM_ITERATIONS, 0, 0); fifo_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
fifo_blocking_ops(NUM_ITERATIONS, 0, K_USER); fifo_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, K_USER);
fifo_blocking_ops(NUM_ITERATIONS, K_USER, 0); fifo_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, 0);
fifo_blocking_ops(NUM_ITERATIONS, K_USER, K_USER); fifo_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, K_USER);
#endif #endif
lifo_ops(NUM_ITERATIONS, 0); lifo_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
lifo_ops(NUM_ITERATIONS, K_USER); lifo_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER);
#endif #endif
lifo_blocking_ops(NUM_ITERATIONS, 0, 0); lifo_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
lifo_blocking_ops(NUM_ITERATIONS, 0, K_USER); lifo_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, K_USER);
lifo_blocking_ops(NUM_ITERATIONS, K_USER, 0); lifo_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, 0);
lifo_blocking_ops(NUM_ITERATIONS, K_USER, K_USER); lifo_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, K_USER);
#endif #endif
event_ops(NUM_ITERATIONS, 0); event_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
event_ops(NUM_ITERATIONS, K_USER); event_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER);
#endif #endif
event_blocking_ops(NUM_ITERATIONS, 0, 0); event_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
event_blocking_ops(NUM_ITERATIONS, 0, K_USER); event_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, K_USER);
event_blocking_ops(NUM_ITERATIONS, K_USER, 0); event_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, 0);
event_blocking_ops(NUM_ITERATIONS, K_USER, K_USER); event_blocking_ops(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, K_USER);
#endif #endif
sema_test_signal(NUM_ITERATIONS, 0); sema_test_signal(CONFIG_BENCHMARK_NUM_ITERATIONS, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
sema_test_signal(NUM_ITERATIONS, K_USER); sema_test_signal(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER);
#endif #endif
sema_context_switch(NUM_ITERATIONS, 0, 0); sema_context_switch(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
sema_context_switch(NUM_ITERATIONS, 0, K_USER); sema_context_switch(CONFIG_BENCHMARK_NUM_ITERATIONS, 0, K_USER);
sema_context_switch(NUM_ITERATIONS, K_USER, 0); sema_context_switch(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, 0);
sema_context_switch(NUM_ITERATIONS, K_USER, K_USER); sema_context_switch(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER, K_USER);
#endif #endif
mutex_lock_unlock(NUM_ITERATIONS, 0); mutex_lock_unlock(CONFIG_BENCHMARK_NUM_ITERATIONS, 0);
#ifdef CONFIG_USERSPACE #ifdef CONFIG_USERSPACE
mutex_lock_unlock(NUM_ITERATIONS, K_USER); mutex_lock_unlock(CONFIG_BENCHMARK_NUM_ITERATIONS, K_USER);
#endif #endif
heap_malloc_free(); heap_malloc_free();