src/olsr_time.c

   1
   2 /*
   3  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   4  * Copyright (c) 2004-2009, the olsr.org team - see HISTORY file
   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 <assert.h>
  43 #include <limits.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46
  47 #include "olsr_time.h"
  48
  49 /**
  50  *Function that converts a double to a mantissa/exponent
  51  *product as described in RFC3626:
  52  *
  53  * value = C*(1+a/16)*2^b [in seconds]
  54  *
  55  *  where a is the integer represented by the four highest bits of the
  56  *  field and b the integer represented by the four lowest bits of the
  57  *  field.
  58  *
  59  *@param interval the time interval to process
  60  *
  61  *@return a 8-bit mantissa/exponent product
  62  */
  63 uint8_t
  64 reltime_to_me(const olsr_reltime interval)
  65 {
  66   uint8_t a = 0, b = 0;                /* Underflow defaults */
  67
  68   /* It is sufficent to compare the integer part since we test on >=.
  69    * So we have now only a floating point division and the rest of the loop
  70    * are only integer operations.
  71    *
  72    * const unsigned int unscaled_interval = interval / VTIME_SCALE_FACTOR;
  73    *
  74    * VTIME_SCALE_FACTOR = 1/16
  75    *
  76    * => unscaled_interval = interval(ms) / 1000 * 16
  77    *                      = interval(ms) / 125 * 2
  78    */
  79
  80   unsigned unscaled_interval = interval;
  81   while (unscaled_interval >= 62) {
  82     unscaled_interval >>= 1;
  83     b++;
  84   }
  85
  86   if (0 < b) {
  87     if (15 < --b) {
  88       a = 15;                   /* Overflow defaults */
  89       b = 15;
  90     } else {
  91       a = (interval >> (b + 2)) - 15;
  92     }
  93   }
  94
  95   return (a << 4) + b;
  96 }
  97
  98 /**
  99  * Function for converting a mantissa/exponent 8bit value back
 100  * to double as described in RFC3626:
 101  *
 102  * value = C*(1+a/16)*2^b [in seconds]
 103  *
 104  *  where a is the integer represented by the four highest bits of the
 105  *  field and b the integer represented by the four lowest bits of the
 106  *  field.
 107  *
 108  * me is the 8 bit mantissa/exponent value
 109  *
 110  * To avoid expensive floating maths, we transform the equation:
 111  *     value = C * (1 + a / 16) * 2^b
 112  * first, we make an int addition from the floating point addition:
 113  *     value = C * ((16 + a) / 16) * 2^b
 114  * then we get rid of a pair of parentheses
 115  *     value = C * (16 + a) / 16 * 2^b
 116  * and now we make an int multiplication from the floating point one
 117  *     value = C * (16 + a) * 2^b / 16
 118  * so that we can make a shift from the multiplication
 119  *     value = C * ((16 + a) << b) / 16
 120  * and sionce C and 16 are constants
 121  *     value = ((16 + a) << b) * C / 16
 122  *
 123  * VTIME_SCALE_FACTOR = 1/16
 124  *
 125  * =>  value(ms) = ((16 + a) << b) / 256 * 1000
 126  *
 127  * 1. case: b >= 8
 128  *           = ((16 + a) << (b-8)) * 1000
 129  *
 130  * 2. case: b <= 8
 131  *           = ((16 + a) * 1000) >> (8-b)
 132  */
 133 olsr_reltime
 134 me_to_reltime(const uint8_t me)
 135 {
 136   const uint8_t a = me >> 4;
 137   const uint8_t b = me & 0x0F;
 138
 139   if (b >= 8) {
 140     return ((16 + a) << (b - 8)) * 1000;
 141   }
 142   assert(me == reltime_to_me(((16 + a) * 1000) >> (8 - b)));
 143   return ((16 + a) * 1000) >> (8 - b);
 144 }
 145
 146 char *
 147 reltime_to_txt(struct time_txt *buffer, olsr_reltime t) {
 148   sprintf(buffer->buf, "%u.%03u", t/1000, t%1000);
 149   return buffer->buf;
 150 }
 151
 152 uint32_t
 153 txt_to_reltime(char *txt) {
 154   uint32_t t1 = 0,t2 = 0;
 155   char *fraction;
 156
 157   fraction = strchr(txt, '.');
 158   if (fraction != NULL) {
 159     *fraction++ = 0;
 160
 161     if (strlen(fraction) > 3) {
 162       fraction[3] = 0;
 163     }
 164
 165     t2 = strtoul(fraction, NULL, 10);
 166   }
 167   t1 = strtoul(txt, NULL, 10);
 168   if (t1 > UINT32_MAX / MSEC_PER_SEC) {
 169     t1 = UINT32_MAX / MSEC_PER_SEC;
 170   }
 171   return t1*MSEC_PER_SEC + t2;
 172 }
 173
 174 /*
 175  * Local Variables:
 176  * c-basic-offset: 2
 177  * indent-tabs-mode: nil
 178  * End:
 179  */