Updated test framework

Author: rcitach

examples/utest/testcases/perf/Kconfig

@@ -4,55 +4,21 @@ config UTEST_SYS_PERF_TC
     bool "system performance test"
     default n
 
-choice
-    prompt "Select time reference for System Performance Testcase"
-    default USING_TICK_AS_TIME_REF
+config UTEST_SYS_PERF_TC_COUNT
+    int "Test the number of cycles"
+    default 1000
     depends on UTEST_SYS_PERF_TC
 
-config USING_HWTIME_AS_TIME_REF
-    bool "Use hardware timer as time reference"
-    depends on RT_USING_HWTIMER
-
-config USING_TICK_AS_TIME_REF
-    bool "Use system tick as time reference"
-
-endchoice
-
 config UTEST_HWTIMER_DEV_NAME
     string "Hardware timer device name"
     default "timer0"
-    depends on USING_HWTIME_AS_TIME_REF && UTEST_SYS_PERF_TC
+    depends on RT_USING_HWTIMER && UTEST_SYS_PERF_TC
     help
-        Specify the hardware timer device name used for context switch testing (e.g., timer11).
-
-config UTEST_SYS_CONTEXT_SWITCH
-    bool "system context switch test"
-    default n
-    depends on UTEST_SYS_PERF_TC
+        Specify the hardware timer device name used for context switch testing (e.g., timer0).
 
 config UTEST_SYS_IRQ_LATENCY
     bool "system IRQ LATENCY test"
     default n
-    depends on RT_USING_HWTIMER && USING_HWTIME_AS_TIME_REF && UTEST_SYS_PERF_TC
-
-config UTEST_SYS_THREAD_SEM
-    bool "system thread semaphore tests"
-    default n
-    depends on UTEST_SYS_PERF_TC
-
-config UTEST_SYS_THREAD_EVENT
-    bool "system thread event tests"
-    default n
-    depends on UTEST_SYS_PERF_TC
-
-config UTEST_SYS_THREAD_MBOX
-    bool "system thread mbox tests"
-    default n
-    depends on UTEST_SYS_PERF_TC
-
-config UTEST_SYS_THREAD_MQ
-    bool "system thread messagequeue tests"
-    default n
-    depends on UTEST_SYS_PERF_TC
+    depends on RT_USING_HWTIMER && UTEST_SYS_PERF_TC
 
 endmenu

examples/utest/testcases/perf/SConscript

@@ -2,26 +2,11 @@ Import('rtconfig')
 from building import *
 
 cwd     = GetCurrentDir()
-src     = []
+src     = Glob('*.c')
 CPPPATH = [cwd]
 
-if GetDepend(['UTEST_SYS_CONTEXT_SWITCH']):
-    src += ['context_switch_tc.c']
-
-if GetDepend(['UTEST_SYS_IRQ_LATENCY']):
-    src += ['irq_latency_tc.c']
-
-if GetDepend(['UTEST_SYS_THREAD_SEM']):
-    src += ['thread_sem_tc.c']
-
-if GetDepend(['UTEST_SYS_THREAD_EVENT']):
-    src += ['thread_event_tc.c']
-
-if GetDepend(['UTEST_SYS_THREAD_MBOX']):
-    src += ['thread_mbox_tc.c']
-
-if GetDepend(['UTEST_SYS_THREAD_MQ']):
-    src += ['thread_mq_tc.c']
+# if GetDepend(['UTEST_SYS_IRQ_LATENCY']):
+#     src += ['irq_latency_tc.c']
 
 group = DefineGroup('utestcases', src, depend = ['UTEST_SYS_PERF_TC'], CPPPATH = CPPPATH)
 

examples/utest/testcases/perf/context_switch_tc.c

@@ -13,27 +13,75 @@
 #include <rtdevice.h>
 #include <utest.h>
 #include <utest_assert.h>
+#include <perf_tc.h>
+
+typedef struct rt_perf_array
+{
+    rt_uint32_t count;
+    rt_uint32_t *raw_times;
+    rt_uint32_t *local_times;
+    rt_uint32_t *net_times;
+} rt_perf_array_t;
 
 static rt_sem_t sem1, sem2;
-static rt_thread_t thread1, thread2;
-#define THREAD_STACK_SIZE       1024
-#define THREAD_PRIORITY         10
-#define THREAD_TIMESLICE        5
+static rt_sem_t complete_sem = RT_NULL;
+
+void rt_perf_array_destroy(rt_perf_array_t *arr)
+{
+    if (arr)
+    {
+        if (arr->raw_times)   rt_free(arr->raw_times);
+        if (arr->local_times) rt_free(arr->local_times);
+        if (arr->net_times)   rt_free(arr->net_times);
+        rt_free(arr);
+    }
+}
 
-#define SWITCH_COUNT 1000  /* Number of context switches */
+rt_perf_array_t *rt_perf_array_create(rt_uint32_t count)
+{
+    rt_perf_array_t *arr = rt_calloc(1, sizeof(rt_perf_array_t));
+    if (!arr)
+        return RT_NULL;
+
+    arr->count = count;
+    arr->raw_times = rt_calloc(count, sizeof(rt_uint32_t));
+    arr->local_times = rt_calloc(count, sizeof(rt_uint32_t));
+    arr->net_times = rt_calloc(count, sizeof(rt_uint32_t));
 
-#ifdef USING_HWTIME_AS_TIME_REF
-static rt_device_t hw_dev = RT_NULL;
+    if (!arr->raw_times || !arr->local_times || !arr->net_times)
+    {
+        rt_perf_array_destroy(arr);
+        return RT_NULL;
+    }
 
-static rt_size_t get_timer_us(rt_hwtimerval_t *timeout_s)
+    return arr;
+}
+
+void rt_perf_array_compute(rt_perf_array_t *arr, rt_perf_t *perf)
 {
-    if (hw_dev)
-        return rt_device_read(hw_dev, 0, timeout_s, sizeof(rt_hwtimerval_t));
-    return 0;
+    rt_uint32_t i;
+    rt_uint32_t tot_time = 0;
+    rt_uint32_t max_time = 0;
+    rt_uint32_t min_time = 0xFFFFFFFF;
+
+    for (i = 0; i < arr->count; i++)
+    {
+        rt_uint32_t net = (arr->raw_times[i] > arr->local_times[i]) ?
+                          (arr->raw_times[i] - arr->local_times[i]) : 0;
+        arr->net_times[i] = net;
+
+        tot_time += net;
+        if (net > max_time) max_time = net;
+        if (net < min_time) min_time = net;
+    }
+
+    perf->count = arr->count;
+    perf->tot_time = tot_time;
+    perf->max_time = max_time;
+    perf->min_time = min_time;
 }
-#endif
 
-static void thread1_entry(void *parameter)
+static void perf_thread_event1(void *parameter)
 {
     while (1)
     {
@@ -42,136 +90,83 @@ static void thread1_entry(void *parameter)
     }
 }
 
-static void thread2_entry(void *parameter)
+static void perf_thread_event2(void *parameter)
 {
-    rt_uint32_t total_time = 0;
-    rt_uint32_t sem_op_time = 0;
+    rt_perf_t *perf = (rt_perf_t *)parameter;
+    rt_perf_t *perf_local = (rt_perf_t *)rt_calloc(1,sizeof(rt_perf_t));
     rt_uint32_t i;
-#ifdef USING_HWTIME_AS_TIME_REF
-    rt_hwtimerval_t start_time, end_time;
-    rt_uint16_t ret;
-    /* Getting Signal Time */
-    ret = get_timer_us(&start_time);
-    for (i = 0; i < SWITCH_COUNT; i++)
-    {
-        rt_sem_take(sem2, RT_WAITING_FOREVER);
-        rt_sem_release(sem2);
-    }
-    ret +=get_timer_us(&end_time);
-    sem_op_time = (end_time.sec - start_time.sec) * 1000000u + (end_time.usec - start_time.usec);
 
-    ret += get_timer_us(&start_time);
-    for (i = 0; i < SWITCH_COUNT; i++)
+    rt_perf_array_t *perf_arr = rt_perf_array_create(UTEST_SYS_PERF_TC_COUNT);
+    if (!perf_arr)
     {
-        rt_sem_take(sem2, RT_WAITING_FOREVER);
-        rt_sem_release(sem1);
+        LOG_E("Failed to allocate performance arrays");
+        return;
     }
-    ret +=get_timer_us(&end_time);
-    total_time = (end_time.sec - start_time.sec) * 1000000u + (end_time.usec - start_time.usec);
-#else
-    rt_uint32_t start_time, end_time;
-    /* Getting Signal Time */
-    start_time = rt_tick_get();
-    for (i = 0; i < SWITCH_COUNT; i++)
+
+    for (i = 0; i < UTEST_SYS_PERF_TC_COUNT; i++)
     {
+        rt_perf_start(perf_local);
         rt_sem_take(sem2, RT_WAITING_FOREVER);
         rt_sem_release(sem2);
+        rt_perf_stop(perf_local);
+        perf_arr->local_times[i] = perf_local->real_time;
     }
-    end_time = rt_tick_get();
-    sem_op_time = (end_time - start_time) / RT_TICK_PER_SECOND;
-    sem_op_time += ((end_time - start_time) % RT_TICK_PER_SECOND) * (1000000u / RT_TICK_PER_SECOND);
 
-    start_time = rt_tick_get();
-    for (i = 0; i < SWITCH_COUNT; i++)
+    for (i = 0; i < UTEST_SYS_PERF_TC_COUNT; i++)
     {
-       rt_sem_take(sem2, RT_WAITING_FOREVER);
-       rt_sem_release(sem1);
+        rt_perf_start(perf);
+        rt_sem_take(sem2, RT_WAITING_FOREVER);
+        rt_sem_release(sem1);
+        rt_perf_stop(perf);
+        perf_arr->raw_times[i] = perf->real_time;
     }
-    end_time = rt_tick_get();
-    total_time = (end_time - start_time) / RT_TICK_PER_SECOND;
-    total_time += ((end_time - start_time) % RT_TICK_PER_SECOND) * (1000000u / RT_TICK_PER_SECOND);
-#endif
-
-    rt_uint32_t single_switch_time = total_time / SWITCH_COUNT; /* Total single switching time */
-    rt_uint32_t single_sem_op_time = sem_op_time / SWITCH_COUNT; /* Single semaphore operation time */
-    rt_uint32_t context_switch_time = single_switch_time - single_sem_op_time; /* Context switching time */
 
-    LOG_I("Total time for %d switches: %d us", SWITCH_COUNT, total_time);
-    LOG_I("Single switch time (including semaphore): %d us", single_switch_time);
-    LOG_I("Semaphore operation time: %d us", single_sem_op_time);
-    LOG_I("Pure context switch time: %d us", context_switch_time);
+    rt_perf_array_compute(perf_arr, perf);
+    rt_perf_array_destroy(perf_arr);
+    rt_free(perf_local);
+    rt_sem_release(complete_sem);
 }
 
-void context_switch_test(void)
+rt_err_t context_switch_test(rt_perf_t *perf)
 {
-    thread1 = rt_thread_create("thread1", thread1_entry, RT_NULL, THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
-    if (thread1 != RT_NULL)
-    {
-        rt_thread_startup(thread1);
-    }
+    rt_thread_t thread1 = RT_NULL;
+    rt_thread_t thread2 = RT_NULL;
 
-    thread2 = rt_thread_create("thread2", thread2_entry, RT_NULL, THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
-    if (thread2 != RT_NULL)
-    {
-        rt_thread_startup(thread2);
-    }
-}
+# if __STDC_VERSION__ >= 199901L
+    rt_strcpy(perf->name,__func__);
+#else
+    rt_strcpy(perf->name,"context_switch_test");
+#endif
 
-static rt_err_t utest_tc_init(void)
-{
-    int ret = RT_EOK;
-#ifdef USING_HWTIME_AS_TIME_REF
-    rt_hwtimerval_t timeout_s;
+    sem1 = rt_sem_create("sem1", 1, RT_IPC_FLAG_FIFO);
+    sem2 = rt_sem_create("sem2", 0, RT_IPC_FLAG_FIFO);
+    complete_sem = rt_sem_create("complete_sem", 0, RT_IPC_FLAG_FIFO);
 
-    hw_dev = rt_device_find(UTEST_HWTIMER_DEV_NAME);
-    if (hw_dev == RT_NULL)
+    thread1 = rt_thread_create("perf_thread_event1", perf_thread_event1, perf,
+                                THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+    if (thread1 == RT_NULL)
     {
-        ret = RT_ERROR;
-        LOG_E("hwtimer sample run failed! can't find %s device!", UTEST_HWTIMER_DEV_NAME);
-        return ret;
+        LOG_E("perf_thread_event1 create failed.");
+        return -RT_ERROR;
     }
 
-    ret = rt_device_open(hw_dev, RT_DEVICE_OFLAG_RDWR);
-    if (ret != RT_EOK)
+    thread2 = rt_thread_create("perf_thread_event2", perf_thread_event2, perf,
+                                THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
+    if (thread2 == RT_NULL)
     {
-        LOG_E("open %s device failed!", UTEST_HWTIMER_DEV_NAME);
-        return ret;
+        LOG_E("perf_thread_event2 create failed.");
+        return -RT_ERROR;
     }
 
-    timeout_s.sec  = 5;      /* s  */
-    timeout_s.usec = 0;     /* us */
-    if (rt_device_write(hw_dev, 0, &timeout_s, sizeof(rt_hwtimerval_t)) != sizeof(rt_hwtimerval_t))
-    {
-        ret = RT_ERROR;
-        LOG_E("set timeout value failed");
-        return ret;
-    }
-#endif
-    sem1 = rt_sem_create("sem1", 1, RT_IPC_FLAG_FIFO);
-    sem2 = rt_sem_create("sem2", 0, RT_IPC_FLAG_FIFO);
-    if (sem1 == RT_NULL || sem2 == RT_NULL)
-    {
-        ret = RT_ERROR;
-        LOG_E("Semaphore create failed!");
-        return ret;
-    }
-    return ret;
-}
+    rt_thread_startup(thread1);
+    rt_thread_startup(thread2);
 
-static rt_err_t utest_tc_cleanup(void)
-{
-    if (thread1) rt_thread_delete(thread1);
-    if(sem1) rt_sem_delete(sem1);
-    if(sem2) rt_sem_delete(sem2);
-#ifdef USING_HWTIME_AS_TIME_REF
-    if(hw_dev) rt_device_close(hw_dev);
-#endif
-    return RT_EOK;
-}
+    rt_sem_take(complete_sem, RT_WAITING_FOREVER);
+    rt_thread_delete(thread1);
+    rt_sem_delete(complete_sem);
+    rt_sem_delete(sem1);
+    rt_sem_delete(sem2);
 
-static void testcase(void)
-{
-    UTEST_UNIT_RUN(context_switch_test);
+    return RT_EOK;
 }
 
-UTEST_TC_EXPORT(testcase, "testcase.pref.context", utest_tc_init, utest_tc_cleanup, 10);