lib/librte_timer/rte_timer.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2014 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 #include <string.h>
  35 #include <stdio.h>
  36 #include <stdint.h>
  37 #include <inttypes.h>
  38 #include <assert.h>
  39 #include <sys/queue.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_eal.h>
  49 #include <rte_per_lcore.h>
  50 #include <rte_lcore.h>
  51 #include <rte_branch_prediction.h>
  52 #include <rte_spinlock.h>
  53 #include <rte_random.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 pending_head;  /**< dummy timer instance to head up list */
  61         rte_spinlock_t list_lock;       /**< lock to protect list access */
  62
  63         /** per-core variable that true if a timer was updated on this
  64          *  core since last reset of the variable */
  65         int updated;
  66
  67         /** track the current depth of the skiplist */
  68         unsigned curr_skiplist_depth;
  69
  70         unsigned prev_lcore;              /**< used for lcore round robin */
  71
  72         /** running timer on this lcore now */
  73         struct rte_timer *running_tim;
  74
  75 #ifdef RTE_LIBRTE_TIMER_DEBUG
  76         /** per-lcore statistics */
  77         struct rte_timer_debug_stats stats;
  78 #endif
  79 } __rte_cache_aligned;
  80
  81 /** per-lcore private info for timers */
  82 static struct priv_timer priv_timer[RTE_MAX_LCORE];
  83
  84 /* when debug is enabled, store some statistics */
  85 #ifdef RTE_LIBRTE_TIMER_DEBUG
  86 #define __TIMER_STAT_ADD(name, n) do {                                  \
  87                 unsigned __lcore_id = rte_lcore_id();                   \
  88                 if (__lcore_id < RTE_MAX_LCORE)                         \
  89                         priv_timer[__lcore_id].stats.name += (n);       \
  90         } while(0)
  91 #else
  92 #define __TIMER_STAT_ADD(name, n) do {} while(0)
  93 #endif
  94
  95 /* Init the timer library. */
  96 void
  97 rte_timer_subsystem_init(void)
  98 {
  99         unsigned lcore_id;
 100
 101         /* since priv_timer is static, it's zeroed by default, so only init some
 102          * fields.
 103          */
 104         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id ++) {
 105                 rte_spinlock_init(&priv_timer[lcore_id].list_lock);
 106                 priv_timer[lcore_id].prev_lcore = lcore_id;
 107         }
 108 }
 109
 110 /* Initialize the timer handle tim for use */
 111 void
 112 rte_timer_init(struct rte_timer *tim)
 113 {
 114         union rte_timer_status status;
 115
 116         status.state = RTE_TIMER_STOP;
 117         status.owner = RTE_TIMER_NO_OWNER;
 118         tim->status.u32 = status.u32;
 119 }
 120
 121 /*
 122  * if timer is pending or stopped (or running on the same core than
 123  * us), mark timer as configuring, and on success return the previous
 124  * status of the timer
 125  */
 126 static int
 127 timer_set_config_state(struct rte_timer *tim,
 128                        union rte_timer_status *ret_prev_status)
 129 {
 130         union rte_timer_status prev_status, status;
 131         int success = 0;
 132         unsigned lcore_id;
 133
 134         lcore_id = rte_lcore_id();
 135
 136         /* wait that the timer is in correct status before update,
 137          * and mark it as being configured */
 138         while (success == 0) {
 139                 prev_status.u32 = tim->status.u32;
 140
 141                 /* timer is running on another core
 142                  * or ready to run on local core, exit
 143                  */
 144                 if (prev_status.state == RTE_TIMER_RUNNING &&
 145                     (prev_status.owner != (uint16_t)lcore_id ||
 146                      tim != priv_timer[lcore_id].running_tim))
 147                         return -1;
 148
 149                 /* timer is being configured on another core */
 150                 if (prev_status.state == RTE_TIMER_CONFIG)
 151                         return -1;
 152
 153                 /* here, we know that timer is stopped or pending,
 154                  * mark it atomically as being configured */
 155                 status.state = RTE_TIMER_CONFIG;
 156                 status.owner = (int16_t)lcore_id;
 157                 success = rte_atomic32_cmpset(&tim->status.u32,
 158                                               prev_status.u32,
 159                                               status.u32);
 160         }
 161
 162         ret_prev_status->u32 = prev_status.u32;
 163         return 0;
 164 }
 165
 166 /*
 167  * if timer is pending, mark timer as running
 168  */
 169 static int
 170 timer_set_running_state(struct rte_timer *tim)
 171 {
 172         union rte_timer_status prev_status, status;
 173         unsigned lcore_id = rte_lcore_id();
 174         int success = 0;
 175
 176         /* wait that the timer is in correct status before update,
 177          * and mark it as running */
 178         while (success == 0) {
 179                 prev_status.u32 = tim->status.u32;
 180
 181                 /* timer is not pending anymore */
 182                 if (prev_status.state != RTE_TIMER_PENDING)
 183                         return -1;
 184
 185                 /* here, we know that timer is stopped or pending,
 186                  * mark it atomically as beeing configured */
 187                 status.state = RTE_TIMER_RUNNING;
 188                 status.owner = (int16_t)lcore_id;
 189                 success = rte_atomic32_cmpset(&tim->status.u32,
 190                                               prev_status.u32,
 191                                               status.u32);
 192         }
 193
 194         return 0;
 195 }
 196
 197 /*
 198  * Return a skiplist level for a new entry.
 199  * This probabalistically gives a level with p=1/4 that an entry at level n
 200  * will also appear at level n+1.
 201  */
 202 static uint32_t
 203 timer_get_skiplist_level(unsigned curr_depth)
 204 {
 205 #ifdef RTE_LIBRTE_TIMER_DEBUG
 206         static uint32_t i, count = 0;
 207         static uint32_t levels[MAX_SKIPLIST_DEPTH] = {0};
 208 #endif
 209
 210         /* probability value is 1/4, i.e. all at level 0, 1 in 4 is at level 1,
 211          * 1 in 16 at level 2, 1 in 64 at level 3, etc. Calculated using lowest
 212          * bit position of a (pseudo)random number.
 213          */
 214         uint32_t rand = rte_rand() & (UINT32_MAX - 1);
 215         uint32_t level = rand == 0 ? MAX_SKIPLIST_DEPTH : (rte_bsf32(rand)-1) / 2;
 216
 217         /* limit the levels used to one above our current level, so we don't,
 218          * for instance, have a level 0 and a level 7 without anything between
 219          */
 220         if (level > curr_depth)
 221                 level = curr_depth;
 222         if (level >= MAX_SKIPLIST_DEPTH)
 223                 level = MAX_SKIPLIST_DEPTH-1;
 224 #ifdef RTE_LIBRTE_TIMER_DEBUG
 225         count ++;
 226         levels[level]++;
 227         if (count % 10000 == 0)
 228                 for (i = 0; i < MAX_SKIPLIST_DEPTH; i++)
 229                         printf("Level %u: %u\n", (unsigned)i, (unsigned)levels[i]);
 230 #endif
 231         return level;
 232 }
 233
 234 /*
 235  * For a given time value, get the entries at each level which
 236  * are <= that time value.
 237  */
 238 static void
 239 timer_get_prev_entries(uint64_t time_val, unsigned tim_lcore,
 240                 struct rte_timer **prev)
 241 {
 242         unsigned lvl = priv_timer[tim_lcore].curr_skiplist_depth;
 243         prev[lvl] = &priv_timer[tim_lcore].pending_head;
 244         while(lvl != 0) {
 245                 lvl--;
 246                 prev[lvl] = prev[lvl+1];
 247                 while (prev[lvl]->sl_next[lvl] &&
 248                                 prev[lvl]->sl_next[lvl]->expire <= time_val)
 249                         prev[lvl] = prev[lvl]->sl_next[lvl];
 250         }
 251 }
 252
 253 /*
 254  * Given a timer node in the skiplist, find the previous entries for it at
 255  * all skiplist levels.
 256  */
 257 static void
 258 timer_get_prev_entries_for_node(struct rte_timer *tim, unsigned tim_lcore,
 259                 struct rte_timer **prev)
 260 {
 261         int i;
 262         /* to get a specific entry in the list, look for just lower than the time
 263          * values, and then increment on each level individually if necessary
 264          */
 265         timer_get_prev_entries(tim->expire - 1, tim_lcore, prev);
 266         for (i = priv_timer[tim_lcore].curr_skiplist_depth - 1; i >= 0; i--) {
 267                 while (prev[i]->sl_next[i] != NULL &&
 268                                 prev[i]->sl_next[i] != tim &&
 269                                 prev[i]->sl_next[i]->expire <= tim->expire)
 270                         prev[i] = prev[i]->sl_next[i];
 271         }
 272 }
 273
 274 /*
 275  * add in list, lock if needed
 276  * timer must be in config state
 277  * timer must not be in a list
 278  */
 279 static void
 280 timer_add(struct rte_timer *tim, unsigned tim_lcore, int local_is_locked)
 281 {
 282         unsigned lcore_id = rte_lcore_id();
 283         unsigned lvl;
 284         struct rte_timer *prev[MAX_SKIPLIST_DEPTH+1];
 285
 286         /* if timer needs to be scheduled on another core, we need to
 287          * lock the list; if it is on local core, we need to lock if
 288          * we are not called from rte_timer_manage() */
 289         if (tim_lcore != lcore_id || !local_is_locked)
 290                 rte_spinlock_lock(&priv_timer[tim_lcore].list_lock);
 291
 292         /* find where exactly this element goes in the list of elements
 293          * for each depth. */
 294         timer_get_prev_entries(tim->expire, tim_lcore, prev);
 295
 296         /* now assign it a new level and add at that level */
 297         const unsigned tim_level = timer_get_skiplist_level(
 298                         priv_timer[tim_lcore].curr_skiplist_depth);
 299         if (tim_level == priv_timer[tim_lcore].curr_skiplist_depth)
 300                 priv_timer[tim_lcore].curr_skiplist_depth++;
 301
 302         lvl = tim_level;
 303         while (lvl > 0) {
 304                 tim->sl_next[lvl] = prev[lvl]->sl_next[lvl];
 305                 prev[lvl]->sl_next[lvl] = tim;
 306                 lvl--;
 307         }
 308         tim->sl_next[0] = prev[0]->sl_next[0];
 309         prev[0]->sl_next[0] = tim;
 310
 311         /* save the lowest list entry into the expire field of the dummy hdr
 312          * NOTE: this is not atomic on 32-bit*/
 313         priv_timer[tim_lcore].pending_head.expire = priv_timer[tim_lcore].\
 314                         pending_head.sl_next[0]->expire;
 315
 316         if (tim_lcore != lcore_id || !local_is_locked)
 317                 rte_spinlock_unlock(&priv_timer[tim_lcore].list_lock);
 318 }
 319
 320 /*
 321  * del from list, lock if needed
 322  * timer must be in config state
 323  * timer must be in a list
 324  */
 325 static void
 326 timer_del(struct rte_timer *tim, union rte_timer_status prev_status,
 327                 int local_is_locked)
 328 {
 329         unsigned lcore_id = rte_lcore_id();
 330         unsigned prev_owner = prev_status.owner;
 331         int i;
 332         struct rte_timer *prev[MAX_SKIPLIST_DEPTH+1];
 333
 334         /* if timer needs is pending another core, we need to lock the
 335          * list; if it is on local core, we need to lock if we are not
 336          * called from rte_timer_manage() */
 337         if (prev_owner != lcore_id || !local_is_locked)
 338                 rte_spinlock_lock(&priv_timer[prev_owner].list_lock);
 339
 340         /* save the lowest list entry into the expire field of the dummy hdr.
 341          * NOTE: this is not atomic on 32-bit */
 342         if (tim == priv_timer[prev_owner].pending_head.sl_next[0])
 343                 priv_timer[prev_owner].pending_head.expire =
 344                                 ((tim->sl_next[0] == NULL) ? 0 : tim->sl_next[0]->expire);
 345
 346         /* adjust pointers from previous entries to point past this */
 347         timer_get_prev_entries_for_node(tim, prev_owner, prev);
 348         for (i = priv_timer[prev_owner].curr_skiplist_depth - 1; i >= 0; i--) {
 349                 if (prev[i]->sl_next[i] == tim)
 350                         prev[i]->sl_next[i] = tim->sl_next[i];
 351         }
 352
 353         /* in case we deleted last entry at a level, adjust down max level */
 354         for (i = priv_timer[prev_owner].curr_skiplist_depth - 1; i >= 0; i--)
 355                 if (priv_timer[prev_owner].pending_head.sl_next[i] == NULL)
 356                         priv_timer[prev_owner].curr_skiplist_depth --;
 357                 else
 358                         break;
 359
 360         if (prev_owner != lcore_id || !local_is_locked)
 361                 rte_spinlock_unlock(&priv_timer[prev_owner].list_lock);
 362 }
 363
 364 /* Reset and start the timer associated with the timer handle (private func) */
 365 static int
 366 __rte_timer_reset(struct rte_timer *tim, uint64_t expire,
 367                   uint64_t period, unsigned tim_lcore,
 368                   rte_timer_cb_t fct, void *arg,
 369                   int local_is_locked)
 370 {
 371         union rte_timer_status prev_status, status;
 372         int ret;
 373         unsigned lcore_id = rte_lcore_id();
 374
 375         /* round robin for tim_lcore */
 376         if (tim_lcore == (unsigned)LCORE_ID_ANY) {
 377                 if (lcore_id < RTE_MAX_LCORE) {
 378                         /* EAL thread with valid lcore_id */
 379                         tim_lcore = rte_get_next_lcore(
 380                                 priv_timer[lcore_id].prev_lcore,
 381                                 0, 1);
 382                         priv_timer[lcore_id].prev_lcore = tim_lcore;
 383                 } else
 384                         /* non-EAL thread do not run rte_timer_manage(),
 385                          * so schedule the timer on the first enabled lcore. */
 386                         tim_lcore = rte_get_next_lcore(LCORE_ID_ANY, 0, 1);
 387         }
 388
 389         /* wait that the timer is in correct status before update,
 390          * and mark it as being configured */
 391         ret = timer_set_config_state(tim, &prev_status);
 392         if (ret < 0)
 393                 return -1;
 394
 395         __TIMER_STAT_ADD(reset, 1);
 396         if (prev_status.state == RTE_TIMER_RUNNING &&
 397             lcore_id < RTE_MAX_LCORE) {
 398                 priv_timer[lcore_id].updated = 1;
 399         }
 400
 401         /* remove it from list */
 402         if (prev_status.state == RTE_TIMER_PENDING) {
 403                 timer_del(tim, prev_status, local_is_locked);
 404                 __TIMER_STAT_ADD(pending, -1);
 405         }
 406
 407         tim->period = period;
 408         tim->expire = expire;
 409         tim->f = fct;
 410         tim->arg = arg;
 411
 412         __TIMER_STAT_ADD(pending, 1);
 413         timer_add(tim, tim_lcore, local_is_locked);
 414
 415         /* update state: as we are in CONFIG state, only us can modify
 416          * the state so we don't need to use cmpset() here */
 417         rte_wmb();
 418         status.state = RTE_TIMER_PENDING;
 419         status.owner = (int16_t)tim_lcore;
 420         tim->status.u32 = status.u32;
 421
 422         return 0;
 423 }
 424
 425 /* Reset and start the timer associated with the timer handle tim */
 426 int
 427 rte_timer_reset(struct rte_timer *tim, uint64_t ticks,
 428                 enum rte_timer_type type, unsigned tim_lcore,
 429                 rte_timer_cb_t fct, void *arg)
 430 {
 431         uint64_t cur_time = rte_get_timer_cycles();
 432         uint64_t period;
 433
 434         if (unlikely((tim_lcore != (unsigned)LCORE_ID_ANY) &&
 435                         !rte_lcore_is_enabled(tim_lcore)))
 436                 return -1;
 437
 438         if (type == PERIODICAL)
 439                 period = ticks;
 440         else
 441                 period = 0;
 442
 443         return __rte_timer_reset(tim,  cur_time + ticks, period, tim_lcore,
 444                           fct, arg, 0);
 445 }
 446
 447 /* loop until rte_timer_reset() succeed */
 448 void
 449 rte_timer_reset_sync(struct rte_timer *tim, uint64_t ticks,
 450                      enum rte_timer_type type, unsigned tim_lcore,
 451                      rte_timer_cb_t fct, void *arg)
 452 {
 453         while (rte_timer_reset(tim, ticks, type, tim_lcore,
 454                                fct, arg) != 0)
 455                 rte_pause();
 456 }
 457
 458 /* Stop the timer associated with the timer handle tim */
 459 int
 460 rte_timer_stop(struct rte_timer *tim)
 461 {
 462         union rte_timer_status prev_status, status;
 463         unsigned lcore_id = rte_lcore_id();
 464         int ret;
 465
 466         /* wait that the timer is in correct status before update,
 467          * and mark it as being configured */
 468         ret = timer_set_config_state(tim, &prev_status);
 469         if (ret < 0)
 470                 return -1;
 471
 472         __TIMER_STAT_ADD(stop, 1);
 473         if (prev_status.state == RTE_TIMER_RUNNING &&
 474             lcore_id < RTE_MAX_LCORE) {
 475                 priv_timer[lcore_id].updated = 1;
 476         }
 477
 478         /* remove it from list */
 479         if (prev_status.state == RTE_TIMER_PENDING) {
 480                 timer_del(tim, prev_status, 0);
 481                 __TIMER_STAT_ADD(pending, -1);
 482         }
 483
 484         /* mark timer as stopped */
 485         rte_wmb();
 486         status.state = RTE_TIMER_STOP;
 487         status.owner = RTE_TIMER_NO_OWNER;
 488         tim->status.u32 = status.u32;
 489
 490         return 0;
 491 }
 492
 493 /* loop until rte_timer_stop() succeed */
 494 void
 495 rte_timer_stop_sync(struct rte_timer *tim)
 496 {
 497         while (rte_timer_stop(tim) != 0)
 498                 rte_pause();
 499 }
 500
 501 /* Test the PENDING status of the timer handle tim */
 502 int
 503 rte_timer_pending(struct rte_timer *tim)
 504 {
 505         return tim->status.state == RTE_TIMER_PENDING;
 506 }
 507
 508 /* must be called periodically, run all timer that expired */
 509 void rte_timer_manage(void)
 510 {
 511         union rte_timer_status status;
 512         struct rte_timer *tim, *next_tim;
 513         struct rte_timer *run_first_tim, **pprev;
 514         unsigned lcore_id = rte_lcore_id();
 515         struct rte_timer *prev[MAX_SKIPLIST_DEPTH + 1];
 516         uint64_t cur_time;
 517         int i, ret;
 518
 519         /* timer manager only runs on EAL thread with valid lcore_id */
 520         assert(lcore_id < RTE_MAX_LCORE);
 521
 522         __TIMER_STAT_ADD(manage, 1);
 523         /* optimize for the case where per-cpu list is empty */
 524         if (priv_timer[lcore_id].pending_head.sl_next[0] == NULL)
 525                 return;
 526         cur_time = rte_get_timer_cycles();
 527
 528 #ifdef RTE_ARCH_X86_64
 529         /* on 64-bit the value cached in the pending_head.expired will be
 530          * updated atomically, so we can consult that for a quick check here
 531          * outside the lock */
 532         if (likely(priv_timer[lcore_id].pending_head.expire > cur_time))
 533                 return;
 534 #endif
 535
 536         /* browse ordered list, add expired timers in 'expired' list */
 537         rte_spinlock_lock(&priv_timer[lcore_id].list_lock);
 538
 539         /* if nothing to do just unlock and return */
 540         if (priv_timer[lcore_id].pending_head.sl_next[0] == NULL ||
 541             priv_timer[lcore_id].pending_head.sl_next[0]->expire > cur_time) {
 542                 rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
 543                 return;
 544         }
 545
 546         /* save start of list of expired timers */
 547         tim = priv_timer[lcore_id].pending_head.sl_next[0];
 548
 549         /* break the existing list at current time point */
 550         timer_get_prev_entries(cur_time, lcore_id, prev);
 551         for (i = priv_timer[lcore_id].curr_skiplist_depth -1; i >= 0; i--) {
 552                 if (prev[i] == &priv_timer[lcore_id].pending_head)
 553                         continue;
 554                 priv_timer[lcore_id].pending_head.sl_next[i] =
 555                     prev[i]->sl_next[i];
 556                 if (prev[i]->sl_next[i] == NULL)
 557                         priv_timer[lcore_id].curr_skiplist_depth--;
 558                 prev[i] ->sl_next[i] = NULL;
 559         }
 560
 561         /* transition run-list from PENDING to RUNNING */
 562         run_first_tim = tim;
 563         pprev = &run_first_tim;
 564
 565         for ( ; tim != NULL; tim = next_tim) {
 566                 next_tim = tim->sl_next[0];
 567
 568                 ret = timer_set_running_state(tim);
 569                 if (likely(ret == 0)) {
 570                         pprev = &tim->sl_next[0];
 571                 } else {
 572                         /* another core is trying to re-config this one,
 573                          * remove it from local expired list
 574                          */
 575                         *pprev = next_tim;
 576                 }
 577         }
 578
 579         /* update the next to expire timer value */
 580         priv_timer[lcore_id].pending_head.expire =
 581             (priv_timer[lcore_id].pending_head.sl_next[0] == NULL) ? 0 :
 582                 priv_timer[lcore_id].pending_head.sl_next[0]->expire;
 583
 584         rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
 585
 586         /* now scan expired list and call callbacks */
 587         for (tim = run_first_tim; tim != NULL; tim = next_tim) {
 588                 next_tim = tim->sl_next[0];
 589                 priv_timer[lcore_id].updated = 0;
 590                 priv_timer[lcore_id].running_tim = tim;
 591
 592                 /* execute callback function with list unlocked */
 593                 tim->f(tim, tim->arg);
 594
 595                 __TIMER_STAT_ADD(pending, -1);
 596                 /* the timer was stopped or reloaded by the callback
 597                  * function, we have nothing to do here */
 598                 if (priv_timer[lcore_id].updated == 1)
 599                         continue;
 600
 601                 if (tim->period == 0) {
 602                         /* remove from done list and mark timer as stopped */
 603                         status.state = RTE_TIMER_STOP;
 604                         status.owner = RTE_TIMER_NO_OWNER;
 605                         rte_wmb();
 606                         tim->status.u32 = status.u32;
 607                 }
 608                 else {
 609                         /* keep it in list and mark timer as pending */
 610                         rte_spinlock_lock(&priv_timer[lcore_id].list_lock);
 611                         status.state = RTE_TIMER_PENDING;
 612                         __TIMER_STAT_ADD(pending, 1);
 613                         status.owner = (int16_t)lcore_id;
 614                         rte_wmb();
 615                         tim->status.u32 = status.u32;
 616                         __rte_timer_reset(tim, tim->expire + tim->period,
 617                                 tim->period, lcore_id, tim->f, tim->arg, 1);
 618                         rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
 619                 }
 620         }
 621         priv_timer[lcore_id].running_tim = NULL;
 622 }
 623
 624 /* dump statistics about timers */
 625 void rte_timer_dump_stats(FILE *f)
 626 {
 627 #ifdef RTE_LIBRTE_TIMER_DEBUG
 628         struct rte_timer_debug_stats sum;
 629         unsigned lcore_id;
 630
 631         memset(&sum, 0, sizeof(sum));
 632         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
 633                 sum.reset += priv_timer[lcore_id].stats.reset;
 634                 sum.stop += priv_timer[lcore_id].stats.stop;
 635                 sum.manage += priv_timer[lcore_id].stats.manage;
 636                 sum.pending += priv_timer[lcore_id].stats.pending;
 637         }
 638         fprintf(f, "Timer statistics:\n");
 639         fprintf(f, "  reset = %"PRIu64"\n", sum.reset);
 640         fprintf(f, "  stop = %"PRIu64"\n", sum.stop);
 641         fprintf(f, "  manage = %"PRIu64"\n", sum.manage);
 642         fprintf(f, "  pending = %"PRIu64"\n", sum.pending);
 643 #else
 644         fprintf(f, "No timer statistics, RTE_LIBRTE_TIMER_DEBUG is disabled\n");
 645 #endif
 646 }