app/test/test_timer_racecond.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015 Akamai Technologies.
   3  * All rights reserved.
   4  */
   5
   6 #include "test.h"
   7
   8 #include <stdio.h>
   9 #include <unistd.h>
  10 #include <inttypes.h>
  11 #include <rte_cycles.h>
  12 #include <rte_timer.h>
  13 #include <rte_common.h>
  14 #include <rte_lcore.h>
  15 #include <rte_random.h>
  16 #include <rte_malloc.h>
  17 #include <rte_pause.h>
  18
  19 #ifdef RTE_EXEC_ENV_LINUX
  20 #define usec_delay(us) usleep(us)
  21 #else
  22 #define usec_delay(us) rte_delay_us(us)
  23 #endif
  24
  25 #define BILLION (1UL << 30)
  26
  27 #define TEST_DURATION_S 4 /* in seconds */
  28 #define N_TIMERS    50
  29
  30 static struct rte_timer timer[N_TIMERS];
  31 static unsigned int timer_lcore_id[N_TIMERS];
  32
  33 static unsigned int main_lcore;
  34 static volatile unsigned int stop_workers;
  35
  36 static int reload_timer(struct rte_timer *tim);
  37
  38 RTE_LOG_REGISTER(timer_logtype_test, test.timer, INFO);
  39
  40 static void
  41 timer_cb(struct rte_timer *tim, void *arg __rte_unused)
  42 {
  43         /* Simulate slow callback function, 100 us. */
  44         rte_delay_us(100);
  45         if (tim == &timer[0])
  46                 rte_log(RTE_LOG_DEBUG, timer_logtype_test,
  47                         "------------------------------------------------\n");
  48         rte_log(RTE_LOG_DEBUG, timer_logtype_test, "%s: core %u timer %"
  49                 PRIuPTR "\n", __func__, rte_lcore_id(), tim - timer);
  50         (void)reload_timer(tim);
  51 }
  52
  53 RTE_DEFINE_PER_LCORE(unsigned, n_reset_collisions);
  54
  55 static int
  56 reload_timer(struct rte_timer *tim)
  57 {
  58         /* Make timer expire roughly when the TSC hits the next BILLION
  59          * multiple. Add in timer's index to make them expire in nearly
  60          * sorted order. This makes all timers somewhat synchronized,
  61          * firing ~2-3 times per second, assuming 2-3 GHz TSCs.
  62          */
  63         uint64_t ticks = BILLION - (rte_get_timer_cycles() % BILLION) +
  64             (tim - timer);
  65         int ret;
  66
  67         ret = rte_timer_reset(tim, ticks, PERIODICAL, main_lcore, timer_cb, NULL);
  68         if (ret != 0) {
  69                 rte_log(RTE_LOG_DEBUG, timer_logtype_test,
  70                         "- core %u failed to reset timer %" PRIuPTR " (OK)\n",
  71                         rte_lcore_id(), tim - timer);
  72                 RTE_PER_LCORE(n_reset_collisions) += 1;
  73         }
  74         return ret;
  75 }
  76
  77 static int
  78 worker_main_loop(__rte_unused void *arg)
  79 {
  80         unsigned lcore_id = rte_lcore_id();
  81         unsigned i;
  82
  83         RTE_PER_LCORE(n_reset_collisions) = 0;
  84
  85         printf("Starting main loop on core %u\n", lcore_id);
  86
  87         while (!stop_workers) {
  88                 /* Wait until the timer manager is running.
  89                  * We know it's running when we see timer[0] NOT pending.
  90                  */
  91                 if (rte_timer_pending(&timer[0])) {
  92                         rte_pause();
  93                         continue;
  94                 }
  95
  96                 /* Now, go cause some havoc!
  97                  * Reload our timers.
  98                  */
  99                 for (i = 0; i < N_TIMERS; i++) {
 100                         if (timer_lcore_id[i] == lcore_id)
 101                                 (void)reload_timer(&timer[i]);
 102                 }
 103                 usec_delay(100*1000); /* sleep 100 ms */
 104         }
 105
 106         if (RTE_PER_LCORE(n_reset_collisions) != 0) {
 107                 printf("- core %u, %u reset collisions (OK)\n",
 108                         lcore_id, RTE_PER_LCORE(n_reset_collisions));
 109         }
 110         return 0;
 111 }
 112
 113 static int
 114 test_timer_racecond(void)
 115 {
 116         int ret;
 117         uint64_t hz;
 118         uint64_t cur_time;
 119         uint64_t end_time;
 120         int64_t diff = 0;
 121         unsigned lcore_id;
 122         unsigned i;
 123
 124         main_lcore = lcore_id = rte_lcore_id();
 125         hz = rte_get_timer_hz();
 126
 127         /* init and start timers */
 128         for (i = 0; i < N_TIMERS; i++) {
 129                 rte_timer_init(&timer[i]);
 130                 ret = reload_timer(&timer[i]);
 131                 TEST_ASSERT(ret == 0, "reload_timer failed");
 132
 133                 /* Distribute timers to workers.
 134                  * Note that we assign timer[0] to the main.
 135                  */
 136                 timer_lcore_id[i] = lcore_id;
 137                 lcore_id = rte_get_next_lcore(lcore_id, 1, 1);
 138         }
 139
 140         /* calculate the "end of test" time */
 141         cur_time = rte_get_timer_cycles();
 142         end_time = cur_time + (hz * TEST_DURATION_S);
 143
 144         /* start worker cores */
 145         stop_workers = 0;
 146         printf("Start timer manage race condition test (%u seconds)\n",
 147                         TEST_DURATION_S);
 148         rte_eal_mp_remote_launch(worker_main_loop, NULL, SKIP_MAIN);
 149
 150         while (diff >= 0) {
 151                 /* run the timers */
 152                 rte_timer_manage();
 153
 154                 /* wait 100 ms */
 155                 usec_delay(100*1000);
 156
 157                 cur_time = rte_get_timer_cycles();
 158                 diff = end_time - cur_time;
 159         }
 160
 161         /* stop worker cores */
 162         printf("Stopping timer manage race condition test\n");
 163         stop_workers = 1;
 164         rte_eal_mp_wait_lcore();
 165
 166         /* stop timers */
 167         for (i = 0; i < N_TIMERS; i++) {
 168                 ret = rte_timer_stop(&timer[i]);
 169                 TEST_ASSERT(ret == 0, "rte_timer_stop failed");
 170         }
 171
 172         return TEST_SUCCESS;
 173 }
 174
 175 REGISTER_TEST_COMMAND(timer_racecond_autotest, test_timer_racecond);