* @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);
/**
* 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.
*/
* @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);
/**
*/
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
* @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;
}
+/**
+ * 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
* @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;
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);
}
}
av->consumption_since_last_update__ = nc;
update_tracker (av);
+ update_excess (av);
if (av->consumption_since_last_update__ > 0)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
else
{
av->consumption_since_last_update__ += size;
+ update_excess (av);
}
return GNUNET_NO;
}
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);
av->update_cb (av->update_cb_cls);
if (old_limit > new_limit)
update_tracker (av); /* maximum excess might be less now */
+ update_excess (av);
}