Cleanup for lq_plugin system, preparation for default fpm
authorHenning Rogge <rogge@fgan.de>
Mon, 19 May 2008 08:49:48 +0000 (10:49 +0200)
committerHenning Rogge <rogge@fgan.de>
Mon, 19 May 2008 08:49:48 +0000 (10:49 +0200)
lib/lq_etx_fpm/src/lq_etx_fpm.c
lib/lq_etx_fpm/src/lq_etx_fpm.h
lib/lq_etx_fpm/src/lq_etx_fpm_plugin.c
lib/lq_etx_fpm/src/lq_etx_fpm_plugin.h
src/fpm.c
src/lq_plugin.c
src/lq_plugin.h
src/lq_plugin_default.c
src/lq_plugin_default.h
src/olsr.c

index fc37249..c7808e5 100644 (file)
 
 /* etx lq plugin (fpm version) settings */
 struct lq_handler lq_etx_fpm_handler = {
-    &lq_etx_fpm_calc_cost,
-    &lq_etx_fpm_calc_cost,
+    &default_lq_initialize_fpm,
     
-    &lq_etx_fpm_olsr_is_relevant_costchange,
+    &default_lq_calc_cost_fpm,
+    &default_lq_calc_cost_fpm,
     
-    &lq_etx_fpm_packet_loss_worker,
-    &lq_etx_fpm_olsr_memorize_foreign_hello_lq,
-    &lq_etx_fpm_olsr_copy_link_lq_into_tc,
-    &lq_etx_fpm_olsr_clear_lq,
-    &lq_etx_fpm_olsr_clear_lq,
+    &default_lq_is_relevant_costchange_fpm,
     
-    &lq_etx_fpm_olsr_serialize_hello_lq_pair,
-    &lq_etx_fpm_olsr_serialize_tc_lq_pair,
-    &lq_etx_fpm_olsr_deserialize_hello_lq_pair,
-    &lq_etx_fpm_olsr_deserialize_tc_lq_pair,
+    &default_lq_packet_loss_worker_fpm,
+    &default_lq_memorize_foreign_hello_fpm,
+    &default_lq_copy_link2tc_fpm,
+    &default_lq_clear_fpm,
+    &default_lq_clear_fpm,
     
-    &lq_etx_fpm_olsr_print_lq,
-    &lq_etx_fpm_olsr_print_lq,
-    &lq_etx_fpm_olsr_print_cost, 
+    &default_lq_serialize_hello_lq_pair_fpm,
+    &default_lq_serialize_tc_lq_pair_fpm,
+    &default_lq_deserialize_hello_lq_pair_fpm,
+    &default_lq_deserialize_tc_lq_pair_fpm,
     
-    sizeof(struct lq_etx_fpm),
-    sizeof(struct lq_etx_fpm)
+    &default_lq_print_fpm,
+    &default_lq_print_fpm,
+    &default_lq_print_cost_fpm, 
+    
+    sizeof(struct default_lq_fpm),
+    sizeof(struct default_lq_fpm)
 };
 
-fpm MINIMAL_LQ;
+fpm minimal_lq;
 fpm aging_factor_new, aging_factor_old;
+fpm aging_quickstart_new, aging_quickstart_old;
 
-int init_lq_etx_fpm(void) {
+void default_lq_initialize_fpm(void) {
   aging_factor_new = ftofpm(olsr_cnf->lq_aging);
   aging_factor_old = fpmsub(itofpm(1), aging_factor_new);
-  if (aging_factor_new == 0 && aging_factor_old == 0) {
-    aging_factor_new = 0;
-  }
   
-  MINIMAL_LQ = ftofpm(0.1);
+  aging_quickstart_new = ftofpm(LQ_QUICKSTART_AGING);
+  aging_quickstart_old = fpmsub(itofpm(1), aging_quickstart_new);
   
-  // activate plugin
-  set_lq_handler(&lq_etx_fpm_handler, LQ_ETX_FPM_HANDLER_NAME);
-  return 1;
+  minimal_lq = ftofpm(MINIMAL_USEFUL_LQ);
 }
 
-olsr_linkcost lq_etx_fpm_calc_cost(const void *ptr) {
-  const struct lq_etx_fpm *lq = ptr;
+olsr_linkcost default_lq_calc_cost_fpm(const void *ptr) {
+  const struct default_lq_fpm *lq = ptr;
   olsr_linkcost cost;
   
-  if (lq->lq < MINIMAL_LQ || lq->nlq < MINIMAL_LQ) {
+  if (lq->lq < minimal_lq || lq->nlq < minimal_lq) {
     return LINK_COST_BROKEN;
   }
   
@@ -108,8 +107,8 @@ olsr_linkcost lq_etx_fpm_calc_cost(const void *ptr) {
   return cost;
 }
 
-int lq_etx_fpm_olsr_serialize_hello_lq_pair(unsigned char *buff, void *ptr) {
-  struct lq_etx_fpm *lq = ptr;
+int default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *ptr) {
+  struct default_lq_fpm *lq = ptr;
   
   buff[0] = (unsigned char)fpmtoi(fpmmuli(lq->lq, 255));
   buff[1] = (unsigned char)fpmtoi(fpmmuli(lq->nlq, 255));
@@ -119,8 +118,8 @@ int lq_etx_fpm_olsr_serialize_hello_lq_pair(unsigned char *buff, void *ptr) {
   return 4;
 }
 
-void lq_etx_fpm_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *ptr) {
-  struct lq_etx_fpm *lq = ptr;
+void default_lq_deserialize_hello_lq_pair_fpm(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_fpm *lq = ptr;
   olsr_u8_t valueLq, valueNlq;
   
   pkt_get_u8(curr, &valueLq);
@@ -131,15 +130,15 @@ void lq_etx_fpm_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *ptr
   lq->nlq = fpmidiv(itofpm((int)valueNlq), 255);
 }
 
-olsr_bool lq_etx_fpm_olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2) {
+olsr_bool default_lq_is_relevant_costchange_fpm(olsr_linkcost c1, olsr_linkcost c2) {
   if (c1 > c2) {
     return c2 - c1 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
   }
   return c1 - c2 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
 }
 
-int lq_etx_fpm_olsr_serialize_tc_lq_pair(unsigned char *buff, void *ptr) {
-  struct lq_etx_fpm *lq = ptr;
+int default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *ptr) {
+  struct default_lq_fpm *lq = ptr;
   
   buff[0] = (unsigned char)fpmtoi(fpmmuli(lq->lq, 255));
   buff[1] = (unsigned char)fpmtoi(fpmmuli(lq->nlq, 255));
@@ -149,8 +148,8 @@ int lq_etx_fpm_olsr_serialize_tc_lq_pair(unsigned char *buff, void *ptr) {
   return 4;
 }
 
-void lq_etx_fpm_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *ptr) {
-  struct lq_etx_fpm *lq = ptr;
+void default_lq_deserialize_tc_lq_pair_fpm(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_fpm *lq = ptr;
   olsr_u8_t valueLq, valueNlq;
   
   pkt_get_u8(curr, &valueLq);
@@ -161,22 +160,30 @@ void lq_etx_fpm_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *ptr) {
   lq->nlq = fpmidiv(itofpm(valueNlq), 255);
 }
 
-olsr_linkcost lq_etx_fpm_packet_loss_worker(struct link_entry *link, void *ptr, olsr_bool lost) {
-  struct lq_etx_fpm *tlq = ptr;
+olsr_linkcost default_lq_packet_loss_worker_fpm(struct link_entry *link, void *ptr, olsr_bool lost) {
+  struct default_lq_fpm *tlq = ptr;
+  fpm alpha_old = aging_factor_old;
+  fpm alpha_new = aging_factor_new;
   
-  fpm link_loss_factor = fpmdiv(itofpm(link->loss_link_multiplier), 65536);
+  fpm link_loss_factor = fpmidiv(itofpm(link->loss_link_multiplier), 65536);
+  
+  if (tlq->quickstart < LQ_QUICKSTART_STEPS) {
+    alpha_new = aging_quickstart_new;
+    alpha_old = aging_quickstart_old;
+    tlq->quickstart++;
+  }
   
   // exponential moving average
-  tlq->lq = fpmmul(tlq->lq, aging_factor_old);
+  tlq->lq = fpmmul(tlq->lq, alpha_old);
   if (lost == 0) {
-    tlq->lq = fpmadd(tlq->lq, fpmmul(aging_factor_new, link_loss_factor));
+    tlq->lq = fpmadd(tlq->lq, fpmmul(alpha_new, link_loss_factor));
   }
-  return lq_etx_fpm_calc_cost(ptr);
+  return default_lq_calc_cost_fpm(ptr);
 }
 
-void lq_etx_fpm_olsr_memorize_foreign_hello_lq(void *ptrLocal, void *ptrForeign) {
-  struct lq_etx_fpm *local = ptrLocal;
-  struct lq_etx_fpm *foreign = ptrForeign;
+void default_lq_memorize_foreign_hello_fpm(void *ptrLocal, void *ptrForeign) {
+  struct default_lq_fpm *local = ptrLocal;
+  struct default_lq_fpm *foreign = ptrForeign;
   
   if (foreign) {
     local->nlq = foreign->lq;
@@ -186,22 +193,22 @@ void lq_etx_fpm_olsr_memorize_foreign_hello_lq(void *ptrLocal, void *ptrForeign)
   }
 }
 
-void lq_etx_fpm_olsr_copy_link_lq_into_tc(void *target, void *source) {
-  memcpy(target, source, sizeof(struct lq_etx_fpm));
+void default_lq_copy_link2tc_fpm(void *target, void *source) {
+  memcpy(target, source, sizeof(struct default_lq_fpm));
 }
 
-void lq_etx_fpm_olsr_clear_lq(void *target) {
-  memset(target, 0, sizeof(struct lq_etx_fpm));
+void default_lq_clear_fpm(void *target) {
+  memset(target, 0, sizeof(struct default_lq_fpm));
 }
 
-const char *lq_etx_fpm_olsr_print_lq(void *ptr, struct lqtextbuffer *buffer) {
-  struct lq_etx_fpm *lq = ptr;
+const char *default_lq_print_fpm(void *ptr, struct lqtextbuffer *buffer) {
+  struct default_lq_fpm *lq = ptr;
   
   sprintf(buffer->buf, "%s/%s", fpmtoa(lq->lq), fpmtoa(lq->nlq));
   return buffer->buf;
 }
 
-const char *lq_etx_fpm_olsr_print_cost(olsr_linkcost cost, struct lqtextbuffer *buffer) {
+const char *default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer) {
   sprintf(buffer->buf, "%s", fpmtoa(cost));
   return buffer->buf;
 }
index 1078e6f..f28ecde 100644 (file)
 #define LQ_PLUGIN_RELEVANT_COSTCHANGE 16
 
 #define LQ_ETX_FPM_HANDLER_NAME "ETX metric with FPM"
-struct lq_etx_fpm {
+struct default_lq_fpm {
        fpm lq, nlq;
+       olsr_u16_t quickstart;
 };
 
-int init_lq_etx_fpm(void);
+void default_lq_initialize_fpm(void);
 
-olsr_linkcost lq_etx_fpm_calc_cost(const void *lq);
+olsr_linkcost default_lq_calc_cost_fpm(const void *lq);
 
-olsr_bool lq_etx_fpm_olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
+olsr_bool default_lq_is_relevant_costchange_fpm(olsr_linkcost c1, olsr_linkcost c2);
 
-olsr_linkcost lq_etx_fpm_packet_loss_worker(struct link_entry *link, void *lq, olsr_bool lost);
-void lq_etx_fpm_olsr_memorize_foreign_hello_lq(void *local, void *foreign);
+olsr_linkcost default_lq_packet_loss_worker_fpm(struct link_entry *link, void *lq, olsr_bool lost);
+void default_lq_memorize_foreign_hello_fpm(void *local, void *foreign);
 
-int lq_etx_fpm_olsr_serialize_hello_lq_pair(unsigned char *buff, void *lq);
-void lq_etx_fpm_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *lq);
-int lq_etx_fpm_olsr_serialize_tc_lq_pair(unsigned char *buff, void *lq);
-void lq_etx_fpm_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *lq);
+int default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *lq);
+void default_lq_deserialize_hello_lq_pair_fpm(const olsr_u8_t **curr, void *lq);
+int default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *lq);
+void default_lq_deserialize_tc_lq_pair_fpm(const olsr_u8_t **curr, void *lq);
 
-void lq_etx_fpm_olsr_copy_link_lq_into_tc(void *target, void *source);
-void lq_etx_fpm_olsr_clear_lq(void *target);
+void default_lq_copy_link2tc_fpm(void *target, void *source);
+void default_lq_clear_fpm(void *target);
 
-const char *lq_etx_fpm_olsr_print_lq(void *ptr, struct lqtextbuffer *buffer);
-const char *lq_etx_fpm_olsr_print_cost(olsr_linkcost cost, struct lqtextbuffer *buffer);
+const char *default_lq_print_fpm(void *ptr, struct lqtextbuffer *buffer);
+const char *default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer);
+
+extern struct lq_handler lq_etx_fpm_handler;
 
 #endif /*LQ_ETX_FPM_*/
index acebf24..eecf161 100644 (file)
@@ -64,6 +64,11 @@ int olsrd_plugin_interface_version(void)
     return PLUGIN_INTERFACE_VERSION;
 }
 
+int olsrd_plugin_init(void) {
+  set_lq_handler(&lq_etx_fpm_handler, LQ_ETX_FPM_HANDLER_NAME);
+  return 1;
+}
+
 /**
  * Register parameters from config file
  * Called for all plugin parameters
@@ -71,14 +76,10 @@ int olsrd_plugin_interface_version(void)
 static const struct olsrd_plugin_parameters plugin_parameters[] = {
 };
 
-/**
- * Initialize plugin
- * Called after all parameters are passed
- */
-int
-olsrd_plugin_init(void)
+void olsrd_get_plugin_parameters(const struct olsrd_plugin_parameters **params, int *size)
 {
-  return init_lq_etx_fpm();
+    *params = plugin_parameters;
+    *size = sizeof(plugin_parameters)/sizeof(*plugin_parameters);
 }
 
 
index 2fc2e04..d56cf6f 100644 (file)
@@ -48,9 +48,6 @@
 
 
 /* Initialization function */
-int
-olsrd_plugin_init(void);
-
 int 
 olsrd_plugin_interface_version(void);
 
index 72fb64a..252ee9b 100644 (file)
--- a/src/fpm.c
+++ b/src/fpm.c
@@ -43,6 +43,7 @@
 #include "fpm.h"
 
 #ifdef USE_FPM
+#undef NDEBUG
 
 #ifndef NDEBUG
 
index 37b8557..5bf8fb6 100644 (file)
 #include "lq_plugin_default.h"
 #include "lq_plugin.h"
 
-/* Default lq plugin settings */
-struct lq_handler default_lq_handler = {
-  &default_calc_cost,
-  &default_calc_cost,
-
-  &default_olsr_is_relevant_costchange,
-
-  &default_packet_loss_worker,
-  &default_olsr_memorize_foreign_hello_lq,
-  &default_olsr_copy_link_lq_into_tc,
-  &default_olsr_clear_lq,
-  &default_olsr_clear_lq,
-
-  &default_olsr_serialize_hello_lq_pair,
-  &default_olsr_serialize_tc_lq_pair,
-  &default_olsr_deserialize_hello_lq_pair,
-  &default_olsr_deserialize_tc_lq_pair,
-
-  &default_olsr_print_lq,
-  &default_olsr_print_lq,
-  &default_olsr_print_cost,
-
-  sizeof(struct default_lq),
-  sizeof(struct default_lq)
-};
-
-struct lq_handler *active_lq_handler = &default_lq_handler;
+struct lq_handler *active_lq_handler = NULL;
 
 /*
  * set_lq_handler
@@ -84,21 +58,18 @@ struct lq_handler *active_lq_handler = &default_lq_handler;
  * this function is used by routing metric plugins to activate their link
  * quality handler
  * 
+ * The name parameter is marked as "unused" to squelch a compiler warning if debug
+ * output is not active
+ * 
  * @param pointer to lq_handler structure
  * @param name of the link quality handler for debug output
  */
 void
-set_lq_handler(struct lq_handler *handler, const char *name)
+set_lq_handler(struct lq_handler *handler, const __attribute__ ((unused)) char *name)
 {
-  if (handler) {
-    OLSR_PRINTF(1, "Activated lq_handler: %s\n", name);
-    active_lq_handler = handler;
-  } else {
-    OLSR_PRINTF(1, "Activated lq_handler: default\n");
-    active_lq_handler = &default_lq_handler;
-  }
-
-  name = NULL;                 /* squelch compiler warning */
+  OLSR_PRINTF(1, "Activated lq_handler: %s\n", name);
+  active_lq_handler = handler;
+  handler->initialize();
 }
 
 /*
index 1455298..ec506bd 100644 (file)
 #define ROUTE_COST_BROKEN (0xffffffff)
 #define ZERO_ROUTE_COST 0
 
+#define MINIMAL_USEFUL_LQ 0.1
+
+#define LQ_QUICKSTART_STEPS 12
+#define LQ_QUICKSTART_AGING 0.25
+
 struct lqtextbuffer {
   char buf[16];
 };
 
 struct lq_handler {
+  void (*initialize)(void);
+  
   olsr_linkcost(*calc_hello_cost) (const void *lq);
   olsr_linkcost(*calc_tc_cost) (const void *lq);
 
index e44c64b..c9f0f5c 100644 (file)
 #include "olsr.h"
 #include "lq_plugin_default.h"
 
-olsr_linkcost default_calc_cost(const void *ptr) {
-  const struct default_lq *lq = ptr;
+/* Default lq plugin settings */
+struct lq_handler default_lq_float_handler = {
+  &default_lq_initialize_float,
+  
+  &default_lq_calc_cost_float,
+  &default_lq_calc_cost_float,
+
+  &default_lq_is_relevant_costchange_float,
+
+  &default_lq_packet_loss_worker_float,
+  &default_lq_memorize_foreign_hello_float,
+  &default_lq_copy_link2tc_float,
+  &default_lq_clear_float,
+  &default_lq_clear_float,
+
+  &default_lq_serialize_hello_lq_pair_float,
+  &default_lq_serialize_tc_lq_pair_float,
+  &default_lq_deserialize_hello_lq_pair_float,
+  &default_lq_deserialize_tc_lq_pair_float,
+
+  &default_lq_print_float,
+  &default_lq_print_float,
+  &default_lq_print_cost_float,
+
+  sizeof(struct default_lq_float),
+  sizeof(struct default_lq_float)
+};
+
+void default_lq_initialize_float(void) {
+  return;
+}
+
+olsr_linkcost default_lq_calc_cost_float(const void *ptr) {
+  const struct default_lq_float *lq = ptr;
   olsr_linkcost cost;
   
-  if (lq->lq < 0.1 || lq->nlq < 0.1) {
+  if (lq->lq < MINIMAL_USEFUL_LQ || lq->nlq < MINIMAL_USEFUL_LQ) {
     return LINK_COST_BROKEN;
   }
   
@@ -64,8 +96,8 @@ olsr_linkcost default_calc_cost(const void *ptr) {
   return cost;
 }
 
-int default_olsr_serialize_hello_lq_pair(unsigned char *buff, void *ptr) {
-  struct default_lq *lq = ptr;
+int default_lq_serialize_hello_lq_pair_float(unsigned char *buff, void *ptr) {
+  struct default_lq_float *lq = ptr;
   
   olsr_u16_t lq_value = (olsr_u16_t)(lq->lq * 65535);
   olsr_u16_t nlq_value = (olsr_u16_t)(lq->nlq * 65535);
@@ -78,8 +110,8 @@ int default_olsr_serialize_hello_lq_pair(unsigned char *buff, void *ptr) {
   return 4;
 }
 
-void default_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *ptr) {
-  struct default_lq *lq = ptr;
+void default_lq_deserialize_hello_lq_pair_float(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_float *lq = ptr;
   
   olsr_u8_t lq_high, lq_low, nlq_high, nlq_low;
   olsr_u16_t lq_value, nlq_value;
@@ -96,15 +128,15 @@ void default_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *ptr) {
   lq->nlq = (float)nlq_value / 65535.0;
 }
 
-olsr_bool default_olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2) {
+olsr_bool default_lq_is_relevant_costchange_float(olsr_linkcost c1, olsr_linkcost c2) {
   if (c1 > c2) {
     return c2 - c1 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
   }
   return c1 - c2 > LQ_PLUGIN_RELEVANT_COSTCHANGE;
 }
 
-int default_olsr_serialize_tc_lq_pair(unsigned char *buff, void *ptr) {
-  struct default_lq *lq = ptr;
+int default_lq_serialize_tc_lq_pair_float(unsigned char *buff, void *ptr) {
+  struct default_lq_float *lq = ptr;
   
   olsr_u16_t lq_value = (olsr_u16_t)(lq->lq * 65535);
   olsr_u16_t nlq_value = (olsr_u16_t)(lq->nlq * 65535);
@@ -117,8 +149,8 @@ int default_olsr_serialize_tc_lq_pair(unsigned char *buff, void *ptr) {
   return 4;
 }
 
-void default_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *ptr) {
-  struct default_lq *lq = ptr;
+void default_lq_deserialize_tc_lq_pair_float(const olsr_u8_t **curr, void *ptr) {
+  struct default_lq_float *lq = ptr;
   
   olsr_u8_t lq_high, lq_low, nlq_high, nlq_low;
   olsr_u16_t lq_value, nlq_value;
@@ -135,20 +167,25 @@ void default_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *ptr) {
   lq->nlq = (float)nlq_value / 65535.0;
 }
 
-olsr_linkcost default_packet_loss_worker(struct link_entry *link, void *ptr, olsr_bool lost) {
-  struct default_lq *tlq = ptr;
+olsr_linkcost default_lq_packet_loss_worker_float(struct link_entry *link, void *ptr, olsr_bool lost) {
+  struct default_lq_float *tlq = ptr;
+  float alpha = olsr_cnf->lq_aging;
   
+  if (tlq->quickstart < LQ_QUICKSTART_STEPS) {
+    alpha = LQ_QUICKSTART_AGING; /* fast enough to get the LQ value within 6 Hellos up to 0.9 */
+    tlq->quickstart++;
+  }
   // exponential moving average
-  tlq->lq *= (1 - olsr_cnf->lq_aging);
+  tlq->lq *= (1 - alpha);
   if (lost == 0) {
-    tlq->lq += (olsr_cnf->lq_aging * link->loss_link_multiplier / 65536);
+    tlq->lq += (alpha * link->loss_link_multiplier / 65536);
   }
-  return default_calc_cost(ptr);
+  return default_lq_calc_cost_float(ptr);
 }
 
-void default_olsr_memorize_foreign_hello_lq(void *ptrLocal, void *ptrForeign) {
-  struct default_lq *local = ptrLocal;
-  struct default_lq *foreign = ptrForeign;
+void default_lq_memorize_foreign_hello_float(void *ptrLocal, void *ptrForeign) {
+  struct default_lq_float *local = ptrLocal;
+  struct default_lq_float *foreign = ptrForeign;
   
   if (foreign) {
     local->nlq = foreign->lq;
@@ -158,22 +195,22 @@ void default_olsr_memorize_foreign_hello_lq(void *ptrLocal, void *ptrForeign) {
   }
 }
 
-void default_olsr_copy_link_lq_into_tc(void *target, void *source) {
-  memcpy(target, source, sizeof(struct default_lq));
+void default_lq_copy_link2tc_float(void *target, void *source) {
+  memcpy(target, source, sizeof(struct default_lq_float));
 }
 
-void default_olsr_clear_lq(void *target) {
-  memset(target, 0, sizeof(struct default_lq));
+void default_lq_clear_float(void *target) {
+  memset(target, 0, sizeof(struct default_lq_float));
 }
 
-const char *default_olsr_print_lq(void *ptr, struct lqtextbuffer *buffer) {
-  struct default_lq *lq = ptr;
+const char *default_lq_print_float(void *ptr, struct lqtextbuffer *buffer) {
+  struct default_lq_float *lq = ptr;
   
   sprintf(buffer->buf, "%2.3f/%2.3f", lq->lq, lq->nlq);
   return buffer->buf;
 }
 
-const char *default_olsr_print_cost(olsr_linkcost cost, struct lqtextbuffer *buffer) {
+const char *default_lq_print_cost_float(olsr_linkcost cost, struct lqtextbuffer *buffer) {
   sprintf(buffer->buf, "%2.3f", ((float)cost)/LQ_PLUGIN_LC_MULTIPLIER);
   return buffer->buf;
 }
index 29f409d..4a4bb45 100644 (file)
 #include "olsr_types.h"
 #include "lq_plugin.h"
 
+#define DEFAULT_LQ_HANDLER_NAME "ETX plugin (float)"
+
 #define LQ_PLUGIN_LC_MULTIPLIER 1024
 #define LQ_PLUGIN_RELEVANT_COSTCHANGE 8
 
-struct default_lq {
-       float lq, nlq;
+struct default_lq_float {
+  float lq, nlq;
+  olsr_u16_t quickstart;
 };
 
-olsr_linkcost default_calc_cost(const void *lq);
+void default_lq_initialize_float(void);
+
+olsr_linkcost default_lq_calc_cost_float(const void *lq);
+
+olsr_bool default_lq_is_relevant_costchange_float(olsr_linkcost c1, olsr_linkcost c2);
 
-olsr_bool default_olsr_is_relevant_costchange(olsr_linkcost c1, olsr_linkcost c2);
+olsr_linkcost default_lq_packet_loss_worker_float(struct link_entry *link, void *lq, olsr_bool lost);
+void default_lq_memorize_foreign_hello_float(void *local, void *foreign);
 
-olsr_linkcost default_packet_loss_worker(struct link_entry *link, void *lq, olsr_bool lost);
-void default_olsr_memorize_foreign_hello_lq(void *local, void *foreign);
+int default_lq_serialize_hello_lq_pair_float(unsigned char *buff, void *lq);
+void default_lq_deserialize_hello_lq_pair_float(const olsr_u8_t **curr, void *lq);
+int default_lq_serialize_tc_lq_pair_float(unsigned char *buff, void *lq);
+void default_lq_deserialize_tc_lq_pair_float(const olsr_u8_t **curr, void *lq);
 
-int default_olsr_serialize_hello_lq_pair(unsigned char *buff, void *lq);
-void default_olsr_deserialize_hello_lq_pair(const olsr_u8_t **curr, void *lq);
-int default_olsr_serialize_tc_lq_pair(unsigned char *buff, void *lq);
-void default_olsr_deserialize_tc_lq_pair(const olsr_u8_t **curr, void *lq);
+void default_lq_copy_link2tc_float(void *target, void *source);
+void default_lq_clear_float(void *target);
 
-void default_olsr_copy_link_lq_into_tc(void *target, void *source);
-void default_olsr_clear_lq(void *target);
+const char *default_lq_print_float(void *ptr, struct lqtextbuffer *buffer);
+const char *default_lq_print_cost_float(olsr_linkcost cost, struct lqtextbuffer *buffer);
 
-const char *default_olsr_print_lq(void *ptr, struct lqtextbuffer *buffer);
-const char *default_olsr_print_cost(olsr_linkcost cost, struct lqtextbuffer *buffer);
+extern struct lq_handler default_lq_float_handler;
 
 #endif /*LQ_PLUGIN_DEFAULT_H_*/
index 9472017..28894ac 100644 (file)
@@ -61,6 +61,7 @@
 #include "lq_packet.h"
 #include "common/avl.h"
 #include "net_olsr.h"
+#include "lq_plugin_default.h"
 
 #include <stdarg.h>
 #include <signal.h>
@@ -244,6 +245,9 @@ olsr_init_tables(void)
     avl_comp_prefix_default = avl_comp_ipv6_prefix;
   }
 
+  /* Initialize default LQ plugin */
+  set_lq_handler(&default_lq_float_handler, DEFAULT_LQ_HANDLER_NAME);
+  
   /* Initialize link set */
   olsr_init_link_set();