[GNUnet-SVN] r32263 - in gnunet/src: include util

[gnunet]

Author: grothoff
Date: 2014-02-09 19:45:18 +0100 (Sun, 09 Feb 2014)
New Revision: 32263

Modified:
   gnunet/src/include/gnunet_bandwidth_lib.h
   gnunet/src/util/bandwidth.c
Log:
add api to bandwidth tracker to notify clients about excess bandwidth available

Modified: gnunet/src/include/gnunet_bandwidth_lib.h
===================================================================
--- gnunet/src/include/gnunet_bandwidth_lib.h   2014-02-08 16:46:25 UTC (rev 
32262)
+++ gnunet/src/include/gnunet_bandwidth_lib.h   2014-02-09 18:45:18 UTC (rev 
32263)
@@ -60,10 +60,20 @@
  * @param cls a closure to pass
  */
 typedef void
-(*GNUNET_BANDWIDTH_tracker_update_cb) (void *cls);
+(*GNUNET_BANDWIDTH_TrackerUpdateCallback) (void *cls);
 
 
 /**
+ * Callback to be called by the bandwidth tracker if the tracker
+ * was updated and the client should update it's delay values
+ *
+ * @param cls a closure to pass
+ */
+typedef void
+(*GNUNET_BANDWIDTH_ExcessNotificationCallback) (void *cls);
+
+
+/**
  * Struct to track available bandwidth.  Combines a time stamp with a
  * number of bytes transmitted, a quota and a maximum amount that
  * carries over.  Not opaque so that it can be inlined into data
@@ -81,14 +91,31 @@
    * Function we call if the tracker's bandwidth is increased and a
    * previously returned timeout might now expire earlier.
    */
-  GNUNET_BANDWIDTH_tracker_update_cb update_cb;
+  GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb;
 
   /**
+   * Closure for @e excess_cb.
+   */
+  void *excess_cb_cls;
+
+  /**
+   * Function we call if the tracker is about to throw
+   * away bandwidth due to excess (max carry exceeded).
+   */
+  GNUNET_BANDWIDTH_ExcessNotificationCallback excess_cb;
+
+  /**
    * Number of bytes consumed since we last updated the tracker.
    */
   int64_t consumption_since_last_update__;
 
   /**
+   * Task scheduled to call the @e excess_cb once we have
+   * reached the maximum bandwidth the tracker can hold.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier excess_task;
+
+  /**
    * Time when we last updated the tracker.
    */
   struct GNUNET_TIME_Absolute last_update__;
@@ -132,10 +159,8 @@
  * @return number of bytes available at bps until deadline
  */
 uint64_t
-GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO
-                                            bps,
-                                            struct GNUNET_TIME_Relative
-                                            deadline);
+GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO 
bps,
+                                            struct GNUNET_TIME_Relative 
deadline);
 
 
 /**
@@ -181,14 +206,41 @@
  */
 void
 GNUNET_BANDWIDTH_tracker_init (struct GNUNET_BANDWIDTH_Tracker *av,
-                               GNUNET_BANDWIDTH_tracker_update_cb update_cb,
+                               GNUNET_BANDWIDTH_TrackerUpdateCallback 
update_cb,
                                void *update_cb_cls,
-                               struct GNUNET_BANDWIDTH_Value32NBO
-                               bytes_per_second_limit,
+                               struct GNUNET_BANDWIDTH_Value32NBO 
bytes_per_second_limit,
                                uint32_t max_carry_s);
 
 
 /**
+ * Initialize bandwidth tracker.  Note that in addition to the
+ * 'max_carry_s' limit, we also always allow at least
+ * GNUNET_SERVER_MAX_MESSAGE_SIZE to accumulate.  So if the
+ * bytes-per-second limit is so small that within 'max_carry_s' not
+ * even GNUNET_SERVER_MAX_MESSAGE_SIZE is allowed to accumulate, it is
+ * ignored and replaced by GNUNET_SERVER_MAX_MESSAGE_SIZE (which is in
+ * bytes).
+ *
+ * @param av tracker to initialize
+ * @param update_cb callback to notify a client about the tracker being updated
+ * @param update_cb_cls cls for the @a update_cb callback
+ * @param bytes_per_second_limit initial limit to assume
+ * @param max_carry_s maximum number of seconds unused bandwidth
+ *        may accumulate before it expires
+ * @param excess_cb callback to notify if we have excess bandwidth
+ * @param excess_cb_cls closure for @a excess_cb
+ */
+void
+GNUNET_BANDWIDTH_tracker_init2 (struct GNUNET_BANDWIDTH_Tracker *av,
+                                GNUNET_BANDWIDTH_TrackerUpdateCallback 
update_cb,
+                                void *update_cb_cls,
+                                struct GNUNET_BANDWIDTH_Value32NBO 
bytes_per_second_limit,
+                                uint32_t max_carry_s,
+                                GNUNET_BANDWIDTH_ExcessNotificationCallback 
excess_cb,
+                                void *excess_cb_cls);
+
+
+/**
  * Notify the tracker that a certain number of bytes of bandwidth have
  * been consumed.  Note that it is legal to consume bytes even if not
  * enough bandwidth is available (in that case,

Modified: gnunet/src/util/bandwidth.c
===================================================================
--- gnunet/src/util/bandwidth.c 2014-02-08 16:46:25 UTC (rev 32262)
+++ gnunet/src/util/bandwidth.c 2014-02-09 18:45:18 UTC (rev 32263)
@@ -74,10 +74,8 @@
  * @return number of bytes available at bps until deadline
  */
 uint64_t
-GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO
-                                            bps,
-                                            struct GNUNET_TIME_Relative
-                                            deadline)
+GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO 
bps,
+                                            struct GNUNET_TIME_Relative 
deadline)
 {
   uint64_t b;
 
@@ -121,14 +119,79 @@
 }
 
 
+/**
+ * Task run whenever we hit the bandwidth limit for a tracker.
+ *
+ * @param cls the `struct GNUNET_BANDWIDTH_Tracker`
+ * @param tc scheduler context
+ */
+static void
+excess_trigger (void *cls,
+                const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_BANDWIDTH_Tracker *av = cls;
 
+  av->excess_task = GNUNET_SCHEDULER_NO_TASK;
+  av->excess_cb (av->excess_cb_cls);
+}
+
+
 /**
+ * Recalculate when we might need to call the excess callback.
+ */
+static void
+update_excess (struct GNUNET_BANDWIDTH_Tracker *av)
+{
+  struct GNUNET_TIME_Relative delay;
+  struct GNUNET_TIME_Absolute now;
+  uint64_t delta_time;
+  uint64_t delta_avail;
+  int64_t left_bytes;
+  uint64_t max_carry;
+  int64_t current_consumption;
+
+  if (NULL == av->excess_cb)
+    return; /* nothing to do */
+  now = GNUNET_TIME_absolute_get ();
+  delta_time = now.abs_value_us - av->last_update__.abs_value_us;
+  delta_avail =
+      (delta_time * ((unsigned long long) av->available_bytes_per_s__) +
+       500000LL) / 1000000LL;
+  current_consumption = av->consumption_since_last_update__ - delta_avail;
+  /* negative current_consumption means that we have savings */
+  max_carry = av->available_bytes_per_s__ * av->max_carry_s__;
+  if (max_carry < GNUNET_SERVER_MAX_MESSAGE_SIZE)
+    max_carry = GNUNET_SERVER_MAX_MESSAGE_SIZE;
+  left_bytes = max_carry + current_consumption;
+  /* left_bytes now contains the number of bytes needed until
+     we have more savings than allowed */
+  if (left_bytes < 0)
+  {
+    /* having excess already */
+    delay = GNUNET_TIME_UNIT_ZERO;
+  }
+  else
+  {
+    delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                           left_bytes);
+    delay = GNUNET_TIME_relative_divide (delay,
+                                         av->available_bytes_per_s__);
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != av->excess_task)
+    GNUNET_SCHEDULER_cancel (av->excess_task);
+  av->excess_task = GNUNET_SCHEDULER_add_delayed (delay,
+                                                  &excess_trigger,
+                                                  av);
+}
+
+
+/**
  * Initialize bandwidth tracker.  Note that in addition to the
  * 'max_carry_s' limit, we also always allow at least
- * GNUNET_SERVER_MAX_MESSAGE_SIZE to accumulate.  So if the
+ * #GNUNET_SERVER_MAX_MESSAGE_SIZE to accumulate.  So if the
  * bytes-per-second limit is so small that within 'max_carry_s' not
- * even GNUNET_SERVER_MAX_MESSAGE_SIZE is allowed to accumulate, it is
- * ignored and replaced by GNUNET_SERVER_MAX_MESSAGE_SIZE (which is in
+ * even #GNUNET_SERVER_MAX_MESSAGE_SIZE is allowed to accumulate, it is
+ * ignored and replaced by #GNUNET_SERVER_MAX_MESSAGE_SIZE (which is in
  * bytes).
  *
  * @param av tracker to initialize
@@ -137,13 +200,17 @@
  * @param bytes_per_second_limit initial limit to assume
  * @param max_carry_s maximum number of seconds unused bandwidth
  *        may accumulate before it expires
+ * @param excess_cb callback to notify if we have excess bandwidth
+ * @param excess_cb_cls closure for @a excess_cb
  */
 void
-GNUNET_BANDWIDTH_tracker_init (struct GNUNET_BANDWIDTH_Tracker *av,
-                               GNUNET_BANDWIDTH_tracker_update_cb update_cb,
-                               void *update_cb_cls,
-                               struct GNUNET_BANDWIDTH_Value32NBO
-                               bytes_per_second_limit, uint32_t max_carry_s)
+GNUNET_BANDWIDTH_tracker_init2 (struct GNUNET_BANDWIDTH_Tracker *av,
+                                GNUNET_BANDWIDTH_TrackerUpdateCallback 
update_cb,
+                                void *update_cb_cls,
+                                struct GNUNET_BANDWIDTH_Value32NBO 
bytes_per_second_limit,
+                                uint32_t max_carry_s,
+                                GNUNET_BANDWIDTH_ExcessNotificationCallback 
excess_cb,
+                                void *excess_cb_cls)
 {
   av->update_cb = update_cb;
   av->update_cb_cls = update_cb_cls;
@@ -151,13 +218,49 @@
   av->last_update__ = GNUNET_TIME_absolute_get ();
   av->available_bytes_per_s__ = ntohl (bytes_per_second_limit.value__);
   av->max_carry_s__ = max_carry_s;
+  av->excess_cb = excess_cb;
+  av->excess_cb_cls = excess_cb_cls;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Tracker %p initialized with %u Bps and max carry %u\n", av,
-       (unsigned int) av->available_bytes_per_s__, (unsigned int) max_carry_s);
+       "Tracker %p initialized with %u Bps and max carry %u\n",
+       av,
+       (unsigned int) av->available_bytes_per_s__,
+       (unsigned int) max_carry_s);
+  update_excess (av);
 }
 
 
 /**
+ * Initialize bandwidth tracker.  Note that in addition to the
+ * 'max_carry_s' limit, we also always allow at least
+ * GNUNET_SERVER_MAX_MESSAGE_SIZE to accumulate.  So if the
+ * bytes-per-second limit is so small that within 'max_carry_s' not
+ * even GNUNET_SERVER_MAX_MESSAGE_SIZE is allowed to accumulate, it is
+ * ignored and replaced by GNUNET_SERVER_MAX_MESSAGE_SIZE (which is in
+ * bytes).
+ *
+ * @param av tracker to initialize
+ * @param update_cb callback to notify a client about the tracker being updated
+ * @param update_cb_cls cls for the callback
+ * @param bytes_per_second_limit initial limit to assume
+ * @param max_carry_s maximum number of seconds unused bandwidth
+ *        may accumulate before it expires
+ */
+void
+GNUNET_BANDWIDTH_tracker_init (struct GNUNET_BANDWIDTH_Tracker *av,
+                               GNUNET_BANDWIDTH_TrackerUpdateCallback 
update_cb,
+                               void *update_cb_cls,
+                               struct GNUNET_BANDWIDTH_Value32NBO 
bytes_per_second_limit,
+                               uint32_t max_carry_s)
+{
+  GNUNET_BANDWIDTH_tracker_init2 (av, update_cb,
+                                  update_cb_cls,
+                                  bytes_per_second_limit,
+                                  max_carry_s,
+                                  NULL, NULL);
+}
+
+
+/**
  * Update the tracker, looking at the current time and
  * bandwidth consumption data.
  *
@@ -230,6 +333,7 @@
     }
     av->consumption_since_last_update__ = nc;
     update_tracker (av);
+    update_excess (av);
     if (av->consumption_since_last_update__ > 0)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -241,6 +345,7 @@
   else
   {
     av->consumption_since_last_update__ += size;
+    update_excess (av);
   }
   return GNUNET_NO;
 }
@@ -262,7 +367,7 @@
   struct GNUNET_TIME_Relative ret;
   int64_t bytes_needed;
 
-  if (av->available_bytes_per_s__ == 0)
+  if (0 == av->available_bytes_per_s__)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Tracker %p delay is infinity\n", av);
@@ -340,6 +445,7 @@
     av->update_cb (av->update_cb_cls);
   if (old_limit > new_limit)
     update_tracker (av);        /* maximum excess might be less now */
+  update_excess (av);
 }