src/lq_plugin_default_fpm.c

   1
   2 /*
   3  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   4  * Copyright (c) 2008 Henning Rogge <rogge@fgan.de>
   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 olsr.org, olsrd 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
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * Visit http://www.olsr.org for more information.
  35  *
  36  * If you find this software useful feel free to make a donation
  37  * to the project. For more information see the website or contact
  38  * the copyright holders.
  39  *
  40  */
  41
  42 #include "tc_set.h"
  43 #include "link_set.h"
  44 #include "lq_plugin.h"
  45 #include "olsr_spf.h"
  46 #include "lq_packet.h"
  47 #include "packet.h"
  48 #include "olsr.h"
  49 #include "lq_plugin_default_fpm.h"
  50
  51 static void default_lq_initialize_fpm(void);
  52 static olsr_linkcost default_lq_calc_cost_fpm(const void *lq);
  53 static void default_lq_packet_loss_worker_fpm(struct link_entry *link, void *lq, bool lost);
  54 static void default_lq_memorize_foreign_hello_fpm(void *local, void *foreign);
  55 static int default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *lq);
  56 static void default_lq_deserialize_hello_lq_pair_fpm(const uint8_t ** curr, void *lq);
  57 static int default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *lq);
  58 static void default_lq_deserialize_tc_lq_pair_fpm(const uint8_t ** curr, void *lq);
  59 static void default_lq_copy_link2tc_fpm(void *target, void *source);
  60 static void default_lq_clear_fpm(void *target);
  61 static const char *default_lq_print_fpm(void *ptr, char separator, struct lqtextbuffer *buffer);
  62 static const char *default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer);
  63
  64
  65 /* etx lq plugin (fpm version) settings */
  66 struct lq_handler lq_etx_fpm_handler = {
  67   &default_lq_initialize_fpm,
  68
  69   &default_lq_calc_cost_fpm,
  70   &default_lq_calc_cost_fpm,
  71
  72   &default_lq_packet_loss_worker_fpm,
  73   &default_lq_memorize_foreign_hello_fpm,
  74   &default_lq_copy_link2tc_fpm,
  75   &default_lq_copy_link2tc_fpm,
  76   &default_lq_clear_fpm,
  77   &default_lq_clear_fpm,
  78
  79   &default_lq_serialize_hello_lq_pair_fpm,
  80   &default_lq_serialize_tc_lq_pair_fpm,
  81   &default_lq_deserialize_hello_lq_pair_fpm,
  82   &default_lq_deserialize_tc_lq_pair_fpm,
  83
  84   &default_lq_print_fpm,
  85   &default_lq_print_fpm,
  86   &default_lq_print_cost_fpm,
  87
  88   sizeof(struct default_lq_fpm),
  89   sizeof(struct default_lq_fpm),
  90   4,
  91   4
  92 };
  93
  94 uint32_t aging_factor_new, aging_factor_old;
  95 uint32_t aging_quickstart_new, aging_quickstart_old;
  96
  97 static void
  98 default_lq_initialize_fpm(void)
  99 {
 100   aging_factor_new = (uint32_t) (olsr_cnf->lq_aging * LQ_FPM_INTERNAL_MULTIPLIER);
 101   aging_factor_old = LQ_FPM_INTERNAL_MULTIPLIER - aging_factor_new;
 102
 103   aging_quickstart_new = (uint32_t) (LQ_QUICKSTART_AGING * LQ_FPM_INTERNAL_MULTIPLIER);
 104   aging_quickstart_old = LQ_FPM_INTERNAL_MULTIPLIER - aging_quickstart_new;
 105 }
 106
 107 static olsr_linkcost
 108 default_lq_calc_cost_fpm(const void *ptr)
 109 {
 110   const struct default_lq_fpm *lq = ptr;
 111   olsr_linkcost cost;
 112
 113   if (lq->valueLq < (unsigned int)(255 * MINIMAL_USEFUL_LQ) || lq->valueNlq < (unsigned int)(255 * MINIMAL_USEFUL_LQ)) {
 114     return LINK_COST_BROKEN;
 115   }
 116
 117   cost = LQ_FPM_LINKCOST_MULTIPLIER * 255 / (int)lq->valueLq * 255 / (int)lq->valueNlq;
 118
 119   if (cost > LINK_COST_BROKEN)
 120     return LINK_COST_BROKEN;
 121   if (cost == 0)
 122     return 1;
 123   return cost;
 124 }
 125
 126 static int
 127 default_lq_serialize_hello_lq_pair_fpm(unsigned char *buff, void *ptr)
 128 {
 129   struct default_lq_fpm *lq = ptr;
 130
 131   buff[0] = (unsigned char)lq->valueLq;
 132   buff[1] = (unsigned char)lq->valueNlq;
 133   buff[2] = (unsigned char)(0);
 134   buff[3] = (unsigned char)(0);
 135
 136   return 4;
 137 }
 138
 139 static void
 140 default_lq_deserialize_hello_lq_pair_fpm(const uint8_t ** curr, void *ptr)
 141 {
 142   struct default_lq_fpm *lq = ptr;
 143
 144   pkt_get_u8(curr, &lq->valueLq);
 145   pkt_get_u8(curr, &lq->valueNlq);
 146   pkt_ignore_u16(curr);
 147 }
 148
 149 static int
 150 default_lq_serialize_tc_lq_pair_fpm(unsigned char *buff, void *ptr)
 151 {
 152   struct default_lq_fpm *lq = ptr;
 153
 154   buff[0] = (unsigned char)lq->valueLq;
 155   buff[1] = (unsigned char)lq->valueNlq;
 156   buff[2] = (unsigned char)(0);
 157   buff[3] = (unsigned char)(0);
 158
 159   return 4;
 160 }
 161
 162 static void
 163 default_lq_deserialize_tc_lq_pair_fpm(const uint8_t ** curr, void *ptr)
 164 {
 165   struct default_lq_fpm *lq = ptr;
 166
 167   pkt_get_u8(curr, &lq->valueLq);
 168   pkt_get_u8(curr, &lq->valueNlq);
 169   pkt_ignore_u16(curr);
 170 }
 171
 172 static void
 173 default_lq_packet_loss_worker_fpm(struct link_entry *link __attribute__ ((unused)), void *ptr, bool lost)
 174 {
 175   struct default_lq_fpm *tlq = ptr;
 176   uint32_t alpha_old = aging_factor_old;
 177   uint32_t alpha_new = aging_factor_new;
 178
 179   uint32_t value;
 180
 181   if (tlq->quickstart < LQ_QUICKSTART_STEPS) {
 182     alpha_new = aging_quickstart_new;
 183     alpha_old = aging_quickstart_old;
 184     tlq->quickstart++;
 185   }
 186   // exponential moving average
 187   value = (uint32_t) (tlq->valueLq) * LQ_FPM_INTERNAL_MULTIPLIER / 255;
 188
 189   value = (value * alpha_old + LQ_FPM_INTERNAL_MULTIPLIER - 1) / LQ_FPM_INTERNAL_MULTIPLIER;
 190
 191   if (!lost) {
 192     uint32_t ratio;
 193
 194     ratio = (alpha_new * link->loss_link_multiplier + LINK_LOSS_MULTIPLIER - 1) / LINK_LOSS_MULTIPLIER;
 195     value += ratio;
 196   }
 197   tlq->valueLq = (value * 255 + LQ_FPM_INTERNAL_MULTIPLIER - 1) / LQ_FPM_INTERNAL_MULTIPLIER;
 198
 199   link->linkcost = default_lq_calc_cost_fpm(ptr);
 200   olsr_relevant_linkcost_change();
 201 }
 202
 203 static void
 204 default_lq_memorize_foreign_hello_fpm(void *ptrLocal, void *ptrForeign)
 205 {
 206   struct default_lq_fpm *local = ptrLocal;
 207   struct default_lq_fpm *foreign = ptrForeign;
 208
 209   if (foreign) {
 210     local->valueNlq = foreign->valueLq;
 211   } else {
 212     local->valueNlq = 0;
 213   }
 214 }
 215
 216 static void
 217 default_lq_copy_link2tc_fpm(void *target, void *source)
 218 {
 219   memcpy(target, source, sizeof(struct default_lq_fpm));
 220 }
 221
 222 static void
 223 default_lq_clear_fpm(void *target)
 224 {
 225   memset(target, 0, sizeof(struct default_lq_fpm));
 226 }
 227
 228 static const char *
 229 default_lq_print_fpm(void *ptr, char separator, struct lqtextbuffer *buffer)
 230 {
 231   struct default_lq_fpm *lq = ptr;
 232
 233   snprintf(buffer->buf, sizeof(buffer->buf), "%0.3f%c%0.3f", (double)(lq->valueLq) / (double)255.0, separator,
 234                   (double)(lq->valueNlq) / (double)255.0);
 235   return buffer->buf;
 236 }
 237
 238 static const char *
 239 default_lq_print_cost_fpm(olsr_linkcost cost, struct lqtextbuffer *buffer)
 240 {
 241   snprintf(buffer->buf, sizeof(buffer->buf), "%.3f", (double)(cost) / (double)LQ_FPM_LINKCOST_MULTIPLIER);
 242   return buffer->buf;
 243 }
 244
 245 /*
 246  * Local Variables:
 247  * c-basic-offset: 2
 248  * indent-tabs-mode: nil
 249  * End:
 250  */