timer: allow reset on service cores
[dpdk.git] / 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_lcore.h>
50 #include <rte_branch_prediction.h>
51 #include <rte_spinlock.h>
52 #include <rte_random.h>
53 #include <rte_pause.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 being 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                                 rte_lcore_has_role(tim_lcore, ROLE_SERVICE))))
437                 return -1;
438
439         if (type == PERIODICAL)
440                 period = ticks;
441         else
442                 period = 0;
443
444         return __rte_timer_reset(tim,  cur_time + ticks, period, tim_lcore,
445                           fct, arg, 0);
446 }
447
448 /* loop until rte_timer_reset() succeed */
449 void
450 rte_timer_reset_sync(struct rte_timer *tim, uint64_t ticks,
451                      enum rte_timer_type type, unsigned tim_lcore,
452                      rte_timer_cb_t fct, void *arg)
453 {
454         while (rte_timer_reset(tim, ticks, type, tim_lcore,
455                                fct, arg) != 0)
456                 rte_pause();
457 }
458
459 /* Stop the timer associated with the timer handle tim */
460 int
461 rte_timer_stop(struct rte_timer *tim)
462 {
463         union rte_timer_status prev_status, status;
464         unsigned lcore_id = rte_lcore_id();
465         int ret;
466
467         /* wait that the timer is in correct status before update,
468          * and mark it as being configured */
469         ret = timer_set_config_state(tim, &prev_status);
470         if (ret < 0)
471                 return -1;
472
473         __TIMER_STAT_ADD(stop, 1);
474         if (prev_status.state == RTE_TIMER_RUNNING &&
475             lcore_id < RTE_MAX_LCORE) {
476                 priv_timer[lcore_id].updated = 1;
477         }
478
479         /* remove it from list */
480         if (prev_status.state == RTE_TIMER_PENDING) {
481                 timer_del(tim, prev_status, 0);
482                 __TIMER_STAT_ADD(pending, -1);
483         }
484
485         /* mark timer as stopped */
486         rte_wmb();
487         status.state = RTE_TIMER_STOP;
488         status.owner = RTE_TIMER_NO_OWNER;
489         tim->status.u32 = status.u32;
490
491         return 0;
492 }
493
494 /* loop until rte_timer_stop() succeed */
495 void
496 rte_timer_stop_sync(struct rte_timer *tim)
497 {
498         while (rte_timer_stop(tim) != 0)
499                 rte_pause();
500 }
501
502 /* Test the PENDING status of the timer handle tim */
503 int
504 rte_timer_pending(struct rte_timer *tim)
505 {
506         return tim->status.state == RTE_TIMER_PENDING;
507 }
508
509 /* must be called periodically, run all timer that expired */
510 void rte_timer_manage(void)
511 {
512         union rte_timer_status status;
513         struct rte_timer *tim, *next_tim;
514         struct rte_timer *run_first_tim, **pprev;
515         unsigned lcore_id = rte_lcore_id();
516         struct rte_timer *prev[MAX_SKIPLIST_DEPTH + 1];
517         uint64_t cur_time;
518         int i, ret;
519
520         /* timer manager only runs on EAL thread with valid lcore_id */
521         assert(lcore_id < RTE_MAX_LCORE);
522
523         __TIMER_STAT_ADD(manage, 1);
524         /* optimize for the case where per-cpu list is empty */
525         if (priv_timer[lcore_id].pending_head.sl_next[0] == NULL)
526                 return;
527         cur_time = rte_get_timer_cycles();
528
529 #ifdef RTE_ARCH_X86_64
530         /* on 64-bit the value cached in the pending_head.expired will be
531          * updated atomically, so we can consult that for a quick check here
532          * outside the lock */
533         if (likely(priv_timer[lcore_id].pending_head.expire > cur_time))
534                 return;
535 #endif
536
537         /* browse ordered list, add expired timers in 'expired' list */
538         rte_spinlock_lock(&priv_timer[lcore_id].list_lock);
539
540         /* if nothing to do just unlock and return */
541         if (priv_timer[lcore_id].pending_head.sl_next[0] == NULL ||
542             priv_timer[lcore_id].pending_head.sl_next[0]->expire > cur_time) {
543                 rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
544                 return;
545         }
546
547         /* save start of list of expired timers */
548         tim = priv_timer[lcore_id].pending_head.sl_next[0];
549
550         /* break the existing list at current time point */
551         timer_get_prev_entries(cur_time, lcore_id, prev);
552         for (i = priv_timer[lcore_id].curr_skiplist_depth -1; i >= 0; i--) {
553                 if (prev[i] == &priv_timer[lcore_id].pending_head)
554                         continue;
555                 priv_timer[lcore_id].pending_head.sl_next[i] =
556                     prev[i]->sl_next[i];
557                 if (prev[i]->sl_next[i] == NULL)
558                         priv_timer[lcore_id].curr_skiplist_depth--;
559                 prev[i] ->sl_next[i] = NULL;
560         }
561
562         /* transition run-list from PENDING to RUNNING */
563         run_first_tim = tim;
564         pprev = &run_first_tim;
565
566         for ( ; tim != NULL; tim = next_tim) {
567                 next_tim = tim->sl_next[0];
568
569                 ret = timer_set_running_state(tim);
570                 if (likely(ret == 0)) {
571                         pprev = &tim->sl_next[0];
572                 } else {
573                         /* another core is trying to re-config this one,
574                          * remove it from local expired list
575                          */
576                         *pprev = next_tim;
577                 }
578         }
579
580         /* update the next to expire timer value */
581         priv_timer[lcore_id].pending_head.expire =
582             (priv_timer[lcore_id].pending_head.sl_next[0] == NULL) ? 0 :
583                 priv_timer[lcore_id].pending_head.sl_next[0]->expire;
584
585         rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
586
587         /* now scan expired list and call callbacks */
588         for (tim = run_first_tim; tim != NULL; tim = next_tim) {
589                 next_tim = tim->sl_next[0];
590                 priv_timer[lcore_id].updated = 0;
591                 priv_timer[lcore_id].running_tim = tim;
592
593                 /* execute callback function with list unlocked */
594                 tim->f(tim, tim->arg);
595
596                 __TIMER_STAT_ADD(pending, -1);
597                 /* the timer was stopped or reloaded by the callback
598                  * function, we have nothing to do here */
599                 if (priv_timer[lcore_id].updated == 1)
600                         continue;
601
602                 if (tim->period == 0) {
603                         /* remove from done list and mark timer as stopped */
604                         status.state = RTE_TIMER_STOP;
605                         status.owner = RTE_TIMER_NO_OWNER;
606                         rte_wmb();
607                         tim->status.u32 = status.u32;
608                 }
609                 else {
610                         /* keep it in list and mark timer as pending */
611                         rte_spinlock_lock(&priv_timer[lcore_id].list_lock);
612                         status.state = RTE_TIMER_PENDING;
613                         __TIMER_STAT_ADD(pending, 1);
614                         status.owner = (int16_t)lcore_id;
615                         rte_wmb();
616                         tim->status.u32 = status.u32;
617                         __rte_timer_reset(tim, tim->expire + tim->period,
618                                 tim->period, lcore_id, tim->f, tim->arg, 1);
619                         rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
620                 }
621         }
622         priv_timer[lcore_id].running_tim = NULL;
623 }
624
625 /* dump statistics about timers */
626 void rte_timer_dump_stats(FILE *f)
627 {
628 #ifdef RTE_LIBRTE_TIMER_DEBUG
629         struct rte_timer_debug_stats sum;
630         unsigned lcore_id;
631
632         memset(&sum, 0, sizeof(sum));
633         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
634                 sum.reset += priv_timer[lcore_id].stats.reset;
635                 sum.stop += priv_timer[lcore_id].stats.stop;
636                 sum.manage += priv_timer[lcore_id].stats.manage;
637                 sum.pending += priv_timer[lcore_id].stats.pending;
638         }
639         fprintf(f, "Timer statistics:\n");
640         fprintf(f, "  reset = %"PRIu64"\n", sum.reset);
641         fprintf(f, "  stop = %"PRIu64"\n", sum.stop);
642         fprintf(f, "  manage = %"PRIu64"\n", sum.manage);
643         fprintf(f, "  pending = %"PRIu64"\n", sum.pending);
644 #else
645         fprintf(f, "No timer statistics, RTE_LIBRTE_TIMER_DEBUG is disabled\n");
646 #endif
647 }