src/ats-tests/ats-testing-preferences.c

   1 /*
   2  This file is part of GNUnet.
   3  Copyright (C) 2010-2013 Christian Grothoff (and other contributing authors)
   4
   5  GNUnet is free software; you can redistribute it and/or modify
   6  it under the terms of the GNU General Public License as published
   7  by the Free Software Foundation; either version 3, or (at your
   8  option) any later version.
   9
  10  GNUnet is distributed in the hope that it will be useful, but
  11  WITHOUT ANY WARRANTY; without even the implied warranty of
  12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  General Public License for more details.
  14
  15  You should have received a copy of the GNU General Public License
  16  along with GNUnet; see the file COPYING.  If not, write to the
  17  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  Boston, MA 02111-1307, USA.
  19  */
  20 /**
  21  * @file ats-tests/ats-testing-preferences.c
  22  * @brief ats benchmark: preference generator
  23  * @author Christian Grothoff
  24  * @author Matthias Wachs
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "ats-testing.h"
  29
  30 static struct PreferenceGenerator *pg_head;
  31 static struct PreferenceGenerator *pg_tail;
  32
  33 extern struct GNUNET_ATS_TEST_Topology *top;
  34
  35 static double
  36 get_preference (struct PreferenceGenerator *pg)
  37 {
  38   struct GNUNET_TIME_Relative time_delta;
  39   double delta_value;
  40   double pref_value;
  41
  42   /* Calculate the current preference value */
  43   switch (pg->type) {
  44     case GNUNET_ATS_TEST_TG_CONSTANT:
  45       pref_value = pg->base_value;
  46       break;
  47     case GNUNET_ATS_TEST_TG_LINEAR:
  48       time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start);
  49       /* Calculate point of time in the current period */
  50       time_delta.rel_value_us = time_delta.rel_value_us %
  51           pg->duration_period.rel_value_us;
  52       delta_value = ((double) time_delta.rel_value_us  /
  53           pg->duration_period.rel_value_us) * (pg->max_value - pg->base_value);
  54       if ((pg->max_value < pg->base_value) &&
  55           ((pg->max_value - pg->base_value) > pg->base_value))
  56       {
  57         /* This will cause an underflow */
  58         GNUNET_break (0);
  59       }
  60       pref_value = pg->base_value + delta_value;
  61       break;
  62     case GNUNET_ATS_TEST_TG_RANDOM:
  63       delta_value =  (double) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
  64           10000 * (pg->max_value - pg->base_value)) / 10000;
  65       pref_value = pg->base_value + delta_value;
  66       break;
  67     case GNUNET_ATS_TEST_TG_SINUS:
  68       time_delta = GNUNET_TIME_absolute_get_duration(pg->time_start);
  69       /* Calculate point of time in the current period */
  70       time_delta.rel_value_us = time_delta.rel_value_us %
  71           pg->duration_period.rel_value_us;
  72       if ((pg->max_value - pg->base_value) > pg->base_value)
  73       {
  74         /* This will cause an underflow for second half of sinus period,
  75          * will be detected in general when experiments are loaded */
  76         GNUNET_break (0);
  77       }
  78       delta_value = (pg->max_value - pg->base_value) *
  79           sin ( (2 * M_PI) / ((double) pg->duration_period.rel_value_us) *
  80               time_delta.rel_value_us);
  81       pref_value = pg->base_value + delta_value;
  82       break;
  83     default:
  84       pref_value = 0.0;
  85       break;
  86   }
  87   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Current preference value is %f\n",
  88       pref_value);
  89   return pref_value;
  90 }
  91
  92
  93 static void
  94 set_pref_task (void *cls,
  95                     const struct GNUNET_SCHEDULER_TaskContext *tc)
  96 {
  97   struct BenchmarkPartner *p = cls;
  98   double pref_value;
  99   p->pg->set_task = NULL;
 100
 101   pref_value = get_preference (p->pg);
 102
 103   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 104       "Setting preference for master [%u] and slave [%u] for %s to %f\n",
 105       p->me->no, p->dest->no,
 106       GNUNET_ATS_print_preference_type (p->pg->kind), pref_value);
 107
 108   GNUNET_ATS_performance_change_preference(p->me->ats_perf_handle,
 109                                            &p->dest->id,
 110                                            p->pg->kind,
 111                                            pref_value,
 112                                            GNUNET_ATS_PREFERENCE_END);
 113
 114   switch (p->pg->kind) {
 115     case GNUNET_ATS_PREFERENCE_BANDWIDTH:
 116       p->pref_bandwidth = pref_value;
 117       break;
 118     case GNUNET_ATS_PREFERENCE_LATENCY:
 119       p->pref_delay = pref_value;
 120       break;
 121     default:
 122       break;
 123   }
 124
 125   p->pg->set_task = GNUNET_SCHEDULER_add_delayed (p->pg->frequency,
 126       set_pref_task, p);
 127
 128 }
 129
 130
 131 /**
 132  * Generate between the source master and the partner and set preferences with a
 133  * value depending on the generator.
 134  *
 135  * @param src source
 136  * @param dest partner
 137  * @param type type of preferences to generate
 138  * @param base_value traffic base rate to send data with
 139  * @param value_rate  traffic maximum rate to send data with
 140  * @param period duration of a period of preferences generation (~ 1/frequency)
 141  * @param frequency how long to generate preferences
 142  * @param kind ATS preference to generate
 143  * @return the preference generator
 144  */
 145 struct PreferenceGenerator *
 146 GNUNET_ATS_TEST_generate_preferences_start (struct BenchmarkPeer *src,
 147     struct BenchmarkPartner *dest,
 148     enum GeneratorType type,
 149     long int base_value,
 150     long int value_rate,
 151     struct GNUNET_TIME_Relative period,
 152     struct GNUNET_TIME_Relative frequency,
 153     enum GNUNET_ATS_PreferenceKind kind)
 154 {
 155   struct PreferenceGenerator *pg;
 156
 157   if (NULL != dest->pg)
 158   {
 159     GNUNET_break (0);
 160     return NULL;
 161   }
 162
 163   pg = GNUNET_new (struct PreferenceGenerator);
 164   GNUNET_CONTAINER_DLL_insert (pg_head, pg_tail, pg);
 165   pg->type = type;
 166   pg->src = src;
 167   pg->dest = dest;
 168   pg->kind = kind;
 169   pg->base_value = base_value;
 170   pg->max_value = value_rate;
 171   pg->duration_period = period;
 172   pg->frequency = frequency;
 173   pg->time_start = GNUNET_TIME_absolute_get();
 174
 175   switch (type) {
 176     case GNUNET_ATS_TEST_TG_CONSTANT:
 177       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 178           "Setting up constant preference generator master[%u] `%s' and slave [%u] `%s' max %u Bips\n",
 179           dest->me->no, GNUNET_i2s (&dest->me->id),
 180           dest->dest->no, GNUNET_i2s (&dest->dest->id),
 181           base_value);
 182       break;
 183     case GNUNET_ATS_TEST_TG_LINEAR:
 184       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 185           "Setting up linear preference generator master[%u] `%s' and slave [%u] `%s' min %u Bips max %u Bips\n",
 186           dest->me->no, GNUNET_i2s (&dest->me->id),
 187           dest->dest->no, GNUNET_i2s (&dest->dest->id),
 188           base_value, value_rate);
 189       break;
 190     case GNUNET_ATS_TEST_TG_SINUS:
 191       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 192           "Setting up sinus preference generator master[%u] `%s' and slave [%u] `%s' baserate %u Bips, amplitude %u Bps\n",
 193           dest->me->no, GNUNET_i2s (&dest->me->id),
 194           dest->dest->no, GNUNET_i2s (&dest->dest->id),
 195           base_value, value_rate);
 196       break;
 197     case GNUNET_ATS_TEST_TG_RANDOM:
 198       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 199           "Setting up random preference generator master[%u] `%s' and slave [%u] `%s' min %u Bips max %u Bps\n",
 200           dest->me->no, GNUNET_i2s (&dest->me->id),
 201           dest->dest->no, GNUNET_i2s (&dest->dest->id),
 202           base_value, value_rate);
 203       break;
 204     default:
 205       break;
 206   }
 207
 208   dest->pg = pg;
 209   pg->set_task = GNUNET_SCHEDULER_add_now (&set_pref_task, dest);
 210   return pg;
 211 }
 212
 213
 214 void
 215 GNUNET_ATS_TEST_generate_preferences_stop (struct PreferenceGenerator *pg)
 216 {
 217   GNUNET_CONTAINER_DLL_remove (pg_head, pg_tail, pg);
 218   pg->dest->pg = NULL;
 219
 220   if (NULL != pg->set_task)
 221   {
 222     GNUNET_SCHEDULER_cancel (pg->set_task);
 223     pg->set_task = NULL;
 224   }
 225
 226   GNUNET_free (pg);
 227 }
 228
 229
 230 /**
 231  * Stop all preferences generators
 232  */
 233 void
 234 GNUNET_ATS_TEST_generate_preferences_stop_all ()
 235 {
 236   struct PreferenceGenerator *cur;
 237   struct PreferenceGenerator *next;
 238   next = pg_head;
 239   for (cur = next; NULL != cur; cur = next)
 240   {
 241       next = cur->next;
 242       GNUNET_ATS_TEST_generate_preferences_stop(cur);
 243   }
 244 }
 245
 246 /* end of file ats-testing-preferences.c */