src/ats/plugin_ats2_simple.c

   1 /*
   2  This file is part of GNUnet.
   3  Copyright (C) 2011-2015, 2018 GNUnet e.V.
   4
   5  GNUnet is free software: you can redistribute it and/or modify it
   6  under the terms of the GNU Affero General Public License as published
   7  by the Free Software Foundation, either version 3 of the License,
   8  or (at your 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  Affero General Public License for more details.
  14
  15  You should have received a copy of the GNU Affero General Public License
  16  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20 /**
  21  * @file ats/plugin_ats2_simple.c
  22  * @brief ATS simple solver
  23  * @author Matthias Wachs
  24  * @author Christian Grothoff
  25  *
  26  * TODO:
  27  * - needs testing
  28  */
  29 #include "platform.h"
  30 #include "gnunet_ats_plugin_new.h"
  31 #include "gnunet_hello_lib.h"
  32 #include "gnunet_peerstore_service.h"
  33
  34 #define LOG(kind,...) GNUNET_log_from (kind, "ats-simple",__VA_ARGS__)
  35
  36
  37 /**
  38  * Base frequency at which we suggest addresses to transport.
  39  * Multiplied by the square of the number of active connections
  40  * (and randomized) to calculate the actual frequency at which
  41  * we will suggest addresses to the transport.  Furthermore, each
  42  * address is also bounded by an exponential back-off.
  43  */
  44 #define SUGGEST_FREQ GNUNET_TIME_UNIT_SECONDS
  45
  46 /**
  47  * What is the minimum bandwidth we always try to allocate for
  48  * any session that is up? (May still be scaled down lower if
  49  * the number of sessions is so high that the total bandwidth
  50  * is insufficient to allow for this value to be granted.)
  51  */
  52 #define MIN_BANDWIDTH_PER_SESSION 1024
  53
  54
  55 /**
  56  * A handle for the proportional solver
  57  */
  58 struct SimpleHandle;
  59
  60
  61 /**
  62  * Information about preferences and sessions we track
  63  * per peer.
  64  */
  65 struct Peer;
  66
  67
  68 /**
  69  * Entry in list of addresses we could try per peer.
  70  */
  71 struct Hello
  72 {
  73
  74   /**
  75    * Kept in a DLL.
  76    */
  77   struct Hello *next;
  78
  79   /**
  80    * Kept in a DLL.
  81    */
  82   struct Hello *prev;
  83
  84   /**
  85    * Peer this hello belongs to.
  86    */
  87   struct Peer *peer;
  88
  89   /**
  90    * The address we could try.
  91    */
  92   const char *address;
  93
  94   /**
  95    * Is a session with this address already up?
  96    * If not, set to NULL.
  97    */
  98   struct GNUNET_ATS_SessionHandle *sh;
  99
 100   /**
 101    * When does the HELLO expire?
 102    */
 103   struct GNUNET_TIME_Absolute expiration;
 104
 105   /**
 106    * When did we try it last?
 107    */
 108   struct GNUNET_TIME_Absolute last_attempt;
 109
 110   /**
 111    * Current exponential backoff value.
 112    */
 113   struct GNUNET_TIME_Relative backoff;
 114
 115   /**
 116    * Type of the network for this HELLO.
 117    */
 118   enum GNUNET_NetworkType nt;
 119
 120 };
 121
 122
 123 /**
 124  * Internal representation of a session by the plugin.
 125  * (If desired, plugin may just use NULL.)
 126  */
 127 struct GNUNET_ATS_SessionHandle
 128 {
 129
 130   /**
 131    * Kept in DLL per peer.
 132    */
 133   struct GNUNET_ATS_SessionHandle *next;
 134
 135   /**
 136    * Kept in DLL per peer.
 137    */
 138   struct GNUNET_ATS_SessionHandle *prev;
 139
 140   /**
 141    * The session in the main ATS service.
 142    */
 143   struct GNUNET_ATS_Session *session;
 144
 145   /**
 146    * Current performance data for this @e session
 147    */
 148   const struct GNUNET_ATS_SessionData *data;
 149
 150   /**
 151    * Hello matching this session, or NULL for none.
 152    */
 153   struct Hello *hello;
 154
 155   /**
 156    * Peer this session is for.
 157    */
 158   struct Peer *peer;
 159
 160   /**
 161    * Address used by this session (largely for debugging).
 162    */
 163   const char *address;
 164
 165   /**
 166    * When did we last update transport about the allocation?
 167    * Used to dampen the frequency of updates.
 168    */
 169   struct GNUNET_TIME_Absolute last_allocation;
 170
 171   /**
 172    * Last BW-in allocation given to the transport service.
 173    */
 174   struct GNUNET_BANDWIDTH_Value32NBO bw_in;
 175
 176   /**
 177    * Last BW-out allocation given to the transport service.
 178    */
 179   struct GNUNET_BANDWIDTH_Value32NBO bw_out;
 180
 181   /**
 182    * New BW-in allocation given to the transport service.
 183    */
 184   uint64_t target_in;
 185
 186   /**
 187    * New BW-out allocation given to the transport service.
 188    */
 189   uint64_t target_out;
 190
 191 };
 192
 193
 194 /**
 195  * Information about preferences and sessions we track
 196  * per peer.
 197  */
 198 struct Peer
 199 {
 200
 201   /**
 202    * Kept in DLL per peer.
 203    */
 204   struct GNUNET_ATS_SessionHandle *sh_head;
 205
 206   /**
 207    * Kept in DLL per peer.
 208    */
 209   struct GNUNET_ATS_SessionHandle *sh_tail;
 210
 211   /**
 212    * Kept in a DLL.
 213    */
 214   struct Hello *h_head;
 215
 216   /**
 217    * Kept in a DLL.
 218    */
 219   struct Hello *h_tail;
 220
 221   /**
 222    * The handle for the proportional solver
 223    */
 224   struct SimpleHandle *h;
 225
 226   /**
 227    * Watch context where we are currently looking for HELLOs for
 228    * this peer.
 229    */
 230   struct GNUNET_PEERSTORE_WatchContext *wc;
 231
 232   /**
 233    * Task used to try again to suggest an address for this peer.
 234    */
 235   struct GNUNET_SCHEDULER_Task *task;
 236
 237   /**
 238    * Which peer is this for?
 239    */
 240   struct GNUNET_PeerIdentity pid;
 241
 242   /**
 243    * When did we last suggest an address to connect to for this peer?
 244    */
 245   struct GNUNET_TIME_Absolute last_suggestion;
 246
 247   /**
 248    * Array where we sum up the bandwidth requests received indexed
 249    * by preference kind (see `enum GNUNET_MQ_PreferenceKind`)
 250    */
 251   uint64_t bw_by_pk[GNUNET_MQ_PREFERENCE_COUNT];
 252
 253 };
 254
 255
 256 /**
 257  * Representation of a network (to be expanded...)
 258  */
 259 struct Network
 260 {
 261
 262   /**
 263    * Total inbound quota
 264    */
 265   unsigned long long total_quota_in;
 266
 267   /**
 268    * Total outbound quota
 269    */
 270   unsigned long long total_quota_out;
 271
 272   /**
 273    * ATS network type
 274    */
 275   enum GNUNET_NetworkType type;
 276
 277 };
 278
 279
 280 /**
 281  * A handle for the proportional solver
 282  */
 283 struct SimpleHandle
 284 {
 285
 286   /**
 287    * Our execution environment.
 288    */
 289   struct GNUNET_ATS_PluginEnvironment *env;
 290
 291   /**
 292    * Information we track for each peer.
 293    */
 294   struct GNUNET_CONTAINER_MultiPeerMap *peers;
 295
 296   /**
 297    * Handle to the peerstore service.
 298    */
 299   struct GNUNET_PEERSTORE_Handle *ps;
 300
 301   /**
 302    * Array where we sum up the bandwidth requests received indexed
 303    * by preference kind (see `enum GNUNET_MQ_PreferenceKind`) (sums
 304    * over all peers).
 305    */
 306   uint64_t bw_by_pk[GNUNET_MQ_PREFERENCE_COUNT];
 307
 308   /**
 309    * Information we track per network type (quotas).
 310    */
 311   struct Network networks[GNUNET_NT_COUNT];
 312
 313 };
 314
 315
 316 /**
 317  * Lookup peer in the peers map.
 318  *
 319  * @param h handle to look up in
 320  * @param pid peer identity to look up by
 321  * @return NULL for not found
 322  */
 323 struct Peer *
 324 lookup_peer (struct SimpleHandle *h,
 325              const struct GNUNET_PeerIdentity *pid)
 326 {
 327   return GNUNET_CONTAINER_multipeermap_get (h->peers,
 328                                             pid);
 329 }
 330
 331
 332 /**
 333  * Check if there is _any_ interesting information left we
 334  * store about the peer in @a p.
 335  *
 336  * @param p peer to test if we can drop the data structure
 337  * @return #GNUNET_YES if no information is left in @a p
 338  */
 339 static int
 340 peer_test_dead (struct Peer *p)
 341 {
 342   for (enum GNUNET_MQ_PreferenceKind pk = 0;
 343        pk < GNUNET_MQ_PREFERENCE_COUNT;
 344        pk++)
 345     if (0 != p->bw_by_pk[pk])
 346       return GNUNET_NO;
 347   if (NULL != p->sh_head)
 348     return GNUNET_NO;
 349   return GNUNET_YES;
 350 }
 351
 352
 353 /**
 354  * Contact the transport service and suggest to it to
 355  * try connecting to the address of @a hello.  Updates
 356  * backoff and timestamp values in the @a hello.
 357  *
 358  * @param hello[in,out] address suggestion to make
 359  */
 360 static void
 361 suggest_hello (struct Hello *hello)
 362 {
 363   struct Peer *p = hello->peer;
 364   struct SimpleHandle *h = p->h;
 365
 366   p->last_suggestion
 367     = hello->last_attempt
 368     = GNUNET_TIME_absolute_get ();
 369   hello->backoff = GNUNET_TIME_randomized_backoff (hello->backoff,
 370                                                    GNUNET_TIME_absolute_get_remaining (hello->expiration));
 371   h->env->suggest_cb (h->env->cls,
 372                       &p->pid,
 373                       hello->address);
 374 }
 375
 376
 377 /**
 378  * Consider suggesting a HELLO (without a session) to transport.
 379  * We look at how many active sessions we have for the peer, and
 380  * if there are many, reduce the frequency of trying new addresses.
 381  * Also, for each address we consider when we last tried it, and
 382  * its exponential backoff if the attempt failed.  Note that it
 383  * is possible that this function is called when no suggestion
 384  * is to be made.
 385  *
 386  * In this case, we only calculate the time until we make the next
 387  * suggestion.
 388  *
 389  * @param cls a `struct Peer`
 390  */
 391 static void
 392 suggest_start_cb (void *cls)
 393 {
 394   struct Peer *p = cls;
 395   struct GNUNET_TIME_Relative delay = GNUNET_TIME_UNIT_ZERO;
 396   struct Hello *hello = NULL;
 397   struct GNUNET_TIME_Absolute hpt = GNUNET_TIME_UNIT_FOREVER_ABS;
 398   struct GNUNET_TIME_Relative xdelay;
 399   struct GNUNET_TIME_Absolute xnext;
 400   unsigned int num_sessions = 0;
 401   uint32_t sq;
 402
 403   /* count number of active sessions */
 404   for (struct GNUNET_ATS_SessionHandle *sh = p->sh_head;
 405        NULL != sh;
 406        sh = sh->next)
 407     num_sessions++;
 408   /* calculate square of number of sessions */
 409   num_sessions++; /* start with 1, even if we have zero sessions */
 410   if (num_sessions < UINT16_MAX)
 411     sq = num_sessions * (uint32_t) num_sessions;
 412   else
 413     sq = UINT32_MAX;
 414   xdelay = GNUNET_TIME_randomized_backoff (GNUNET_TIME_relative_multiply (SUGGEST_FREQ,
 415                                                                           sq),
 416                                            GNUNET_TIME_UNIT_FOREVER_REL);
 417   xnext = GNUNET_TIME_relative_to_absolute (xdelay);
 418
 419   p->task = NULL;
 420   while (0 == delay.rel_value_us)
 421   {
 422     struct Hello *next;
 423     struct GNUNET_TIME_Absolute xmax;
 424
 425     if (NULL != hello)
 426     {
 427       /* We went through the loop already once and found
 428          a HELLO that is due *now*, so make a suggestion! */
 429       GNUNET_break (NULL == hello->sh);
 430       suggest_hello (hello);
 431       hello = NULL;
 432       hpt = GNUNET_TIME_UNIT_FOREVER_ABS;
 433     }
 434     for (struct Hello *pos = p->h_head; NULL != pos; pos = next)
 435     {
 436       struct GNUNET_TIME_Absolute pt;
 437
 438       next = pos->next;
 439       if (NULL != pos->sh)
 440         continue;
 441       if (0 == GNUNET_TIME_absolute_get_remaining (pos->expiration).rel_value_us)
 442       {
 443         /* expired, remove! */
 444         GNUNET_CONTAINER_DLL_remove (p->h_head,
 445                                      p->h_tail,
 446                                      pos);
 447         GNUNET_free (pos);
 448         continue;
 449       }
 450       pt = GNUNET_TIME_absolute_add (pos->last_attempt,
 451                                      pos->backoff);
 452       if ( (NULL == hello) ||
 453            (pt.abs_value_us < hpt.abs_value_us) )
 454       {
 455         hello = pos;
 456         hpt = pt;
 457       }
 458     }
 459     if (NULL == hello)
 460       return; /* no HELLOs that could still be tried */
 461
 462     /* hpt is now the *earliest* possible time for any HELLO
 463        but we might not want to go for as early as possible for
 464        this peer. So the actual time is the max of the earliest
 465        HELLO and the 'xnext' */
 466     xmax = GNUNET_TIME_absolute_max (hpt,
 467                                      xnext);
 468     delay = GNUNET_TIME_absolute_get_remaining (xmax);
 469   }
 470   p->task = GNUNET_SCHEDULER_add_delayed (delay,
 471                                           &suggest_start_cb,
 472                                           p);
 473 }
 474
 475
 476 /**
 477  * Function called by PEERSTORE for each matching record.
 478  *
 479  * @param cls closure with a `struct Peer`
 480  * @param record peerstore record information
 481  * @param emsg error message, or NULL if no errors
 482  */
 483 static void
 484 watch_cb (void *cls,
 485           const struct GNUNET_PEERSTORE_Record *record,
 486           const char *emsg)
 487 {
 488   struct Peer *p = cls;
 489   char *addr;
 490   size_t alen;
 491   enum GNUNET_NetworkType nt;
 492   struct GNUNET_TIME_Absolute expiration;
 493   struct Hello *hello;
 494
 495   if (0 != memcmp (&p->pid,
 496                    &record->peer,
 497                    sizeof (struct GNUNET_PeerIdentity)))
 498   {
 499     GNUNET_break (0);
 500     return;
 501   }
 502   if (0 != strcmp (record->key,
 503                    GNUNET_HELLO_PEERSTORE_KEY))
 504   {
 505     GNUNET_break (0);
 506     return;
 507   }
 508   addr = GNUNET_HELLO_extract_address (record->value,
 509                                        record->value_size,
 510                                        &p->pid,
 511                                        &nt,
 512                                        &expiration);
 513   if (NULL == addr)
 514     return; /* invalid hello, bad signature, other problem */
 515   if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
 516   {
 517     /* expired, ignore */
 518     GNUNET_free (addr);
 519     return;
 520   }
 521   /* check if addr is already known */
 522   for (struct Hello *he = p->h_head;
 523        NULL != he;
 524        he = he->next)
 525   {
 526     if (0 != strcmp (he->address,
 527                      addr))
 528       continue;
 529     if (he->expiration.abs_value_us < expiration.abs_value_us)
 530     {
 531       he->expiration = expiration;
 532       he->nt = nt;
 533     }
 534     GNUNET_free (addr);
 535     return;
 536   }
 537   /* create new HELLO */
 538   alen = strlen (addr) + 1;
 539   hello = GNUNET_malloc (sizeof (struct Hello) + alen);
 540   hello->address = (const char *) &hello[1];
 541   hello->expiration = expiration;
 542   hello->nt = nt;
 543   hello->peer = p;
 544   memcpy (&hello[1],
 545           addr,
 546           alen);
 547   GNUNET_free (addr);
 548   GNUNET_CONTAINER_DLL_insert (p->h_head,
 549                                p->h_tail,
 550                                hello);
 551   /* check if sh for this HELLO already exists */
 552   for (struct GNUNET_ATS_SessionHandle *sh = p->sh_head;
 553        NULL != sh;
 554        sh = sh->next)
 555   {
 556     if ( (NULL == sh->address) ||
 557          (0 != strcmp (sh->address,
 558                        addr)) )
 559       continue;
 560     GNUNET_assert (NULL == sh->hello);
 561     sh->hello = hello;
 562     hello->sh = sh;
 563     break;
 564   }
 565   if (NULL == p->task)
 566     p->task = GNUNET_SCHEDULER_add_now (&suggest_start_cb,
 567                                         p);
 568 }
 569
 570
 571 /**
 572  * Find or add peer if necessary.
 573  *
 574  * @param h our plugin handle
 575  * @param pid the peer identity to add/look for
 576  * @return a peer handle
 577  */
 578 static struct Peer *
 579 peer_add (struct SimpleHandle *h,
 580           const struct GNUNET_PeerIdentity *pid)
 581 {
 582   struct Peer *p = lookup_peer (h,
 583                                 pid);
 584
 585   if (NULL != p)
 586     return p;
 587   p = GNUNET_new (struct Peer);
 588   p->h = h;
 589   p->pid = *pid;
 590   p->wc = GNUNET_PEERSTORE_watch (h->ps,
 591                                   "transport",
 592                                   &p->pid,
 593                                   GNUNET_HELLO_PEERSTORE_KEY,
 594                                   &watch_cb,
 595                                   p);
 596   GNUNET_assert (GNUNET_YES ==
 597                  GNUNET_CONTAINER_multipeermap_put (h->peers,
 598                                                     &p->pid,
 599                                                     p,
 600                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 601
 602   return p;
 603 }
 604
 605
 606 /**
 607  * Free the entry (and associated tasks) of peer @a p.
 608  * Note that @a p must be dead already (see #peer_test_dead()).
 609  *
 610  * @param p the peer to free
 611  */
 612 static void
 613 peer_free (struct Peer *p)
 614 {
 615   struct SimpleHandle *h = p->h;
 616   struct Hello *hello;
 617
 618   GNUNET_assert (NULL == p->sh_head);
 619   while (NULL != (hello = p->h_head))
 620   {
 621     GNUNET_CONTAINER_DLL_remove (p->h_head,
 622                                  p->h_tail,
 623                                  hello);
 624     GNUNET_assert (NULL == hello->sh);
 625     GNUNET_free (hello);
 626   }
 627   if (NULL != p->task)
 628   {
 629     GNUNET_SCHEDULER_cancel (p->task);
 630     p->task = NULL;
 631   }
 632   if (NULL != p->wc)
 633   {
 634     GNUNET_PEERSTORE_watch_cancel (p->wc);
 635     p->wc = NULL;
 636   }
 637   GNUNET_assert (GNUNET_YES ==
 638                  GNUNET_CONTAINER_multipeermap_remove (h->peers,
 639                                                        &p->pid,
 640                                                        p));
 641   GNUNET_free (p);
 642 }
 643
 644
 645 /**
 646  * Check if the new allocation for @a sh is significantly different
 647  * from the last one, and if so, tell transport.
 648  *
 649  * @param sh session handle to consider updating transport for
 650  */
 651 static void
 652 consider_notify_transport (struct GNUNET_ATS_SessionHandle *sh)
 653 {
 654   struct Peer *peer = sh->peer;
 655   struct SimpleHandle *h = peer->h;
 656   enum GNUNET_NetworkType nt = sh->data->prop.nt;
 657   struct GNUNET_TIME_Relative delay;
 658   uint64_t sig_in;
 659   uint64_t sig_out;
 660   int64_t delta_in;
 661   int64_t delta_out;
 662
 663   delay = GNUNET_TIME_absolute_get_duration (sh->last_allocation);
 664   /* A significant change is more than 10% of the quota,
 665      which is given in bytes/second */
 666   sig_in
 667     = h->networks[nt].total_quota_in * (delay.rel_value_us / 1000LL) / 1000LL / 10;
 668   sig_out
 669     = h->networks[nt].total_quota_out * (delay.rel_value_us / 1000LL) / 1000LL / 10;
 670   delta_in = ( (int64_t) ntohl (sh->bw_in.value__)) - ((int64_t) sh->target_in);
 671   delta_out = ( (int64_t) ntohl (sh->bw_in.value__)) - ((int64_t) sh->target_in);
 672   /* we want the absolute values */
 673   if (delta_in < 0)
 674     delta_in = - delta_in;
 675   if (INT64_MIN == delta_in)
 676     delta_in = INT64_MAX;  /* Handle corner case: INT_MIN == - INT_MIN */
 677   if (delta_out < 0)
 678     delta_out = - delta_out;
 679   if (INT64_MIN == delta_out)
 680     delta_out = INT64_MAX; /* Handle corner case: INT_MIN == - INT_MIN */
 681   if ( (sig_in > delta_in) &&
 682        (sig_out > delta_out) )
 683     return; /* insignificant change */
 684   /* change is significant, tell transport! */
 685   if (sh->target_in > UINT32_MAX)
 686     sh->target_in = UINT32_MAX;
 687   sh->bw_in.value__ = htonl ((uint32_t) sh->target_in);
 688   if (sh->target_out > UINT32_MAX)
 689     sh->target_out = UINT32_MAX;
 690   sh->bw_out.value__ = htonl ((uint32_t) sh->target_out);
 691   sh->last_allocation = GNUNET_TIME_absolute_get ();
 692   h->env->allocate_cb (h->env->cls,
 693                        sh->session,
 694                        &peer->pid,
 695                        sh->bw_in,
 696                        sh->bw_out);
 697 }
 698
 699
 700 /**
 701  * Closure for #update_counters and #update_allocation.
 702  */
 703 struct Counters
 704 {
 705   /**
 706    * Plugin's state.
 707    */
 708   struct SimpleHandle *h;
 709
 710   /**
 711    * Bandwidth that applications would prefer to allocate in this
 712    * network type.  We initially add all requested allocations to the
 713    * respective network type where the given preference is best
 714    * satisfied. Later we may rebalance.
 715    */
 716   uint64_t bw_out_by_nt[GNUNET_NT_COUNT];
 717
 718   /**
 719    * Current bandwidth utilization for this network type.  We simply
 720    * add the current goodput up (with some fairness considerations).
 721    */
 722   uint64_t bw_in_by_nt[GNUNET_NT_COUNT];
 723
 724   /**
 725    * By how much do we have to scale (up or down) our expectations
 726    * for outbound bandwidth?
 727    */
 728   double scale_out[GNUNET_NT_COUNT];
 729
 730   /**
 731    * By how much do we have to scale (up or down) our expectations
 732    * for inbound bandwidth?
 733    */
 734   double scale_in[GNUNET_NT_COUNT];
 735
 736 };
 737
 738
 739 /**
 740  * Function used to iterate over all peers and collect
 741  * counter data.
 742  *
 743  * @param cls a `struct Counters *`
 744  * @param pid identity of the peer we process, unused
 745  * @param value a `struct Peer *`
 746  * @return #GNUNET_YES (continue to iterate)
 747  */
 748 static int
 749 update_counters (void *cls,
 750                  const struct GNUNET_PeerIdentity *pid,
 751                  void *value)
 752 {
 753   struct Counters *c = cls;
 754   struct Peer *peer = value;
 755   struct GNUNET_ATS_SessionHandle *best[GNUNET_MQ_PREFERENCE_COUNT];
 756
 757   (void) pid;
 758   if (NULL == peer->sh_head)
 759     return GNUNET_YES; /* no available session, cannot allocate bandwidth */
 760   memset (best,
 761           0,
 762           sizeof (best));
 763   for (struct GNUNET_ATS_SessionHandle *sh = peer->sh_head;
 764        NULL != sh;
 765        sh = sh->next)
 766   {
 767     enum GNUNET_NetworkType nt = sh->data->prop.nt;
 768
 769     sh->target_out = MIN_BANDWIDTH_PER_SESSION;
 770     c->bw_out_by_nt[nt] += MIN_BANDWIDTH_PER_SESSION;
 771     c->bw_in_by_nt[nt] += GNUNET_MAX (MIN_BANDWIDTH_PER_SESSION,
 772                                       sh->data->prop.goodput_in);
 773     for (enum GNUNET_MQ_PreferenceKind pk = 0;
 774          pk < GNUNET_MQ_PREFERENCE_COUNT;
 775          pk++)
 776     {
 777       /* General rule: always prefer smaller distance if possible,
 778          otherwise decide by pk: */
 779       switch (pk) {
 780       case GNUNET_MQ_PREFERENCE_NONE:
 781         break;
 782       case GNUNET_MQ_PREFERENCE_BANDWIDTH:
 783         /* For bandwidth, we compare the sum of transmitted bytes and
 784            confirmed transmitted bytes, so confirmed data counts twice */
 785         if ( (NULL == best[pk]) ||
 786              (sh->data->prop.distance < best[pk]->data->prop.distance) ||
 787              (sh->data->prop.utilization_out + sh->data->prop.goodput_out >
 788               best[pk]->data->prop.utilization_out + best[pk]->data->prop.goodput_out) )
 789           best[pk] = sh;
 790         /* If both are equal (i.e. usually this happens if there is a zero), use
 791            latency as a yardstick */
 792         if ( (sh->data->prop.utilization_out + sh->data->prop.goodput_out ==
 793               best[pk]->data->prop.utilization_out + best[pk]->data->prop.goodput_out) &&
 794              (sh->data->prop.distance == best[pk]->data->prop.distance) &&
 795              (sh->data->prop.delay.rel_value_us <
 796               best[pk]->data->prop.delay.rel_value_us) )
 797           best[pk] = sh;
 798         break;
 799       case GNUNET_MQ_PREFERENCE_LATENCY:
 800         if ( (NULL == best[pk]) ||
 801              (sh->data->prop.distance < best[pk]->data->prop.distance) ||
 802              ( (sh->data->prop.distance == best[pk]->data->prop.distance) &&
 803                (sh->data->prop.delay.rel_value_us <
 804                 best[pk]->data->prop.delay.rel_value_us) ) )
 805           best[pk] = sh;
 806         break;
 807       case GNUNET_MQ_PREFERENCE_RELIABILITY:
 808         /* For reliability, we consider the ratio of goodput to utilization
 809            (but use multiplicative formultations to avoid division by zero) */
 810         if ( (NULL == best[pk]) ||
 811              (1ULL * sh->data->prop.goodput_out * best[pk]->data->prop.utilization_out >
 812               1ULL * sh->data->prop.utilization_out * best[pk]->data->prop.goodput_out) )
 813           best[pk] = sh;
 814         /* If both are equal (i.e. usually this happens if there is a zero), use
 815            latency as a yardstick */
 816         if ( (1ULL * sh->data->prop.goodput_out * best[pk]->data->prop.utilization_out ==
 817               1ULL * sh->data->prop.utilization_out * best[pk]->data->prop.goodput_out) &&
 818              (sh->data->prop.distance == best[pk]->data->prop.distance) &&
 819              (sh->data->prop.delay.rel_value_us <
 820               best[pk]->data->prop.delay.rel_value_us) )
 821           best[pk] = sh;
 822         break;
 823       }
 824     }
 825   }
 826   /* for first round, assign target bandwidth simply to sum of
 827      requested bandwidth */
 828   for (enum GNUNET_MQ_PreferenceKind pk = 0;
 829        pk < GNUNET_MQ_PREFERENCE_COUNT;
 830        pk++)
 831   {
 832     enum GNUNET_NetworkType nt = best[pk]->data->prop.nt;
 833
 834     best[pk]->target_out = GNUNET_MIN (peer->bw_by_pk[pk],
 835                                        MIN_BANDWIDTH_PER_SESSION);
 836     c->bw_out_by_nt[nt] += (uint64_t) (best[pk]->target_out - MIN_BANDWIDTH_PER_SESSION);
 837   }
 838   return GNUNET_YES;
 839 }
 840
 841
 842 /**
 843  * Function used to iterate over all peers and collect
 844  * counter data.
 845  *
 846  * @param cls a `struct Counters *`
 847  * @param pid identity of the peer we process, unused
 848  * @param value a `struct Peer *`
 849  * @return #GNUNET_YES (continue to iterate)
 850  */
 851 static int
 852 update_allocation (void *cls,
 853                    const struct GNUNET_PeerIdentity *pid,
 854                    void *value)
 855 {
 856   struct Counters *c = cls;
 857   struct Peer *peer = value;
 858
 859   (void) pid;
 860   for (struct GNUNET_ATS_SessionHandle *sh = peer->sh_head;
 861        NULL != sh;
 862        sh = sh->next)
 863   {
 864     enum GNUNET_NetworkType nt = sh->data->prop.nt;
 865
 866     sh->target_out = (uint64_t) (c->scale_out[nt] * sh->target_out);
 867     sh->target_in = (uint64_t) (c->scale_in[nt] * sh->target_in);
 868     consider_notify_transport (sh);
 869   }
 870   return GNUNET_YES;
 871 }
 872
 873
 874 /**
 875  * The world changed, recalculate our allocations.
 876  */
 877 static void
 878 update (struct SimpleHandle *h)
 879 {
 880   struct Counters cnt = {
 881     .h = h
 882   };
 883
 884   GNUNET_CONTAINER_multipeermap_iterate (h->peers,
 885                                          &update_counters,
 886                                          &cnt);
 887   /* calculate how badly the missmatch between requested
 888      allocations and available bandwidth is per network type */
 889   for (enum GNUNET_NetworkType nt = 0;
 890        nt < GNUNET_NT_COUNT;
 891        nt++)
 892   {
 893     cnt.scale_out[nt] = 1.0 * cnt.bw_out_by_nt[nt] / h->networks[nt].total_quota_out;
 894     cnt.scale_in[nt] = 1.0 * cnt.bw_in_by_nt[nt] / h->networks[nt].total_quota_in;
 895   }
 896   /* recalculate allocations, considering scaling factor, and
 897      update transport if the change is significant */
 898   GNUNET_CONTAINER_multipeermap_iterate (h->peers,
 899                                          &update_allocation,
 900                                          &cnt);
 901 }
 902
 903
 904 /**
 905  * The plugin should begin to respect a new preference.
 906  *
 907  * @param cls the closure
 908  * @param pref the preference to add
 909  * @return plugin's internal representation, or NULL
 910  */
 911 static struct GNUNET_ATS_PreferenceHandle *
 912 simple_preference_add (void *cls,
 913                        const struct GNUNET_ATS_Preference *pref)
 914 {
 915   struct SimpleHandle *h = cls;
 916   struct Peer *p = peer_add (h,
 917                              &pref->peer);
 918
 919   GNUNET_assert (pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
 920   p->bw_by_pk[pref->pk] += ntohl (pref->bw.value__);
 921   h->bw_by_pk[pref->pk] += ntohl (pref->bw.value__);
 922   update (h);
 923   return NULL;
 924 }
 925
 926
 927 /**
 928  * The plugin should end respecting a preference.
 929  *
 930  * @param cls the closure
 931  * @param ph whatever @e preference_add returned
 932  * @param pref the preference to delete
 933  * @return plugin's internal representation, or NULL
 934  */
 935 static void
 936 simple_preference_del (void *cls,
 937                        struct GNUNET_ATS_PreferenceHandle *ph,
 938                        const struct GNUNET_ATS_Preference *pref)
 939 {
 940   struct SimpleHandle *h = cls;
 941   struct Peer *p = lookup_peer (h,
 942                                 &pref->peer);
 943
 944   GNUNET_assert (NULL != p);
 945   GNUNET_assert (pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
 946   p->bw_by_pk[pref->pk] -= ntohl (pref->bw.value__);
 947   h->bw_by_pk[pref->pk] -= ntohl (pref->bw.value__);
 948   if ( (0 == p->bw_by_pk[pref->pk]) &&
 949        (GNUNET_YES == peer_test_dead (p)) )
 950     peer_free (p);
 951   update (h);
 952 }
 953
 954
 955 /**
 956  * Transport established a new session with performance
 957  * characteristics given in @a data.
 958  *
 959  * @param cls closure
 960  * @param data performance characteristics of @a sh
 961  * @param address address information (for debugging)
 962  * @return handle by which the plugin will identify this session
 963  */
 964 static struct GNUNET_ATS_SessionHandle *
 965 simple_session_add (void *cls,
 966                     const struct GNUNET_ATS_SessionData *data,
 967                     const char *address)
 968 {
 969   struct SimpleHandle *h = cls;
 970   struct Peer *p = peer_add (h,
 971                              &data->peer);
 972   struct Hello *hello;
 973   size_t alen;
 974   struct GNUNET_ATS_SessionHandle *sh;
 975
 976   /* setup session handle */
 977   if (NULL == address)
 978     alen = 0;
 979   else
 980     alen = strlen (address) + 1;
 981   sh = GNUNET_malloc (sizeof (struct GNUNET_ATS_SessionHandle) + alen);
 982   sh->peer = p;
 983   sh->session = data->session;
 984   sh->data = data;
 985   if (NULL == address)
 986   {
 987     sh->address = NULL;
 988   }
 989   else
 990   {
 991     memcpy (&sh[1],
 992             address,
 993             alen);
 994     sh->address = (const char *) &sh[1];
 995   }
 996   GNUNET_CONTAINER_DLL_insert (p->sh_head,
 997                                p->sh_tail,
 998                                sh);
 999   /* match HELLO */
1000   hello = p->h_head;
1001   while ( (NULL != hello) &&
1002           (0 != strcmp (address,
1003                         hello->address)) )
1004     hello = hello->next;
1005   if (NULL != hello)
1006   {
1007     hello->sh = sh;
1008     hello->backoff = GNUNET_TIME_UNIT_ZERO;
1009     sh->hello = hello;
1010   }
1011   update (h);
1012   return NULL;
1013 }
1014
1015
1016 /**
1017  * @a data changed for a given @a sh, solver should consider
1018  * the updated performance characteristics.
1019  *
1020  * @param cls closure
1021  * @param sh session this is about
1022  * @param data performance characteristics of @a sh
1023  */
1024 static void
1025 simple_session_update (void *cls,
1026                        struct GNUNET_ATS_SessionHandle *sh,
1027                        const struct GNUNET_ATS_SessionData *data)
1028 {
1029   struct SimpleHandle *h = cls;
1030
1031   sh->data = data; /* this statement should not really do anything... */
1032   update (h);
1033 }
1034
1035
1036 /**
1037  * A session went away. Solver should update accordingly.
1038  *
1039  * @param cls closure
1040  * @param sh session this is about
1041  * @param data (last) performance characteristics of @a sh
1042  */
1043 static void
1044 simple_session_del (void *cls,
1045                     struct GNUNET_ATS_SessionHandle *sh,
1046                     const struct GNUNET_ATS_SessionData *data)
1047 {
1048   struct SimpleHandle *h = cls;
1049   struct Peer *p = sh->peer;
1050   struct Hello *hello = sh->hello;
1051
1052   /* clean up sh */
1053   GNUNET_CONTAINER_DLL_remove (p->sh_head,
1054                                p->sh_tail,
1055                                sh);
1056   if (NULL != hello)
1057   {
1058     GNUNET_assert (sh == hello->sh);
1059     hello->sh = NULL;
1060     /* session went down, if necessary restart suggesting
1061        addresses */
1062     if (NULL == p->task)
1063       p->task = GNUNET_SCHEDULER_add_now (&suggest_start_cb,
1064                                           p);
1065   }
1066   GNUNET_free (sh);
1067   /* del peer if otherwise dead */
1068   if ( (NULL == p->sh_head) &&
1069        (GNUNET_YES == peer_test_dead (p)) )
1070     peer_free (p);
1071   update (h);
1072 }
1073
1074
1075 #include "plugin_ats2_common.c"
1076
1077
1078 /**
1079  * Function invoked when the plugin is loaded.
1080  *
1081  * @param[in,out] cls the `struct GNUNET_ATS_PluginEnvironment *` to use;
1082  *            modified to return the API functions (ugh).
1083  * @return the `struct SimpleHandle` to pass as a closure
1084  */
1085 void *
1086 libgnunet_plugin_ats2_simple_init (void *cls)
1087 {
1088   static struct GNUNET_ATS_SolverFunctions sf;
1089   struct GNUNET_ATS_PluginEnvironment *env = cls;
1090   struct SimpleHandle *s;
1091
1092   s = GNUNET_new (struct SimpleHandle);
1093   s->env = env;
1094   s->peers = GNUNET_CONTAINER_multipeermap_create (128,
1095                                                    GNUNET_YES);
1096   s->ps = GNUNET_PEERSTORE_connect (env->cfg);
1097   sf.cls = s;
1098   sf.preference_add = &simple_preference_add;
1099   sf.preference_del = &simple_preference_del;
1100   sf.session_add = &simple_session_add;
1101   sf.session_update = &simple_session_update;
1102   sf.session_del = &simple_session_del;
1103   for (enum GNUNET_NetworkType nt = 0;
1104        nt < GNUNET_NT_COUNT;
1105        nt++)
1106   {
1107     const char *name = GNUNET_NT_to_string (nt);
1108
1109     if (NULL == name)
1110     {
1111       GNUNET_break (0);
1112       break;
1113     }
1114     get_quota (env->cfg,
1115                name,
1116                "IN",
1117                &s->networks[nt].total_quota_in);
1118     get_quota (env->cfg,
1119                name,
1120                "OUT",
1121                &s->networks[nt].total_quota_out);
1122     s->networks[nt].type = nt;
1123   }
1124   return &sf;
1125 }
1126
1127
1128 /**
1129  * Function used to unload the plugin.
1130  *
1131  * @param cls return value from #libgnunet_plugin_ats_proportional_init()
1132  */
1133 void *
1134 libgnunet_plugin_ats2_simple_done (void *cls)
1135 {
1136   struct GNUNET_ATS_SolverFunctions *sf = cls;
1137   struct SimpleHandle *s = sf->cls;
1138
1139   GNUNET_break (0 ==
1140                 GNUNET_CONTAINER_multipeermap_size (s->peers));
1141   GNUNET_CONTAINER_multipeermap_destroy (s->peers);
1142   GNUNET_PEERSTORE_disconnect (s->ps,
1143                                GNUNET_NO);
1144   GNUNET_free (s);
1145   return NULL;
1146 }
1147
1148
1149 /* end of plugin_ats2_simple.c */