lib/librte_timer/rte_timer.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2012 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  */
  34
  35 #include <string.h>
  36 #include <stdio.h>
  37 #include <stdint.h>
  38 #include <sys/queue.h>
  39 #include <inttypes.h>
  40
  41 #include <rte_atomic.h>
  42 #include <rte_common.h>
  43 #include <rte_cycles.h>
  44 #include <rte_per_lcore.h>
  45 #include <rte_memory.h>
  46 #include <rte_memzone.h>
  47 #include <rte_launch.h>
  48 #include <rte_tailq.h>
  49 #include <rte_eal.h>
  50 #include <rte_per_lcore.h>
  51 #include <rte_lcore.h>
  52 #include <rte_branch_prediction.h>
  53 #include <rte_spinlock.h>
  54
  55 #include "rte_timer.h"
  56
  57 LIST_HEAD(rte_timer_list, rte_timer);
  58
  59 struct priv_timer {
  60         struct rte_timer_list pending;  /**< list of pending timers */
  61         struct rte_timer_list expired;  /**< list of expired timers */
  62         struct rte_timer_list done;     /**< list of done timers */
  63         rte_spinlock_t list_lock;       /**< lock to protect list access */
  64
  65         /** per-core variable that true if a timer was updated on this
  66          *  core since last reset of the variable */
  67         int updated;
  68
  69         unsigned prev_lcore;              /**< used for lcore round robin */
  70
  71 #ifdef RTE_LIBRTE_TIMER_DEBUG
  72         /** per-lcore statistics */
  73         struct rte_timer_debug_stats stats;
  74 #endif
  75 } __rte_cache_aligned;
  76
  77 /** per-lcore private info for timers */
  78 static struct priv_timer priv_timer[RTE_MAX_LCORE];
  79
  80 /* when debug is enabled, store some statistics */
  81 #ifdef RTE_LIBRTE_TIMER_DEBUG
  82 #define __TIMER_STAT_ADD(name, n) do {                          \
  83                 unsigned __lcore_id = rte_lcore_id();           \
  84                 priv_timer[__lcore_id].stats.name += (n);       \
  85         } while(0)
  86 #else
  87 #define __TIMER_STAT_ADD(name, n) do {} while(0)
  88 #endif
  89
  90 /* this macro allow to modify var while browsing the list */
  91 #define LIST_FOREACH_SAFE(var, var2, head, field)                      \
  92         for ((var) = ((head)->lh_first),                               \
  93                      (var2) = ((var) ? ((var)->field.le_next) : NULL); \
  94              (var);                                                    \
  95              (var) = (var2),                                           \
  96                      (var2) = ((var) ? ((var)->field.le_next) : NULL))
  97
  98
  99 /* Init the timer library. */
 100 void
 101 rte_timer_subsystem_init(void)
 102 {
 103         unsigned lcore_id;
 104
 105         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id ++) {
 106                 LIST_INIT(&priv_timer[lcore_id].pending);
 107                 LIST_INIT(&priv_timer[lcore_id].expired);
 108                 LIST_INIT(&priv_timer[lcore_id].done);
 109                 rte_spinlock_init(&priv_timer[lcore_id].list_lock);
 110                 priv_timer[lcore_id].prev_lcore = lcore_id;
 111         }
 112 }
 113
 114 /* Initialize the timer handle tim for use */
 115 void
 116 rte_timer_init(struct rte_timer *tim)
 117 {
 118         union rte_timer_status status;
 119
 120         status.state = RTE_TIMER_STOP;
 121         status.owner = RTE_TIMER_NO_OWNER;
 122         tim->status.u32 = status.u32;
 123 }
 124
 125 /*
 126  * if timer is pending or stopped (or running on the same core than
 127  * us), mark timer as configuring, and on success return the previous
 128  * status of the timer
 129  */
 130 static int
 131 timer_set_config_state(struct rte_timer *tim,
 132                        union rte_timer_status *ret_prev_status)
 133 {
 134         union rte_timer_status prev_status, status;
 135         int success = 0;
 136         unsigned lcore_id;
 137
 138         lcore_id = rte_lcore_id();
 139
 140         /* wait that the timer is in correct status before update,
 141          * and mark it as beeing configured */
 142         while (success == 0) {
 143                 prev_status.u32 = tim->status.u32;
 144
 145                 /* timer is running on another core, exit */
 146                 if (prev_status.state == RTE_TIMER_RUNNING &&
 147                     (unsigned)prev_status.owner != lcore_id)
 148                         return -1;
 149
 150                 /* timer is beeing configured on another core */
 151                 if (prev_status.state == RTE_TIMER_CONFIG)
 152                         return -1;
 153
 154                 /* here, we know that timer is stopped or pending,
 155                  * mark it atomically as beeing configured */
 156                 status.state = RTE_TIMER_CONFIG;
 157                 status.owner = (int16_t)lcore_id;
 158                 success = rte_atomic32_cmpset(&tim->status.u32,
 159                                               prev_status.u32,
 160                                               status.u32);
 161         }
 162
 163         ret_prev_status->u32 = prev_status.u32;
 164         return 0;
 165 }
 166
 167 /*
 168  * if timer is pending, mark timer as running
 169  */
 170 static int
 171 timer_set_running_state(struct rte_timer *tim)
 172 {
 173         union rte_timer_status prev_status, status;
 174         unsigned lcore_id = rte_lcore_id();
 175         int success = 0;
 176
 177         /* wait that the timer is in correct status before update,
 178          * and mark it as running */
 179         while (success == 0) {
 180                 prev_status.u32 = tim->status.u32;
 181
 182                 /* timer is not pending anymore */
 183                 if (prev_status.state != RTE_TIMER_PENDING)
 184                         return -1;
 185
 186                 /* here, we know that timer is stopped or pending,
 187                  * mark it atomically as beeing configured */
 188                 status.state = RTE_TIMER_RUNNING;
 189                 status.owner = (int16_t)lcore_id;
 190                 success = rte_atomic32_cmpset(&tim->status.u32,
 191                                               prev_status.u32,
 192                                               status.u32);
 193         }
 194
 195         return 0;
 196 }
 197
 198 /*
 199  * add in list, lock if needed
 200  * timer must be in config state
 201  * timer must not be in a list
 202  */
 203 static void
 204 timer_add(struct rte_timer *tim, unsigned tim_lcore, int local_is_locked)
 205 {
 206         uint64_t cur_time = rte_get_hpet_cycles();
 207         unsigned lcore_id = rte_lcore_id();
 208         struct rte_timer *t, *t_prev;
 209
 210         /* if timer needs to be scheduled on another core, we need to
 211          * lock the list; if it is on local core, we need to lock if
 212          * we are not called from rte_timer_manage() */
 213         if (tim_lcore != lcore_id || !local_is_locked)
 214                 rte_spinlock_lock(&priv_timer[tim_lcore].list_lock);
 215
 216         t = LIST_FIRST(&priv_timer[tim_lcore].pending);
 217
 218         /* list is empty or 'tim' will expire before 't' */
 219         if (t == NULL || ((int64_t)(tim->expire - cur_time) <
 220                           (int64_t)(t->expire - cur_time))) {
 221                 LIST_INSERT_HEAD(&priv_timer[tim_lcore].pending, tim, next);
 222         }
 223         else {
 224                 t_prev = t;
 225
 226                 /* find an element that will expire after 'tim' */
 227                 LIST_FOREACH(t, &priv_timer[tim_lcore].pending, next) {
 228                         if ((int64_t)(tim->expire - cur_time) <
 229                             (int64_t)(t->expire - cur_time)) {
 230                                 LIST_INSERT_BEFORE(t, tim, next);
 231                                 break;
 232                         }
 233                         t_prev = t;
 234                 }
 235
 236                 /* not found, insert at the end of the list */
 237                 if (t == NULL)
 238                         LIST_INSERT_AFTER(t_prev, tim, next);
 239         }
 240
 241         if (tim_lcore != lcore_id || !local_is_locked)
 242                 rte_spinlock_unlock(&priv_timer[tim_lcore].list_lock);
 243 }
 244
 245 /*
 246  * del from list, lock if needed
 247  * timer must be in config state
 248  * timer must be in a list
 249  */
 250 static void
 251 timer_del(struct rte_timer *tim, unsigned prev_owner, int local_is_locked)
 252 {
 253         unsigned lcore_id = rte_lcore_id();
 254
 255         /* if timer needs is pending another core, we need to lock the
 256          * list; if it is on local core, we need to lock if we are not
 257          * called from rte_timer_manage() */
 258         if (prev_owner != lcore_id || !local_is_locked)
 259                 rte_spinlock_lock(&priv_timer[prev_owner].list_lock);
 260
 261         LIST_REMOVE(tim, next);
 262
 263         if (prev_owner != lcore_id || !local_is_locked)
 264                 rte_spinlock_unlock(&priv_timer[prev_owner].list_lock);
 265 }
 266
 267 /* Reset and start the timer associated with the timer handle (private func) */
 268 static int
 269 __rte_timer_reset(struct rte_timer *tim, uint64_t expire,
 270                   uint64_t period, unsigned tim_lcore,
 271                   rte_timer_cb_t fct, void *arg,
 272                   int local_is_locked)
 273 {
 274         union rte_timer_status prev_status, status;
 275         int ret;
 276         unsigned lcore_id = rte_lcore_id();
 277
 278         /* round robin for tim_lcore */
 279         if (tim_lcore == (unsigned)LCORE_ID_ANY) {
 280                 tim_lcore = rte_get_next_lcore(priv_timer[lcore_id].prev_lcore,
 281                                                0, 1);
 282                 priv_timer[lcore_id].prev_lcore = tim_lcore;
 283         }
 284
 285         /* wait that the timer is in correct status before update,
 286          * and mark it as beeing configured */
 287         ret = timer_set_config_state(tim, &prev_status);
 288         if (ret < 0)
 289                 return -1;
 290
 291         __TIMER_STAT_ADD(reset, 1);
 292         priv_timer[lcore_id].updated = 1;
 293
 294         /* remove it from list */
 295         if (prev_status.state == RTE_TIMER_PENDING ||
 296             prev_status.state == RTE_TIMER_RUNNING) {
 297                 timer_del(tim, prev_status.owner, local_is_locked);
 298                 __TIMER_STAT_ADD(pending, -1);
 299         }
 300
 301         tim->period = period;
 302         tim->expire = expire;
 303         tim->f = fct;
 304         tim->arg = arg;
 305
 306         __TIMER_STAT_ADD(pending, 1);
 307         timer_add(tim, tim_lcore, local_is_locked);
 308
 309         /* update state: as we are in CONFIG state, only us can modify
 310          * the state so we don't need to use cmpset() here */
 311         rte_wmb();
 312         status.state = RTE_TIMER_PENDING;
 313         status.owner = (int16_t)tim_lcore;
 314         tim->status.u32 = status.u32;
 315
 316         return 0;
 317 }
 318
 319 /* Reset and start the timer associated with the timer handle tim */
 320 int
 321 rte_timer_reset(struct rte_timer *tim, uint64_t ticks,
 322                 enum rte_timer_type type, unsigned tim_lcore,
 323                 rte_timer_cb_t fct, void *arg)
 324 {
 325         uint64_t cur_time = rte_get_hpet_cycles();
 326         uint64_t period;
 327
 328         if (unlikely((tim_lcore != (unsigned)LCORE_ID_ANY) &&
 329                         !rte_lcore_is_enabled(tim_lcore)))
 330                 return -1;
 331
 332         if (type == PERIODICAL)
 333                 period = ticks;
 334         else
 335                 period = 0;
 336
 337         __rte_timer_reset(tim,  cur_time + ticks, period, tim_lcore,
 338                           fct, arg, 0);
 339
 340         return 0;
 341 }
 342
 343 /* loop until rte_timer_reset() succeed */
 344 void
 345 rte_timer_reset_sync(struct rte_timer *tim, uint64_t ticks,
 346                      enum rte_timer_type type, unsigned tim_lcore,
 347                      rte_timer_cb_t fct, void *arg)
 348 {
 349         while (rte_timer_reset(tim, ticks, type, tim_lcore,
 350                                fct, arg) != 0);
 351 }
 352
 353 /* Stop the timer associated with the timer handle tim */
 354 int
 355 rte_timer_stop(struct rte_timer *tim)
 356 {
 357         union rte_timer_status prev_status, status;
 358         unsigned lcore_id = rte_lcore_id();
 359         int ret;
 360
 361         /* wait that the timer is in correct status before update,
 362          * and mark it as beeing configured */
 363         ret = timer_set_config_state(tim, &prev_status);
 364         if (ret < 0)
 365                 return -1;
 366
 367         __TIMER_STAT_ADD(stop, 1);
 368         priv_timer[lcore_id].updated = 1;
 369
 370         /* remove it from list */
 371         if (prev_status.state == RTE_TIMER_PENDING ||
 372             prev_status.state == RTE_TIMER_RUNNING) {
 373                 timer_del(tim, prev_status.owner, 0);
 374                 __TIMER_STAT_ADD(pending, -1);
 375         }
 376
 377         /* mark timer as stopped */
 378         rte_wmb();
 379         status.state = RTE_TIMER_STOP;
 380         status.owner = RTE_TIMER_NO_OWNER;
 381         tim->status.u32 = status.u32;
 382
 383         return 0;
 384 }
 385
 386 /* loop until rte_timer_stop() succeed */
 387 void
 388 rte_timer_stop_sync(struct rte_timer *tim)
 389 {
 390         while (rte_timer_stop(tim) != 0);
 391 }
 392
 393 /* Test the PENDING status of the timer handle tim */
 394 int
 395 rte_timer_pending(struct rte_timer *tim)
 396 {
 397         return tim->status.state == RTE_TIMER_PENDING;
 398 }
 399
 400 /* must be called periodically, run all timer that expired */
 401 void rte_timer_manage(void)
 402 {
 403         union rte_timer_status status;
 404         struct rte_timer *tim, *tim2;
 405         unsigned lcore_id = rte_lcore_id();
 406         uint64_t cur_time = rte_get_hpet_cycles();
 407         int ret;
 408
 409         __TIMER_STAT_ADD(manage, 1);
 410
 411         /* browse ordered list, add expired timers in 'expired' list */
 412         rte_spinlock_lock(&priv_timer[lcore_id].list_lock);
 413
 414         LIST_FOREACH_SAFE(tim, tim2, &priv_timer[lcore_id].pending, next) {
 415                 if ((int64_t)(cur_time - tim->expire) < 0)
 416                         break;
 417
 418                 LIST_REMOVE(tim, next);
 419                 LIST_INSERT_HEAD(&priv_timer[lcore_id].expired, tim, next);
 420         }
 421
 422
 423         /* for each timer of 'expired' list, check state and execute callback */
 424         while ((tim = LIST_FIRST(&priv_timer[lcore_id].expired)) != NULL) {
 425                 ret = timer_set_running_state(tim);
 426
 427                 /* remove from expired list, and add it in done list */
 428                 LIST_REMOVE(tim, next);
 429                 LIST_INSERT_HEAD(&priv_timer[lcore_id].done, tim, next);
 430
 431                 /* this timer was not pending, continue */
 432                 if (ret < 0)
 433                         continue;
 434
 435                 rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
 436
 437                 priv_timer[lcore_id].updated = 0;
 438
 439                 /* execute callback function with list unlocked */
 440                 tim->f(tim, tim->arg);
 441
 442                 rte_spinlock_lock(&priv_timer[lcore_id].list_lock);
 443
 444                 /* the timer was stopped or reloaded by the callback
 445                  * function, we have nothing to do here */
 446                 if (priv_timer[lcore_id].updated == 1)
 447                         continue;
 448
 449                 if (tim->period == 0) {
 450                         /* remove from done list and mark timer as stopped */
 451                         LIST_REMOVE(tim, next);
 452                         __TIMER_STAT_ADD(pending, -1);
 453                         status.state = RTE_TIMER_STOP;
 454                         status.owner = RTE_TIMER_NO_OWNER;
 455                         rte_wmb();
 456                         tim->status.u32 = status.u32;
 457                 }
 458                 else {
 459                         /* keep it in done list and mark timer as pending */
 460                         status.state = RTE_TIMER_PENDING;
 461                         status.owner = (int16_t)lcore_id;
 462                         rte_wmb();
 463                         tim->status.u32 = status.u32;
 464                 }
 465         }
 466
 467         /* finally, browse done list, some timer may have to be
 468          * rescheduled automatically */
 469         LIST_FOREACH_SAFE(tim, tim2, &priv_timer[lcore_id].done, next) {
 470
 471                 /* reset may fail if timer is beeing modified, in this
 472                  * case the timer will remain in 'done' list until the
 473                  * core that is modifying it remove it */
 474                 __rte_timer_reset(tim, cur_time + tim->period,
 475                                   tim->period, lcore_id, tim->f,
 476                                   tim->arg, 1);
 477         }
 478
 479         /* job finished, unlock the list lock */
 480         rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
 481 }
 482
 483 /* dump statistics about timers */
 484 void rte_timer_dump_stats(void)
 485 {
 486 #ifdef RTE_LIBRTE_TIMER_DEBUG
 487         struct rte_timer_debug_stats sum;
 488         unsigned lcore_id;
 489
 490         memset(&sum, 0, sizeof(sum));
 491         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
 492                 sum.reset += priv_timer[lcore_id].stats.reset;
 493                 sum.stop += priv_timer[lcore_id].stats.stop;
 494                 sum.manage += priv_timer[lcore_id].stats.manage;
 495                 sum.pending += priv_timer[lcore_id].stats.pending;
 496         }
 497         printf("Timer statistics:\n");
 498         printf("  reset = %"PRIu64"\n", sum.reset);
 499         printf("  stop = %"PRIu64"\n", sum.stop);
 500         printf("  manage = %"PRIu64"\n", sum.manage);
 501         printf("  pending = %"PRIu64"\n", sum.pending);
 502 #else
 503         printf("No timer statistics, RTE_LIBRTE_TIMER_DEBUG is disabled\n");
 504 #endif
 505 }