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 != GNUNET_memcmp (&p->pid,
 496                    &record->peer))
 497   {
 498     GNUNET_break (0);
 499     return;
 500   }
 501   if (0 != strcmp (record->key,
 502                    GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY))
 503   {
 504     GNUNET_break (0);
 505     return;
 506   }
 507   addr = GNUNET_HELLO_extract_address (record->value,
 508                                        record->value_size,
 509                                        &p->pid,
 510                                        &nt,
 511                                        &expiration);
 512   if (NULL == addr)
 513     return; /* invalid hello, bad signature, other problem */
 514   if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
 515   {
 516     /* expired, ignore */
 517     GNUNET_free (addr);
 518     return;
 519   }
 520   /* check if addr is already known */
 521   for (struct Hello *he = p->h_head;
 522        NULL != he;
 523        he = he->next)
 524   {
 525     if (0 != strcmp (he->address,
 526                      addr))
 527       continue;
 528     if (he->expiration.abs_value_us < expiration.abs_value_us)
 529     {
 530       he->expiration = expiration;
 531       he->nt = nt;
 532     }
 533     GNUNET_free (addr);
 534     return;
 535   }
 536   /* create new HELLO */
 537   alen = strlen (addr) + 1;
 538   hello = GNUNET_malloc (sizeof (struct Hello) + alen);
 539   hello->address = (const char *) &hello[1];
 540   hello->expiration = expiration;
 541   hello->nt = nt;
 542   hello->peer = p;
 543   memcpy (&hello[1],
 544           addr,
 545           alen);
 546   GNUNET_free (addr);
 547   GNUNET_CONTAINER_DLL_insert (p->h_head,
 548                                p->h_tail,
 549                                hello);
 550   /* check if sh for this HELLO already exists */
 551   for (struct GNUNET_ATS_SessionHandle *sh = p->sh_head;
 552        NULL != sh;
 553        sh = sh->next)
 554   {
 555     if ( (NULL == sh->address) ||
 556          (0 != strcmp (sh->address,
 557                        addr)) )
 558       continue;
 559     GNUNET_assert (NULL == sh->hello);
 560     sh->hello = hello;
 561     hello->sh = sh;
 562     break;
 563   }
 564   if (NULL == p->task)
 565     p->task = GNUNET_SCHEDULER_add_now (&suggest_start_cb,
 566                                         p);
 567 }
 568
 569
 570 /**
 571  * Find or add peer if necessary.
 572  *
 573  * @param h our plugin handle
 574  * @param pid the peer identity to add/look for
 575  * @return a peer handle
 576  */
 577 static struct Peer *
 578 peer_add (struct SimpleHandle *h,
 579           const struct GNUNET_PeerIdentity *pid)
 580 {
 581   struct Peer *p = lookup_peer (h,
 582                                 pid);
 583
 584   if (NULL != p)
 585     return p;
 586   p = GNUNET_new (struct Peer);
 587   p->h = h;
 588   p->pid = *pid;
 589   p->wc = GNUNET_PEERSTORE_watch (h->ps,
 590                                   "transport",
 591                                   &p->pid,
 592                                   GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY,
 593                                   &watch_cb,
 594                                   p);
 595   GNUNET_assert (GNUNET_YES ==
 596                  GNUNET_CONTAINER_multipeermap_put (h->peers,
 597                                                     &p->pid,
 598                                                     p,
 599                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 600
 601   return p;
 602 }
 603
 604
 605 /**
 606  * Free the entry (and associated tasks) of peer @a p.
 607  * Note that @a p must be dead already (see #peer_test_dead()).
 608  *
 609  * @param p the peer to free
 610  */
 611 static void
 612 peer_free (struct Peer *p)
 613 {
 614   struct SimpleHandle *h = p->h;
 615   struct Hello *hello;
 616
 617   GNUNET_assert (NULL == p->sh_head);
 618   while (NULL != (hello = p->h_head))
 619   {
 620     GNUNET_CONTAINER_DLL_remove (p->h_head,
 621                                  p->h_tail,
 622                                  hello);
 623     GNUNET_assert (NULL == hello->sh);
 624     GNUNET_free (hello);
 625   }
 626   if (NULL != p->task)
 627   {
 628     GNUNET_SCHEDULER_cancel (p->task);
 629     p->task = NULL;
 630   }
 631   if (NULL != p->wc)
 632   {
 633     GNUNET_PEERSTORE_watch_cancel (p->wc);
 634     p->wc = NULL;
 635   }
 636   GNUNET_assert (GNUNET_YES ==
 637                  GNUNET_CONTAINER_multipeermap_remove (h->peers,
 638                                                        &p->pid,
 639                                                        p));
 640   GNUNET_free (p);
 641 }
 642
 643
 644 /**
 645  * Check if the new allocation for @a sh is significantly different
 646  * from the last one, and if so, tell transport.
 647  *
 648  * @param sh session handle to consider updating transport for
 649  */
 650 static void
 651 consider_notify_transport (struct GNUNET_ATS_SessionHandle *sh)
 652 {
 653   struct Peer *peer = sh->peer;
 654   struct SimpleHandle *h = peer->h;
 655   enum GNUNET_NetworkType nt = sh->data->prop.nt;
 656   struct GNUNET_TIME_Relative delay;
 657   uint64_t sig_in;
 658   uint64_t sig_out;
 659   int64_t delta_in;
 660   int64_t delta_out;
 661
 662   delay = GNUNET_TIME_absolute_get_duration (sh->last_allocation);
 663   /* A significant change is more than 10% of the quota,
 664      which is given in bytes/second */
 665   sig_in
 666     = h->networks[nt].total_quota_in * (delay.rel_value_us / 1000LL) / 1000LL / 10;
 667   sig_out
 668     = h->networks[nt].total_quota_out * (delay.rel_value_us / 1000LL) / 1000LL / 10;
 669   delta_in = ( (int64_t) ntohl (sh->bw_in.value__)) - ((int64_t) sh->target_in);
 670   delta_out = ( (int64_t) ntohl (sh->bw_in.value__)) - ((int64_t) sh->target_in);
 671   /* we want the absolute values */
 672   if (delta_in < 0)
 673     delta_in = - delta_in;
 674   if (INT64_MIN == delta_in)
 675     delta_in = INT64_MAX;  /* Handle corner case: INT_MIN == - INT_MIN */
 676   if (delta_out < 0)
 677     delta_out = - delta_out;
 678   if (INT64_MIN == delta_out)
 679     delta_out = INT64_MAX; /* Handle corner case: INT_MIN == - INT_MIN */
 680   if ( (sig_in > delta_in) &&
 681        (sig_out > delta_out) )
 682     return; /* insignificant change */
 683   /* change is significant, tell transport! */
 684   if (sh->target_in > UINT32_MAX)
 685     sh->target_in = UINT32_MAX;
 686   sh->bw_in.value__ = htonl ((uint32_t) sh->target_in);
 687   if (sh->target_out > UINT32_MAX)
 688     sh->target_out = UINT32_MAX;
 689   sh->bw_out.value__ = htonl ((uint32_t) sh->target_out);
 690   sh->last_allocation = GNUNET_TIME_absolute_get ();
 691   h->env->allocate_cb (h->env->cls,
 692                        sh->session,
 693                        &peer->pid,
 694                        sh->bw_in,
 695                        sh->bw_out);
 696 }
 697
 698
 699 /**
 700  * Closure for #update_counters and #update_allocation.
 701  */
 702 struct Counters
 703 {
 704   /**
 705    * Plugin's state.
 706    */
 707   struct SimpleHandle *h;
 708
 709   /**
 710    * Bandwidth that applications would prefer to allocate in this
 711    * network type.  We initially add all requested allocations to the
 712    * respective network type where the given preference is best
 713    * satisfied. Later we may rebalance.
 714    */
 715   uint64_t bw_out_by_nt[GNUNET_NT_COUNT];
 716
 717   /**
 718    * Current bandwidth utilization for this network type.  We simply
 719    * add the current goodput up (with some fairness considerations).
 720    */
 721   uint64_t bw_in_by_nt[GNUNET_NT_COUNT];
 722
 723   /**
 724    * By how much do we have to scale (up or down) our expectations
 725    * for outbound bandwidth?
 726    */
 727   double scale_out[GNUNET_NT_COUNT];
 728
 729   /**
 730    * By how much do we have to scale (up or down) our expectations
 731    * for inbound bandwidth?
 732    */
 733   double scale_in[GNUNET_NT_COUNT];
 734
 735 };
 736
 737
 738 /**
 739  * Function used to iterate over all peers and collect
 740  * counter data.
 741  *
 742  * @param cls a `struct Counters *`
 743  * @param pid identity of the peer we process, unused
 744  * @param value a `struct Peer *`
 745  * @return #GNUNET_YES (continue to iterate)
 746  */
 747 static int
 748 update_counters (void *cls,
 749                  const struct GNUNET_PeerIdentity *pid,
 750                  void *value)
 751 {
 752   struct Counters *c = cls;
 753   struct Peer *peer = value;
 754   struct GNUNET_ATS_SessionHandle *best[GNUNET_MQ_PREFERENCE_COUNT];
 755
 756   (void) pid;
 757   if (NULL == peer->sh_head)
 758     return GNUNET_YES; /* no available session, cannot allocate bandwidth */
 759   memset (best,
 760           0,
 761           sizeof (best));
 762   for (struct GNUNET_ATS_SessionHandle *sh = peer->sh_head;
 763        NULL != sh;
 764        sh = sh->next)
 765   {
 766     enum GNUNET_NetworkType nt = sh->data->prop.nt;
 767
 768     sh->target_out = MIN_BANDWIDTH_PER_SESSION;
 769     c->bw_out_by_nt[nt] += MIN_BANDWIDTH_PER_SESSION;
 770     c->bw_in_by_nt[nt] += GNUNET_MAX (MIN_BANDWIDTH_PER_SESSION,
 771                                       sh->data->prop.goodput_in);
 772     for (enum GNUNET_MQ_PreferenceKind pk = 0;
 773          pk < GNUNET_MQ_PREFERENCE_COUNT;
 774          pk++)
 775     {
 776       /* General rule: always prefer smaller distance if possible,
 777          otherwise decide by pk: */
 778       switch (pk) {
 779       case GNUNET_MQ_PREFERENCE_NONE:
 780         break;
 781       case GNUNET_MQ_PREFERENCE_BANDWIDTH:
 782         /* For bandwidth, we compare the sum of transmitted bytes and
 783            confirmed transmitted bytes, so confirmed data counts twice */
 784         if ( (NULL == best[pk]) ||
 785              (sh->data->prop.distance < best[pk]->data->prop.distance) ||
 786              (sh->data->prop.utilization_out + sh->data->prop.goodput_out >
 787               best[pk]->data->prop.utilization_out + best[pk]->data->prop.goodput_out) )
 788           best[pk] = sh;
 789         /* If both are equal (i.e. usually this happens if there is a zero), use
 790            latency as a yardstick */
 791         if ( (sh->data->prop.utilization_out + sh->data->prop.goodput_out ==
 792               best[pk]->data->prop.utilization_out + best[pk]->data->prop.goodput_out) &&
 793              (sh->data->prop.distance == best[pk]->data->prop.distance) &&
 794              (sh->data->prop.delay.rel_value_us <
 795               best[pk]->data->prop.delay.rel_value_us) )
 796           best[pk] = sh;
 797         break;
 798       case GNUNET_MQ_PREFERENCE_LATENCY:
 799         if ( (NULL == best[pk]) ||
 800              (sh->data->prop.distance < best[pk]->data->prop.distance) ||
 801              ( (sh->data->prop.distance == best[pk]->data->prop.distance) &&
 802                (sh->data->prop.delay.rel_value_us <
 803                 best[pk]->data->prop.delay.rel_value_us) ) )
 804           best[pk] = sh;
 805         break;
 806       case GNUNET_MQ_PREFERENCE_RELIABILITY:
 807         /* For reliability, we consider the ratio of goodput to utilization
 808            (but use multiplicative formultations to avoid division by zero) */
 809         if ( (NULL == best[pk]) ||
 810              (1ULL * sh->data->prop.goodput_out * best[pk]->data->prop.utilization_out >
 811               1ULL * sh->data->prop.utilization_out * best[pk]->data->prop.goodput_out) )
 812           best[pk] = sh;
 813         /* If both are equal (i.e. usually this happens if there is a zero), use
 814            latency as a yardstick */
 815         if ( (1ULL * sh->data->prop.goodput_out * best[pk]->data->prop.utilization_out ==
 816               1ULL * sh->data->prop.utilization_out * best[pk]->data->prop.goodput_out) &&
 817              (sh->data->prop.distance == best[pk]->data->prop.distance) &&
 818              (sh->data->prop.delay.rel_value_us <
 819               best[pk]->data->prop.delay.rel_value_us) )
 820           best[pk] = sh;
 821         break;
 822       }
 823     }
 824   }
 825   /* for first round, assign target bandwidth simply to sum of
 826      requested bandwidth */
 827   for (enum GNUNET_MQ_PreferenceKind pk = 1 /* skip GNUNET_MQ_PREFERENCE_NONE */;
 828        pk < GNUNET_MQ_PREFERENCE_COUNT;
 829        pk++)
 830   {
 831     const struct GNUNET_ATS_SessionData *data = best[pk]->data;
 832     enum GNUNET_NetworkType nt;
 833
 834     GNUNET_assert (NULL != data);
 835     nt = data->prop.nt;
 836     best[pk]->target_out = GNUNET_MIN (peer->bw_by_pk[pk],
 837                                        MIN_BANDWIDTH_PER_SESSION);
 838     c->bw_out_by_nt[nt] += (uint64_t) (best[pk]->target_out - MIN_BANDWIDTH_PER_SESSION);
 839   }
 840   return GNUNET_YES;
 841 }
 842
 843
 844 /**
 845  * Function used to iterate over all peers and collect
 846  * counter data.
 847  *
 848  * @param cls a `struct Counters *`
 849  * @param pid identity of the peer we process, unused
 850  * @param value a `struct Peer *`
 851  * @return #GNUNET_YES (continue to iterate)
 852  */
 853 static int
 854 update_allocation (void *cls,
 855                    const struct GNUNET_PeerIdentity *pid,
 856                    void *value)
 857 {
 858   struct Counters *c = cls;
 859   struct Peer *peer = value;
 860
 861   (void) pid;
 862   for (struct GNUNET_ATS_SessionHandle *sh = peer->sh_head;
 863        NULL != sh;
 864        sh = sh->next)
 865   {
 866     enum GNUNET_NetworkType nt = sh->data->prop.nt;
 867
 868     sh->target_out = (uint64_t) (c->scale_out[nt] * sh->target_out);
 869     sh->target_in = (uint64_t) (c->scale_in[nt] * sh->target_in);
 870     consider_notify_transport (sh);
 871   }
 872   return GNUNET_YES;
 873 }
 874
 875
 876 /**
 877  * The world changed, recalculate our allocations.
 878  */
 879 static void
 880 update (struct SimpleHandle *h)
 881 {
 882   struct Counters cnt = {
 883     .h = h
 884   };
 885
 886   GNUNET_CONTAINER_multipeermap_iterate (h->peers,
 887                                          &update_counters,
 888                                          &cnt);
 889   /* calculate how badly the missmatch between requested
 890      allocations and available bandwidth is per network type */
 891   for (enum GNUNET_NetworkType nt = 0;
 892        nt < GNUNET_NT_COUNT;
 893        nt++)
 894   {
 895     cnt.scale_out[nt] = 1.0 * cnt.bw_out_by_nt[nt] / h->networks[nt].total_quota_out;
 896     cnt.scale_in[nt] = 1.0 * cnt.bw_in_by_nt[nt] / h->networks[nt].total_quota_in;
 897   }
 898   /* recalculate allocations, considering scaling factor, and
 899      update transport if the change is significant */
 900   GNUNET_CONTAINER_multipeermap_iterate (h->peers,
 901                                          &update_allocation,
 902                                          &cnt);
 903 }
 904
 905
 906 /**
 907  * The plugin should begin to respect a new preference.
 908  *
 909  * @param cls the closure
 910  * @param pref the preference to add
 911  * @return plugin's internal representation, or NULL
 912  */
 913 static struct GNUNET_ATS_PreferenceHandle *
 914 simple_preference_add (void *cls,
 915                        const struct GNUNET_ATS_Preference *pref)
 916 {
 917   struct SimpleHandle *h = cls;
 918   struct Peer *p = peer_add (h,
 919                              &pref->peer);
 920
 921   GNUNET_assert (pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
 922   p->bw_by_pk[pref->pk] += ntohl (pref->bw.value__);
 923   h->bw_by_pk[pref->pk] += ntohl (pref->bw.value__);
 924   update (h);
 925   return NULL;
 926 }
 927
 928
 929 /**
 930  * The plugin should end respecting a preference.
 931  *
 932  * @param cls the closure
 933  * @param ph whatever @e preference_add returned
 934  * @param pref the preference to delete
 935  * @return plugin's internal representation, or NULL
 936  */
 937 static void
 938 simple_preference_del (void *cls,
 939                        struct GNUNET_ATS_PreferenceHandle *ph,
 940                        const struct GNUNET_ATS_Preference *pref)
 941 {
 942   struct SimpleHandle *h = cls;
 943   struct Peer *p = lookup_peer (h,
 944                                 &pref->peer);
 945
 946   GNUNET_assert (NULL != p);
 947   GNUNET_assert (pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
 948   p->bw_by_pk[pref->pk] -= ntohl (pref->bw.value__);
 949   h->bw_by_pk[pref->pk] -= ntohl (pref->bw.value__);
 950   if ( (0 == p->bw_by_pk[pref->pk]) &&
 951        (GNUNET_YES == peer_test_dead (p)) )
 952     peer_free (p);
 953   update (h);
 954 }
 955
 956
 957 /**
 958  * Transport established a new session with performance
 959  * characteristics given in @a data.
 960  *
 961  * @param cls closure
 962  * @param data performance characteristics of @a sh
 963  * @param address address information (for debugging)
 964  * @return handle by which the plugin will identify this session
 965  */
 966 static struct GNUNET_ATS_SessionHandle *
 967 simple_session_add (void *cls,
 968                     const struct GNUNET_ATS_SessionData *data,
 969                     const char *address)
 970 {
 971   struct SimpleHandle *h = cls;
 972   struct Peer *p = peer_add (h,
 973                              &data->peer);
 974   struct Hello *hello;
 975   size_t alen;
 976   struct GNUNET_ATS_SessionHandle *sh;
 977
 978   /* setup session handle */
 979   GNUNET_assert (NULL != data);
 980   if (NULL == address)
 981     alen = 0;
 982   else
 983     alen = strlen (address) + 1;
 984   sh = GNUNET_malloc (sizeof (struct GNUNET_ATS_SessionHandle) + alen);
 985   sh->peer = p;
 986   sh->session = data->session;
 987   sh->data = data;
 988   if (NULL == address)
 989   {
 990     sh->address = NULL;
 991   }
 992   else
 993   {
 994     memcpy (&sh[1],
 995             address,
 996             alen);
 997     sh->address = (const char *) &sh[1];
 998   }
 999   GNUNET_CONTAINER_DLL_insert (p->sh_head,
1000                                p->sh_tail,
1001                                sh);
1002   /* match HELLO */
1003   hello = p->h_head;
1004   while ( (NULL != hello) &&
1005           (0 != strcmp (address,
1006                         hello->address)) )
1007     hello = hello->next;
1008   if (NULL != hello)
1009   {
1010     hello->sh = sh;
1011     hello->backoff = GNUNET_TIME_UNIT_ZERO;
1012     sh->hello = hello;
1013   }
1014   update (h);
1015   return sh;
1016 }
1017
1018
1019 /**
1020  * @a data changed for a given @a sh, solver should consider
1021  * the updated performance characteristics.
1022  *
1023  * @param cls closure
1024  * @param sh session this is about
1025  * @param data performance characteristics of @a sh
1026  */
1027 static void
1028 simple_session_update (void *cls,
1029                        struct GNUNET_ATS_SessionHandle *sh,
1030                        const struct GNUNET_ATS_SessionData *data)
1031 {
1032   struct SimpleHandle *h = cls;
1033
1034   GNUNET_assert (NULL != data);
1035   sh->data = data; /* this statement should not really do anything... */
1036   update (h);
1037 }
1038
1039
1040 /**
1041  * A session went away. Solver should update accordingly.
1042  *
1043  * @param cls closure
1044  * @param sh session this is about
1045  * @param data (last) performance characteristics of @a sh
1046  */
1047 static void
1048 simple_session_del (void *cls,
1049                     struct GNUNET_ATS_SessionHandle *sh,
1050                     const struct GNUNET_ATS_SessionData *data)
1051 {
1052   struct SimpleHandle *h = cls;
1053   struct Peer *p = sh->peer;
1054   struct Hello *hello = sh->hello;
1055
1056   /* clean up sh */
1057   GNUNET_CONTAINER_DLL_remove (p->sh_head,
1058                                p->sh_tail,
1059                                sh);
1060   if (NULL != hello)
1061   {
1062     GNUNET_assert (sh == hello->sh);
1063     hello->sh = NULL;
1064     /* session went down, if necessary restart suggesting
1065        addresses */
1066     if (NULL == p->task)
1067       p->task = GNUNET_SCHEDULER_add_now (&suggest_start_cb,
1068                                           p);
1069   }
1070   GNUNET_free (sh);
1071   /* del peer if otherwise dead */
1072   if ( (NULL == p->sh_head) &&
1073        (GNUNET_YES == peer_test_dead (p)) )
1074     peer_free (p);
1075   update (h);
1076 }
1077
1078
1079 #include "plugin_ats2_common.c"
1080
1081
1082 /**
1083  * Function invoked when the plugin is loaded.
1084  *
1085  * @param[in,out] cls the `struct GNUNET_ATS_PluginEnvironment *` to use;
1086  *            modified to return the API functions (ugh).
1087  * @return the `struct SimpleHandle` to pass as a closure
1088  */
1089 void *
1090 libgnunet_plugin_ats2_simple_init (void *cls)
1091 {
1092   static struct GNUNET_ATS_SolverFunctions sf;
1093   struct GNUNET_ATS_PluginEnvironment *env = cls;
1094   struct SimpleHandle *s;
1095
1096   s = GNUNET_new (struct SimpleHandle);
1097   s->env = env;
1098   s->peers = GNUNET_CONTAINER_multipeermap_create (128,
1099                                                    GNUNET_YES);
1100   s->ps = GNUNET_PEERSTORE_connect (env->cfg);
1101   sf.cls = s;
1102   sf.preference_add = &simple_preference_add;
1103   sf.preference_del = &simple_preference_del;
1104   sf.session_add = &simple_session_add;
1105   sf.session_update = &simple_session_update;
1106   sf.session_del = &simple_session_del;
1107   for (enum GNUNET_NetworkType nt = 0;
1108        nt < GNUNET_NT_COUNT;
1109        nt++)
1110   {
1111     const char *name = GNUNET_NT_to_string (nt);
1112
1113     if (NULL == name)
1114     {
1115       GNUNET_break (0);
1116       break;
1117     }
1118     get_quota (env->cfg,
1119                name,
1120                "IN",
1121                &s->networks[nt].total_quota_in);
1122     get_quota (env->cfg,
1123                name,
1124                "OUT",
1125                &s->networks[nt].total_quota_out);
1126     s->networks[nt].type = nt;
1127   }
1128   return &sf;
1129 }
1130
1131
1132 /**
1133  * Function used to unload the plugin.
1134  *
1135  * @param cls return value from #libgnunet_plugin_ats_proportional_init()
1136  */
1137 void *
1138 libgnunet_plugin_ats2_simple_done (void *cls)
1139 {
1140   struct GNUNET_ATS_SolverFunctions *sf = cls;
1141   struct SimpleHandle *s = sf->cls;
1142
1143   GNUNET_break (0 ==
1144                 GNUNET_CONTAINER_multipeermap_size (s->peers));
1145   GNUNET_CONTAINER_multipeermap_destroy (s->peers);
1146   GNUNET_PEERSTORE_disconnect (s->ps,
1147                                GNUNET_NO);
1148   GNUNET_free (s);
1149   return NULL;
1150 }
1151
1152
1153 /* end of plugin_ats2_simple.c */