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   memset (best,
 759           0,
 760           sizeof (best));
 761   for (struct GNUNET_ATS_SessionHandle *sh = peer->sh_head;
 762        NULL != sh;
 763        sh = sh->next)
 764   {
 765     enum GNUNET_NetworkType nt = sh->data->prop.nt;
 766
 767     sh->target_out = MIN_BANDWIDTH_PER_SESSION;
 768     c->bw_out_by_nt[nt] += MIN_BANDWIDTH_PER_SESSION;
 769     c->bw_in_by_nt[nt] += GNUNET_MAX (MIN_BANDWIDTH_PER_SESSION,
 770                                       sh->data->prop.goodput_in);
 771     for (enum GNUNET_MQ_PreferenceKind pk = 0;
 772          pk < GNUNET_MQ_PREFERENCE_COUNT;
 773          pk++)
 774     {
 775       /* General rule: always prefer smaller distance if possible,
 776          otherwise decide by pk: */
 777       switch (pk) {
 778       case GNUNET_MQ_PREFERENCE_NONE:
 779         break;
 780       case GNUNET_MQ_PREFERENCE_BANDWIDTH:
 781         /* For bandwidth, we compare the sum of transmitted bytes and
 782            confirmed transmitted bytes, so confirmed data counts twice */
 783         if ( (NULL == best[pk]) ||
 784              (sh->data->prop.distance < best[pk]->data->prop.distance) ||
 785              (sh->data->prop.utilization_out + sh->data->prop.goodput_out >
 786               best[pk]->data->prop.utilization_out + best[pk]->data->prop.goodput_out) )
 787           best[pk] = sh;
 788         /* If both are equal (i.e. usually this happens if there is a zero), use
 789            latency as a yardstick */
 790         if ( (sh->data->prop.utilization_out + sh->data->prop.goodput_out ==
 791               best[pk]->data->prop.utilization_out + best[pk]->data->prop.goodput_out) &&
 792              (sh->data->prop.distance == best[pk]->data->prop.distance) &&
 793              (sh->data->prop.delay.rel_value_us <
 794               best[pk]->data->prop.delay.rel_value_us) )
 795           best[pk] = sh;
 796         break;
 797       case GNUNET_MQ_PREFERENCE_LATENCY:
 798         if ( (NULL == best[pk]) ||
 799              (sh->data->prop.distance < best[pk]->data->prop.distance) ||
 800              ( (sh->data->prop.distance == best[pk]->data->prop.distance) &&
 801                (sh->data->prop.delay.rel_value_us <
 802                 best[pk]->data->prop.delay.rel_value_us) ) )
 803           best[pk] = sh;
 804         break;
 805       case GNUNET_MQ_PREFERENCE_RELIABILITY:
 806         /* For reliability, we consider the ratio of goodput to utilization
 807            (but use multiplicative formultations to avoid division by zero) */
 808         if ( (NULL == best[pk]) ||
 809              (1ULL * sh->data->prop.goodput_out * best[pk]->data->prop.utilization_out >
 810               1ULL * sh->data->prop.utilization_out * best[pk]->data->prop.goodput_out) )
 811           best[pk] = sh;
 812         /* If both are equal (i.e. usually this happens if there is a zero), use
 813            latency as a yardstick */
 814         if ( (1ULL * sh->data->prop.goodput_out * best[pk]->data->prop.utilization_out ==
 815               1ULL * sh->data->prop.utilization_out * best[pk]->data->prop.goodput_out) &&
 816              (sh->data->prop.distance == best[pk]->data->prop.distance) &&
 817              (sh->data->prop.delay.rel_value_us <
 818               best[pk]->data->prop.delay.rel_value_us) )
 819           best[pk] = sh;
 820         break;
 821       }
 822     }
 823   }
 824   /* for first round, assign target bandwidth simply to sum of
 825      requested bandwidth */
 826   for (enum GNUNET_MQ_PreferenceKind pk = 0;
 827        pk < GNUNET_MQ_PREFERENCE_COUNT;
 828        pk++)
 829   {
 830     enum GNUNET_NetworkType nt = best[pk]->data->prop.nt;
 831
 832     best[pk]->target_out = GNUNET_MIN (peer->bw_by_pk[pk],
 833                                        MIN_BANDWIDTH_PER_SESSION);
 834     c->bw_out_by_nt[nt] += (uint64_t) (best[pk]->target_out - MIN_BANDWIDTH_PER_SESSION);
 835   }
 836   return GNUNET_YES;
 837 }
 838
 839
 840 /**
 841  * Function used to iterate over all peers and collect
 842  * counter data.
 843  *
 844  * @param cls a `struct Counters *`
 845  * @param pid identity of the peer we process, unused
 846  * @param value a `struct Peer *`
 847  * @return #GNUNET_YES (continue to iterate)
 848  */
 849 static int
 850 update_allocation (void *cls,
 851                    const struct GNUNET_PeerIdentity *pid,
 852                    void *value)
 853 {
 854   struct Counters *c = cls;
 855   struct Peer *peer = value;
 856
 857   (void) pid;
 858   for (struct GNUNET_ATS_SessionHandle *sh = peer->sh_head;
 859        NULL != sh;
 860        sh = sh->next)
 861   {
 862     enum GNUNET_NetworkType nt = sh->data->prop.nt;
 863
 864     sh->target_out = (uint64_t) (c->scale_out[nt] * sh->target_out);
 865     sh->target_in = (uint64_t) (c->scale_in[nt] * sh->target_in);
 866     consider_notify_transport (sh);
 867   }
 868   return GNUNET_YES;
 869 }
 870
 871
 872 /**
 873  * The world changed, recalculate our allocations.
 874  */
 875 static void
 876 update (struct SimpleHandle *h)
 877 {
 878   struct Counters cnt = {
 879     .h = h
 880   };
 881
 882   GNUNET_CONTAINER_multipeermap_iterate (h->peers,
 883                                          &update_counters,
 884                                          &cnt);
 885   /* calculate how badly the missmatch between requested
 886      allocations and available bandwidth is per network type */
 887   for (enum GNUNET_NetworkType nt = 0;
 888        nt < GNUNET_NT_COUNT;
 889        nt++)
 890   {
 891     cnt.scale_out[nt] = 1.0 * cnt.bw_out_by_nt[nt] / h->networks[nt].total_quota_out;
 892     cnt.scale_in[nt] = 1.0 * cnt.bw_in_by_nt[nt] / h->networks[nt].total_quota_in;
 893   }
 894   /* recalculate allocations, considering scaling factor, and
 895      update transport if the change is significant */
 896   GNUNET_CONTAINER_multipeermap_iterate (h->peers,
 897                                          &update_allocation,
 898                                          &cnt);
 899 }
 900
 901
 902 /**
 903  * The plugin should begin to respect a new preference.
 904  *
 905  * @param cls the closure
 906  * @param pref the preference to add
 907  * @return plugin's internal representation, or NULL
 908  */
 909 static struct GNUNET_ATS_PreferenceHandle *
 910 simple_preference_add (void *cls,
 911                        const struct GNUNET_ATS_Preference *pref)
 912 {
 913   struct SimpleHandle *h = cls;
 914   struct Peer *p = peer_add (h,
 915                              &pref->peer);
 916
 917   GNUNET_assert (pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
 918   p->bw_by_pk[pref->pk] += ntohl (pref->bw.value__);
 919   h->bw_by_pk[pref->pk] += ntohl (pref->bw.value__);
 920   update (h);
 921   return NULL;
 922 }
 923
 924
 925 /**
 926  * The plugin should end respecting a preference.
 927  *
 928  * @param cls the closure
 929  * @param ph whatever @e preference_add returned
 930  * @param pref the preference to delete
 931  * @return plugin's internal representation, or NULL
 932  */
 933 static void
 934 simple_preference_del (void *cls,
 935                        struct GNUNET_ATS_PreferenceHandle *ph,
 936                        const struct GNUNET_ATS_Preference *pref)
 937 {
 938   struct SimpleHandle *h = cls;
 939   struct Peer *p = lookup_peer (h,
 940                                 &pref->peer);
 941
 942   GNUNET_assert (NULL != p);
 943   GNUNET_assert (pref->pk < GNUNET_MQ_PREFERENCE_COUNT);
 944   p->bw_by_pk[pref->pk] -= ntohl (pref->bw.value__);
 945   h->bw_by_pk[pref->pk] -= ntohl (pref->bw.value__);
 946   if ( (0 == p->bw_by_pk[pref->pk]) &&
 947        (GNUNET_YES == peer_test_dead (p)) )
 948     peer_free (p);
 949   update (h);
 950 }
 951
 952
 953 /**
 954  * Transport established a new session with performance
 955  * characteristics given in @a data.
 956  *
 957  * @param cls closure
 958  * @param data performance characteristics of @a sh
 959  * @param address address information (for debugging)
 960  * @return handle by which the plugin will identify this session
 961  */
 962 static struct GNUNET_ATS_SessionHandle *
 963 simple_session_add (void *cls,
 964                     const struct GNUNET_ATS_SessionData *data,
 965                     const char *address)
 966 {
 967   struct SimpleHandle *h = cls;
 968   struct Peer *p = peer_add (h,
 969                              &data->peer);
 970   struct Hello *hello;
 971   size_t alen;
 972   struct GNUNET_ATS_SessionHandle *sh;
 973
 974   /* setup session handle */
 975   if (NULL == address)
 976     alen = 0;
 977   else
 978     alen = strlen (address) + 1;
 979   sh = GNUNET_malloc (sizeof (struct GNUNET_ATS_SessionHandle) + alen);
 980   sh->peer = p;
 981   sh->session = data->session;
 982   sh->data = data;
 983   if (NULL == address)
 984   {
 985     sh->address = NULL;
 986   }
 987   else
 988   {
 989     memcpy (&sh[1],
 990             address,
 991             alen);
 992     sh->address = (const char *) &sh[1];
 993   }
 994   GNUNET_CONTAINER_DLL_insert (p->sh_head,
 995                                p->sh_tail,
 996                                sh);
 997   /* match HELLO */
 998   hello = p->h_head;
 999   while ( (NULL != hello) &&
1000           (0 != strcmp (address,
1001                         hello->address)) )
1002     hello = hello->next;
1003   if (NULL != hello)
1004   {
1005     hello->sh = sh;
1006     hello->backoff = GNUNET_TIME_UNIT_ZERO;
1007     sh->hello = hello;
1008   }
1009   update (h);
1010   return NULL;
1011 }
1012
1013
1014 /**
1015  * @a data changed for a given @a sh, solver should consider
1016  * the updated performance characteristics.
1017  *
1018  * @param cls closure
1019  * @param sh session this is about
1020  * @param data performance characteristics of @a sh
1021  */
1022 static void
1023 simple_session_update (void *cls,
1024                        struct GNUNET_ATS_SessionHandle *sh,
1025                        const struct GNUNET_ATS_SessionData *data)
1026 {
1027   struct SimpleHandle *h = cls;
1028
1029   sh->data = data; /* this statement should not really do anything... */
1030   update (h);
1031 }
1032
1033
1034 /**
1035  * A session went away. Solver should update accordingly.
1036  *
1037  * @param cls closure
1038  * @param sh session this is about
1039  * @param data (last) performance characteristics of @a sh
1040  */
1041 static void
1042 simple_session_del (void *cls,
1043                     struct GNUNET_ATS_SessionHandle *sh,
1044                     const struct GNUNET_ATS_SessionData *data)
1045 {
1046   struct SimpleHandle *h = cls;
1047   struct Peer *p = sh->peer;
1048   struct Hello *hello = sh->hello;
1049
1050   /* clean up sh */
1051   GNUNET_CONTAINER_DLL_remove (p->sh_head,
1052                                p->sh_tail,
1053                                sh);
1054   if (NULL != hello)
1055   {
1056     GNUNET_assert (sh == hello->sh);
1057     hello->sh = NULL;
1058     /* session went down, if necessary restart suggesting
1059        addresses */
1060     if (NULL == p->task)
1061       p->task = GNUNET_SCHEDULER_add_now (&suggest_start_cb,
1062                                           p);
1063   }
1064   GNUNET_free (sh);
1065   /* del peer if otherwise dead */
1066   if ( (NULL == p->sh_head) &&
1067        (GNUNET_YES == peer_test_dead (p)) )
1068     peer_free (p);
1069   update (h);
1070 }
1071
1072
1073 #include "plugin_ats2_common.c"
1074
1075
1076 /**
1077  * Function invoked when the plugin is loaded.
1078  *
1079  * @param[in,out] cls the `struct GNUNET_ATS_PluginEnvironment *` to use;
1080  *            modified to return the API functions (ugh).
1081  * @return the `struct SimpleHandle` to pass as a closure
1082  */
1083 void *
1084 libgnunet_plugin_ats2_simple_init (void *cls)
1085 {
1086   static struct GNUNET_ATS_SolverFunctions sf;
1087   struct GNUNET_ATS_PluginEnvironment *env = cls;
1088   struct SimpleHandle *s;
1089
1090   s = GNUNET_new (struct SimpleHandle);
1091   s->env = env;
1092   s->peers = GNUNET_CONTAINER_multipeermap_create (128,
1093                                                    GNUNET_YES);
1094   s->ps = GNUNET_PEERSTORE_connect (env->cfg);
1095   sf.cls = s;
1096   sf.preference_add = &simple_preference_add;
1097   sf.preference_del = &simple_preference_del;
1098   sf.session_add = &simple_session_add;
1099   sf.session_update = &simple_session_update;
1100   sf.session_del = &simple_session_del;
1101   for (enum GNUNET_NetworkType nt = 0;
1102        nt < GNUNET_NT_COUNT;
1103        nt++)
1104   {
1105     const char *name = GNUNET_NT_to_string (nt);
1106
1107     if (NULL == name)
1108     {
1109       GNUNET_break (0);
1110       break;
1111     }
1112     get_quota (env->cfg,
1113                name,
1114                "IN",
1115                &s->networks[nt].total_quota_in);
1116     get_quota (env->cfg,
1117                name,
1118                "OUT",
1119                &s->networks[nt].total_quota_out);
1120     s->networks[nt].type = nt;
1121   }
1122   return &sf;
1123 }
1124
1125
1126 /**
1127  * Function used to unload the plugin.
1128  *
1129  * @param cls return value from #libgnunet_plugin_ats_proportional_init()
1130  */
1131 void *
1132 libgnunet_plugin_ats2_simple_done (void *cls)
1133 {
1134   struct GNUNET_ATS_SolverFunctions *sf = cls;
1135   struct SimpleHandle *s = sf->cls;
1136
1137   GNUNET_break (0 ==
1138                 GNUNET_CONTAINER_multipeermap_size (s->peers));
1139   GNUNET_CONTAINER_multipeermap_destroy (s->peers);
1140   GNUNET_PEERSTORE_disconnect (s->ps,
1141                                GNUNET_NO);
1142   GNUNET_free (s);
1143   return NULL;
1144 }
1145
1146
1147 /* end of plugin_ats2_simple.c */