Line data    Source code

       1             : /*
       2             :  * Timer Wheel
       3             :  * Copyright (C) 2016 Cumulus Networks, Inc.
       4             :  * Donald Sharp
       5             :  *
       6             :  * This program is free software; you can redistribute it and/or modify
       7             :  * it under the terms of the GNU General Public License as published by
       8             :  * the Free Software Foundation; either version 2 of the License, or
       9             :  * (at your option) any later version.
      10             :  *
      11             :  * This program is distributed in the hope that it will be useful, but
      12             :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU General Public License along
      17             :  * with this program; see the file COPYING; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : #include "zebra.h"
      21             : #include "linklist.h"
      22             : #include "thread.h"
      23             : #include "memory.h"
      24             : #include "wheel.h"
      25             : #include "log.h"
      26             : 
      27           8 : DEFINE_MTYPE_STATIC(LIB, TIMER_WHEEL, "Timer Wheel");
      28           8 : DEFINE_MTYPE_STATIC(LIB, TIMER_WHEEL_LIST, "Timer Wheel Slot List");
      29             : 
      30             : static int debug_timer_wheel = 0;
      31             : 
      32             : static void wheel_timer_thread(struct thread *t);
      33             : 
      34           1 : static void wheel_timer_thread_helper(struct thread *t)
      35             : {
      36           1 :         struct listnode *node, *nextnode;
      37           1 :         unsigned long long curr_slot;
      38           1 :         unsigned int slots_to_skip = 1;
      39           1 :         struct timer_wheel *wheel;
      40           1 :         void *data;
      41             : 
      42           1 :         wheel = THREAD_ARG(t);
      43             : 
      44           1 :         wheel->curr_slot += wheel->slots_to_skip;
      45             : 
      46           1 :         curr_slot = wheel->curr_slot % wheel->slots;
      47             : 
      48           1 :         if (debug_timer_wheel)
      49           0 :                 zlog_debug("%s: Wheel Slot: %lld(%lld) count: %d", __func__,
      50             :                            wheel->curr_slot, curr_slot,
      51             :                            listcount(wheel->wheel_slot_lists[curr_slot]));
      52             : 
      53           2 :         for (ALL_LIST_ELEMENTS(wheel->wheel_slot_lists[curr_slot], node,
      54             :                                nextnode, data))
      55           0 :                 (*wheel->slot_run)(data);
      56             : 
      57         100 :         while (list_isempty(wheel->wheel_slot_lists[(curr_slot + slots_to_skip)
      58             :                                                     % wheel->slots])
      59         200 :                && (curr_slot + slots_to_skip) % wheel->slots != curr_slot)
      60          99 :                 slots_to_skip++;
      61             : 
      62           1 :         wheel->slots_to_skip = slots_to_skip;
      63           1 :         thread_add_timer_msec(wheel->master, wheel_timer_thread, wheel,
      64             :                               wheel->nexttime * slots_to_skip, &wheel->timer);
      65           1 : }
      66             : 
      67           1 : static void wheel_timer_thread(struct thread *t)
      68             : {
      69           1 :         struct timer_wheel *wheel;
      70             : 
      71           1 :         wheel = THREAD_ARG(t);
      72             : 
      73           1 :         thread_execute(wheel->master, wheel_timer_thread_helper, wheel, 0);
      74           1 : }
      75             : 
      76           1 : struct timer_wheel *wheel_init(struct thread_master *master, int period,
      77             :                                size_t slots, unsigned int (*slot_key)(const void *),
      78             :                                void (*slot_run)(void *),
      79             :                                const char *run_name)
      80             : {
      81           1 :         struct timer_wheel *wheel;
      82           1 :         size_t i;
      83             : 
      84           1 :         wheel = XCALLOC(MTYPE_TIMER_WHEEL, sizeof(struct timer_wheel));
      85             : 
      86           1 :         wheel->name = XSTRDUP(MTYPE_TIMER_WHEEL, run_name);
      87           1 :         wheel->slot_key = slot_key;
      88           1 :         wheel->slot_run = slot_run;
      89             : 
      90           1 :         wheel->period = period;
      91           1 :         wheel->slots = slots;
      92           1 :         wheel->curr_slot = 0;
      93           1 :         wheel->master = master;
      94           1 :         wheel->nexttime = period / slots;
      95             : 
      96           1 :         wheel->wheel_slot_lists = XCALLOC(MTYPE_TIMER_WHEEL_LIST,
      97             :                                           slots * sizeof(struct list *));
      98         101 :         for (i = 0; i < slots; i++)
      99         100 :                 wheel->wheel_slot_lists[i] = list_new();
     100             : 
     101           1 :         thread_add_timer_msec(wheel->master, wheel_timer_thread, wheel,
     102             :                               wheel->nexttime, &wheel->timer);
     103             : 
     104           1 :         return wheel;
     105             : }
     106             : 
     107           1 : void wheel_delete(struct timer_wheel *wheel)
     108             : {
     109           1 :         int i;
     110             : 
     111         101 :         for (i = 0; i < wheel->slots; i++) {
     112         100 :                 list_delete(&wheel->wheel_slot_lists[i]);
     113             :         }
     114             : 
     115           1 :         THREAD_OFF(wheel->timer);
     116           1 :         XFREE(MTYPE_TIMER_WHEEL_LIST, wheel->wheel_slot_lists);
     117           1 :         XFREE(MTYPE_TIMER_WHEEL, wheel->name);
     118           1 :         XFREE(MTYPE_TIMER_WHEEL, wheel);
     119           1 : }
     120             : 
     121           1 : int wheel_add_item(struct timer_wheel *wheel, void *item)
     122             : {
     123           1 :         long long slot;
     124             : 
     125           1 :         slot = (*wheel->slot_key)(item);
     126             : 
     127           1 :         if (debug_timer_wheel)
     128           0 :                 zlog_debug("%s: Inserting %p: %lld %lld", __func__, item, slot,
     129             :                            slot % wheel->slots);
     130           1 :         listnode_add(wheel->wheel_slot_lists[slot % wheel->slots], item);
     131             : 
     132           1 :         return 0;
     133             : }
     134             : 
     135           1 : int wheel_remove_item(struct timer_wheel *wheel, void *item)
     136             : {
     137           1 :         long long slot;
     138             : 
     139           1 :         slot = (*wheel->slot_key)(item);
     140             : 
     141           1 :         if (debug_timer_wheel)
     142           0 :                 zlog_debug("%s: Removing %p: %lld %lld", __func__, item, slot,
     143             :                            slot % wheel->slots);
     144           1 :         listnode_delete(wheel->wheel_slot_lists[slot % wheel->slots], item);
     145             : 
     146           1 :         return 0;
     147             : }