indent the scheduler code
authorHannes Gredler <hannes@gredler.at>
Sun, 18 May 2008 18:11:59 +0000 (20:11 +0200)
committerHannes Gredler <hannes@gredler.at>
Sun, 18 May 2008 18:11:59 +0000 (20:11 +0200)
src/scheduler.c
src/scheduler.h

index 2df1f03..7fbd946 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org)
@@ -39,7 +40,6 @@
  *
  */
 
-
 #include "defs.h"
 #include "scheduler.h"
 #include "log.h"
 #include "olsr_cookie.h"
 
 /* Timer data, global. Externed in defs.h */
-clock_t now_times;  /* current idea of times(2) reported uptime */
+clock_t now_times;                    /* current idea of times(2) reported uptime */
 
 /* Hashed root of all timers */
 struct list_node timer_wheel[TIMER_WHEEL_SLOTS];
-clock_t timer_last_run; /* remember the last timeslot walk */
-struct list_node *timer_walk_list_node = NULL; /* used for timeslot walk */
+clock_t timer_last_run;                       /* remember the last timeslot walk */
+struct list_node *timer_walk_list_node = NULL; /* used for timeslot walk */
 
 /* Pool of timers to avoid malloc() churn */
 struct list_node free_timer_list;
@@ -98,10 +98,10 @@ olsr_scheduler_sleep(clock_t scheduler_runtime)
 
   if (timercmp(&time_used, &next_interval, <)) {
     timersub(&next_interval, &time_used, &sleeptime_val);
-         
+
     sleeptime_spec.tv_sec = sleeptime_val.tv_sec;
     sleeptime_spec.tv_nsec = sleeptime_val.tv_usec * NSEC_PER_USEC;
-         
+
     while (nanosleep(&sleeptime_spec, &remainder_spec) < 0)
       sleeptime_spec = remainder_spec;
   }
@@ -119,15 +119,16 @@ olsr_scheduler_sleep(clock_t scheduler_runtime)
 void
 olsr_scheduler(void)
 {
-  struct tms tms_buf;   /* Buffer for times(2) calls. */
+  struct tms tms_buf;                 /* Buffer for times(2) calls. */
   struct interface *ifn;
 
-  OLSR_PRINTF(1, "Scheduler started - polling every %0.2f seconds\n", olsr_cnf->pollrate);
+  OLSR_PRINTF(1, "Scheduler started - polling every %0.2f seconds\n",
+             olsr_cnf->pollrate);
   OLSR_PRINTF(3, "Max jitter is %f\n\n", olsr_cnf->max_jitter);
 
   /* Main scheduler loop */
   for (;;) {
+
     /*
      * Update the global timestamp. We are using a non-wallclock timer here
      * to avoid any undesired side effects if the system clock changes.
@@ -137,10 +138,10 @@ olsr_scheduler(void)
     /* Read incoming data */
     olsr_poll_sockets();
 
-    /* Process timers (before packet generation) */      
+    /* Process timers (before packet generation) */
     olsr_walk_timers(&timer_last_run);
 
-    /* Update */      
+    /* Update */
     olsr_process_changes();
 
     /* Check for changes in topology */
@@ -151,9 +152,9 @@ olsr_scheduler(void)
     }
 
     /* looping trough interfaces and emmitting pending data */
-    for (ifn = ifnet; ifn ; ifn = ifn->int_next) { 
+    for (ifn = ifnet; ifn; ifn = ifn->int_next) {
       if (net_output_pending(ifn) && TIMED_OUT(ifn->fwdtimer)) {
-        net_output(ifn);
+       net_output(ifn);
       }
     }
 
@@ -165,7 +166,7 @@ olsr_scheduler(void)
     if (olsr_win32_end_request) {
       break;
     }
-#endif      
+#endif
   }
 
 #if defined WIN32
@@ -177,7 +178,7 @@ olsr_scheduler(void)
    * and hence also kill us.
    */
   while (1) {
-    Sleep(1000); /* milliseconds */
+    Sleep(1000);               /* milliseconds */
   }
 #endif
 }
@@ -191,7 +192,7 @@ olsr_scheduler(void)
  * @param cached result of random() at system init.
  * @return the absolute timer in system clock tick units
  */
-static clock_t 
+static clock_t
 olsr_jitter(unsigned int rel_time, olsr_u8_t jitter_pct, unsigned int random)
 {
   unsigned int jitter_time;
@@ -212,7 +213,7 @@ olsr_jitter(unsigned int rel_time, olsr_u8_t jitter_pct, unsigned int random)
 
 #if 0
   OLSR_PRINTF(3, "TIMER: jitter %u%% rel_time %ums to %ums\n",
-              jitter_pct, rel_time, rel_time - jitter_time);
+             jitter_pct, rel_time, rel_time - jitter_time);
 #endif
 
   return GET_TIMESTAMP(rel_time - jitter_time);
@@ -239,7 +240,7 @@ olsr_get_timer(void)
    */
   if (!list_is_empty(&free_timer_list)) {
     timer_list_node = free_timer_list.next;
-    
+
     /* carve it out of the pool, do not memset overwrite timer->timer_random */
     list_remove(timer_list_node);
     timer = list2timer(timer_list_node);
@@ -250,14 +251,15 @@ olsr_get_timer(void)
   /*
    * Nothing in the pool, allocate a new chunk.
    */
-  timer_block = olsr_malloc(sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK,
-                            "timer chunk");
-  memset(timer_block, 0, sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK); 
+  timer_block =
+    olsr_malloc(sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK,
+               "timer chunk");
+  memset(timer_block, 0, sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK);
 
 #if 0
   OLSR_PRINTF(3, "TIMER: alloc %u bytes chunk at %p\n",
-              sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK,
-              timer_block);
+             sizeof(struct timer_entry) * OLSR_TIMER_MEMORY_CHUNK,
+             timer_block);
 #endif
 
   /*
@@ -298,7 +300,7 @@ olsr_init_timers(void)
 
   OLSR_PRINTF(5, "TIMER: init timers\n");
 
-  memset(timer_wheel, 0 , sizeof(timer_wheel));
+  memset(timer_wheel, 0, sizeof(timer_wheel));
 
   timer_head_node = timer_wheel;
   for (index = 0; index < TIMER_WHEEL_SLOTS; index++) {
@@ -322,7 +324,7 @@ olsr_init_timers(void)
  * Callback the provided function with the context pointer.
  */
 void
-olsr_walk_timers(clock_t *last_run)
+olsr_walk_timers(clock_t * last_run)
 {
   static struct timer_entry *timer;
   struct list_node *timer_head_node;
@@ -348,9 +350,8 @@ olsr_walk_timers(clock_t *last_run)
     timer_head_node = &timer_wheel[*last_run & TIMER_WHEEL_MASK];
 
     /* Walk all entries hanging off this hash bucket */
-    for (timer_walk_list_node = timer_head_node->next;
-         timer_walk_list_node != timer_head_node; /* circular list */
-         timer_walk_list_node = timer_walk_list_node->next) {
+    for (timer_walk_list_node = timer_head_node->next; timer_walk_list_node != timer_head_node;        /* circular list */
+        timer_walk_list_node = timer_walk_list_node->next) {
 
       timer = list2timer(timer_walk_list_node);
 
@@ -359,44 +360,42 @@ olsr_walk_timers(clock_t *last_run)
       /* Ready to fire ? */
       if (TIMED_OUT(timer->timer_clock)) {
 
-        OLSR_PRINTF(3, "TIMER: fire %s timer %p, ctx %p, "
-                    "at clocktick %u\n",
-                    olsr_cookie_name(timer->timer_cookie),
-                    timer, timer->timer_cb_context,
-                    (unsigned int)(*last_run));
+       OLSR_PRINTF(3, "TIMER: fire %s timer %p, ctx %p, "
+                   "at clocktick %u\n",
+                   olsr_cookie_name(timer->timer_cookie),
+                   timer, timer->timer_cb_context, (unsigned int)(*last_run));
 
-        /* This timer is expired, call into the provided callback function */
-        timer->timer_cb(timer->timer_cb_context);
+       /* This timer is expired, call into the provided callback function */
+       timer->timer_cb(timer->timer_cb_context);
 
-        if (timer->timer_period) {
+       if (timer->timer_period) {
 
-          /*
-           * Don't restart the periodic timer if the callback function has
-           * stopped the timer.
-           */
-          if (timer->timer_flags & OLSR_TIMER_RUNNING) {
+         /*
+          * Don't restart the periodic timer if the callback function has
+          * stopped the timer.
+          */
+         if (timer->timer_flags & OLSR_TIMER_RUNNING) {
 
-            /* For periodical timers, rehash the random number and restart */
-            timer->timer_random = random();
-            olsr_change_timer(timer, timer->timer_period,
-                              timer->timer_jitter_pct,
-                              OLSR_TIMER_PERIODIC);
-          }
+           /* For periodical timers, rehash the random number and restart */
+           timer->timer_random = random();
+           olsr_change_timer(timer, timer->timer_period,
+                             timer->timer_jitter_pct, OLSR_TIMER_PERIODIC);
+         }
 
-        } else {
+       } else {
 
-          /*
-           * Don't stop the singleshot timer if the callback function has
-           * stopped the timer.
-           */
-          if (timer->timer_flags & OLSR_TIMER_RUNNING) {
+         /*
+          * Don't stop the singleshot timer if the callback function has
+          * stopped the timer.
+          */
+         if (timer->timer_flags & OLSR_TIMER_RUNNING) {
 
-            /* Singleshot timers are stopped and returned to the pool */
-            olsr_stop_timer(timer);
-          }
-        }
+           /* Singleshot timers are stopped and returned to the pool */
+           olsr_stop_timer(timer);
+         }
+       }
 
-        timers_fired++;
+       timers_fired++;
       }
     }
 
@@ -412,9 +411,9 @@ olsr_walk_timers(clock_t *last_run)
 
 #ifdef DEBUG
   OLSR_PRINTF(3, "TIMER: processed %4u/%u clockwheel slots, "
-              "timers walked %4u/%u, timers fired %u\n",
-              wheel_slot_walks, TIMER_WHEEL_SLOTS,
-              total_timers_walked, timers_running, total_timers_fired);
+             "timers walked %4u/%u, timers fired %u\n",
+             wheel_slot_walks, TIMER_WHEEL_SLOTS,
+             total_timers_walked, timers_running, total_timers_fired);
 #endif
 
   /*
@@ -475,7 +474,7 @@ olsr_get_timezone(void)
  *
  * @return buffer to a formatted system time string.
  */
-const char*
+const char *
 olsr_wallclock_string(void)
 {
   static char buf[4][sizeof("00:00:00.000000")];
@@ -485,7 +484,7 @@ olsr_wallclock_string(void)
   int sec, usec;
 
   ret = buf[idx];
-  idx = (idx+1) & 3;
+  idx = (idx + 1) & 3;
 
   gettimeofday(&now, NULL);
 
@@ -493,7 +492,7 @@ olsr_wallclock_string(void)
   usec = (int)now.tv_usec;
 
   snprintf(ret, sizeof(buf), "%02u:%02u:%02u.%06u",
-           (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60, usec);
+          (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60, usec);
 
   return ret;
 }
@@ -507,7 +506,7 @@ olsr_wallclock_string(void)
  * @param absolute time expressed in clockticks
  * @return buffer to a formatted system time string.
  */
-const char*
+const char *
 olsr_clock_string(clock_t clock)
 {
   static char buf[4][sizeof("00:00:00.000")];
@@ -516,14 +515,14 @@ olsr_clock_string(clock_t clock)
   unsigned int sec, msec;
 
   ret = buf[idx];
-  idx = (idx+1) & 3;
+  idx = (idx + 1) & 3;
 
   /* On most systems a clocktick is a 10ms quantity. */
   msec = olsr_cnf->system_tick_divider * (unsigned int)(clock - now_times);
   sec = msec / MSEC_PER_SEC;
 
-  snprintf(ret, sizeof(buf)/4, "%02u:%02u:%02u.%03u",
-           sec / 3600, (sec % 3600) / 60, (sec % 60), (msec % MSEC_PER_SEC));
+  snprintf(ret, sizeof(buf) / 4, "%02u:%02u:%02u.%03u",
+          sec / 3600, (sec % 3600) / 60, (sec % 60), (msec % MSEC_PER_SEC));
 
   return ret;
 }
@@ -540,8 +539,8 @@ olsr_clock_string(clock_t clock)
  */
 struct timer_entry *
 olsr_start_timer(unsigned int rel_time, olsr_u8_t jitter_pct,
-                 olsr_bool periodical, void (*timer_cb_function)(void *),
-                 void *context, olsr_cookie_t cookie)
+                olsr_bool periodical, void (*timer_cb_function) (void *),
+                void *context, olsr_cookie_t cookie)
 {
   struct timer_entry *timer;
 
@@ -569,13 +568,13 @@ olsr_start_timer(unsigned int rel_time, olsr_u8_t jitter_pct,
    * Now insert in the respective timer_wheel slot.
    */
   list_add_before(&timer_wheel[timer->timer_clock & TIMER_WHEEL_MASK],
-                  &timer->timer_list);
+                 &timer->timer_list);
   timers_running++;
 
 #ifdef DEBUG
   OLSR_PRINTF(3, "TIMER: start %s timer %p firing in %s, ctx %p\n",
-              olsr_cookie_name(timer->timer_cookie),
-              timer, olsr_clock_string(timer->timer_clock), context);
+             olsr_cookie_name(timer->timer_cookie),
+             timer, olsr_clock_string(timer->timer_clock), context);
 #endif
 
   return timer;
@@ -610,12 +609,11 @@ olsr_stop_timer(struct timer_entry *timer)
   if (!timer) {
     return;
   }
-
 #ifdef DEBUG
   OLSR_PRINTF(3, "TIMER: stop %s timer %p firing in %s, ctx %p\n",
-              olsr_cookie_name(timer->timer_cookie),
-              timer, olsr_clock_string(timer->timer_clock),
-              timer->timer_cb_context);
+             olsr_cookie_name(timer->timer_cookie),
+             timer, olsr_clock_string(timer->timer_clock),
+             timer->timer_cb_context);
 #endif
 
   olsr_update_timer_walk_ctx(timer);
@@ -642,7 +640,7 @@ olsr_stop_timer(struct timer_entry *timer)
  */
 void
 olsr_change_timer(struct timer_entry *timer, unsigned int rel_time,
-                  olsr_u8_t jitter_pct, olsr_bool periodical)
+                 olsr_u8_t jitter_pct, olsr_bool periodical)
 {
 
   /* Sanity check. */
@@ -668,13 +666,12 @@ olsr_change_timer(struct timer_entry *timer, unsigned int rel_time,
    */
   list_remove(&timer->timer_list);
   list_add_before(&timer_wheel[timer->timer_clock & TIMER_WHEEL_MASK],
-                  &timer->timer_list);
+                 &timer->timer_list);
 
 #ifdef DEBUG
   OLSR_PRINTF(3, "TIMER: change %s timer %p, firing to %s, ctx %p\n",
-              olsr_cookie_name(timer->timer_cookie), timer,
-              olsr_clock_string(timer->timer_clock),
-              timer->timer_cb_context);
+             olsr_cookie_name(timer->timer_cookie), timer,
+             olsr_clock_string(timer->timer_clock), timer->timer_cb_context);
 #endif
 }
 
@@ -687,26 +684,26 @@ olsr_change_timer(struct timer_entry *timer, unsigned int rel_time,
  */
 void
 olsr_set_timer(struct timer_entry **timer_ptr, unsigned int rel_time,
-               olsr_u8_t jitter_pct, olsr_bool periodical,
-               void (*timer_cb_function)(void *), void *context,
-               olsr_cookie_t cookie)
+              olsr_u8_t jitter_pct, olsr_bool periodical,
+              void (*timer_cb_function) (void *), void *context,
+              olsr_cookie_t cookie)
 {
 
   if (!*timer_ptr) {
 
     /* No timer running, kick it. */
     *timer_ptr = olsr_start_timer(rel_time, jitter_pct, periodical,
-                                  timer_cb_function, context, cookie);
+                                 timer_cb_function, context, cookie);
   } else {
 
     if (!rel_time) {
 
-      /* No good future time provided, kill it.*/
+      /* No good future time provided, kill it. */
       olsr_stop_timer(*timer_ptr);
       *timer_ptr = NULL;
     } else {
 
-      /* Time is ok and timer is running, change it !*/
+      /* Time is ok and timer is running, change it ! */
       olsr_change_timer(*timer_ptr, rel_time, jitter_pct, periodical);
     }
   }
index 0168f28..6a73d30 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org)
  * For a periodic timer the timer_period field is set to non zero,
  * which causes the timer to run forever until manually stopped.
  */
-struct timer_entry
-{
-  struct list_node timer_list; /* memory pooling, or wheel membership */
-  clock_t timer_clock; /* when timer shall fire (absolute time)*/
-  unsigned int timer_period; /* set for periodical timers (relative time) */
-  olsr_cookie_t timer_cookie; /* used for diag stuff */
-  olsr_u8_t timer_jitter_pct; /* the jitter expressed in percent */
-  olsr_u8_t timer_flags; /* misc flags */
-  unsigned int timer_random; /* cache random() result for performance reasons */
-  void (*timer_cb)(void *); /* callback function */
-  void *timer_cb_context; /* context pointer */
+struct timer_entry {
+  struct list_node timer_list;        /* memory pooling, or wheel membership */
+  clock_t timer_clock;                /* when timer shall fire (absolute time) */
+  unsigned int timer_period;          /* set for periodical timers (relative time) */
+  olsr_cookie_t timer_cookie;         /* used for diag stuff */
+  olsr_u8_t timer_jitter_pct;         /* the jitter expressed in percent */
+  olsr_u8_t timer_flags;              /* misc flags */
+  unsigned int timer_random;          /* cache random() result for performance reasons */
+  void (*timer_cb) (void *);          /* callback function */
+  void *timer_cb_context;             /* context pointer */
 };
 
 /* inline to recast from timer_list back to timer_entry */
 LISTNODE2STRUCT(list2timer, struct timer_entry, timer_list);
 
-#define OLSR_TIMER_ONESHOT    0 /* One shot timer */
-#define OLSR_TIMER_PERIODIC   1 /* Periodic timer */
+#define OLSR_TIMER_ONESHOT    0        /* One shot timer */
+#define OLSR_TIMER_PERIODIC   1        /* Periodic timer */
 
 /* Timer flags */
-#define OLSR_TIMER_RUNNING  ( 1 << 0) /* this timer is running */
+#define OLSR_TIMER_RUNNING  ( 1 << 0)  /* this timer is running */
 
 /* Memory pooling */
-#define OLSR_TIMER_MEMORY_CHUNK 100 /* timers per chunk */
+#define OLSR_TIMER_MEMORY_CHUNK 100    /* timers per chunk */
 
 /* Timers */
 void olsr_init_timers(void);
 void olsr_walk_timers(clock_t *);
 void olsr_set_timer(struct timer_entry **, unsigned int, olsr_u8_t, olsr_bool,
-                    void (*)(void *), void *, olsr_cookie_t);
+                   void (*)(void *), void *, olsr_cookie_t);
 struct timer_entry *olsr_start_timer(unsigned int, olsr_u8_t, olsr_bool,
-                                     void (*)(void *), void *, olsr_cookie_t);
-void olsr_change_timer(struct timer_entry *, unsigned int, olsr_u8_t, olsr_bool);
+                                    void (*)(void *), void *, olsr_cookie_t);
+void olsr_change_timer(struct timer_entry *, unsigned int, olsr_u8_t,
+                      olsr_bool);
 void olsr_stop_timer(struct timer_entry *);
 
 /* Printing timestamps */
-const charolsr_clock_string(clock_t);
-const charolsr_wallclock_string(void);
+const char *olsr_clock_string(clock_t);
+const char *olsr_wallclock_string(void);
 
 /* Main scheduler loop */
-void olsr_scheduler(void) __attribute__((noreturn));
+void olsr_scheduler(void) __attribute__ ((noreturn));
 
 #endif