X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fbandwidth.c;h=2a1a4011b8a23f44de2098f0e3b7feca99c9012a;hb=3248c18dfb21f2400d7ccfef45cf962d35f6638f;hp=79497ad5137cf5034d35493db931fe01a78416d7;hpb=61c39c60565b386e0e12ea669556b030e8cd7180;p=oweals%2Fgnunet.git

diff --git a/src/util/bandwidth.c b/src/util/bandwidth.c
index 79497ad51..2a1a4011b 100644
--- a/src/util/bandwidth.c
+++ b/src/util/bandwidth.c
@@ -40,7 +40,8 @@ GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second)
 {
   struct GNUNET_BANDWIDTH_Value32NBO ret;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Initializing bandwidth of %u Bps\n",
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Initializing bandwidth of %u Bps\n",
        (unsigned int) bytes_per_second);
   ret.value__ = htonl (bytes_per_second);
   return ret;
@@ -73,10 +74,8 @@ GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1,
  * @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;
 
@@ -91,7 +90,7 @@ GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO
 
 /**
  * At the given bandwidth, calculate how long it would take for
- * 'size' bytes to be transmitted.
+ * @a size bytes to be transmitted.
  *
  * @param bps bandwidth
  * @param size number of bytes we want to have available
@@ -120,35 +119,168 @@ GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps,
 }
 
 
+/**
+ * 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;
+
+  if (NULL != av->excess_cb)
+    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
+ * @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
+ * @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,
-                               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;
   av->consumption_since_last_update__ = 0;
   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);
 }
 
 
+/**
+ * Stop notifying about tracker updates and excess notifications
+ *
+ * @param av the respective trackers
+ */
+void
+GNUNET_BANDWIDTH_tracker_notification_stop (struct GNUNET_BANDWIDTH_Tracker *av)
+{
+  if (GNUNET_SCHEDULER_NO_TASK != av->excess_task)
+    GNUNET_SCHEDULER_cancel (av->excess_task);
+  av->excess_task = GNUNET_SCHEDULER_NO_TASK;
+  av->excess_cb = NULL;
+  av->excess_cb_cls = NULL;
+  av->update_cb = NULL;
+  av->update_cb_cls = NULL;
+}
+
+
+
 /**
  * Update the tracker, looking at the current time and
  * bandwidth consumption data.
@@ -195,12 +327,12 @@ update_tracker (struct GNUNET_BANDWIDTH_Tracker *av)
  * 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,
- * GNUNET_BANDWIDTH_tracker_get_delay may return non-zero delay values
+ * #GNUNET_BANDWIDTH_tracker_get_delay may return non-zero delay values
  * even for a size of zero for a while).
  *
  * @param av tracker to update
  * @param size number of bytes consumed
- * @return GNUNET_YES if this consumption is above the limit
+ * @return #GNUNET_YES if this consumption is above the limit
  */
 int
 GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
@@ -208,7 +340,9 @@ GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
 {
   int64_t nc;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p consumes %d bytes\n", av,
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Tracker %p consumes %d bytes\n",
+       av,
        (int) size);
   if (size > 0)
   {
@@ -220,6 +354,7 @@ GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
     }
     av->consumption_since_last_update__ = nc;
     update_tracker (av);
+    update_excess (av);
     if (av->consumption_since_last_update__ > 0)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -231,6 +366,7 @@ GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
   else
   {
     av->consumption_since_last_update__ += size;
+    update_excess (av);
   }
   return GNUNET_NO;
 }
@@ -252,7 +388,7 @@ GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av,
   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);
@@ -286,7 +422,7 @@ GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av,
  * @return number of bytes available for consumption right now
  */
 int64_t
-GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker * av)
+GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker *av)
 {
   struct GNUNET_BANDWIDTH_Value32NBO bps;
   uint64_t avail;
@@ -314,8 +450,7 @@ GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker * av)
  */
 void
 GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av,
-                                       struct GNUNET_BANDWIDTH_Value32NBO
-                                       bytes_per_second_limit)
+                                       struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit)
 {
   uint32_t old_limit;
   uint32_t new_limit;
@@ -327,8 +462,11 @@ GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av,
   update_tracker (av);
   old_limit = av->available_bytes_per_s__;
   av->available_bytes_per_s__ = new_limit;
+  if (NULL != av->update_cb)
+    av->update_cb (av->update_cb_cls);
   if (old_limit > new_limit)
     update_tracker (av);        /* maximum excess might be less now */
+  update_excess (av);
 }