GNUnet  0.17.6
Macros | Functions
bandwidth.c File Reference

functions related to bandwidth (unit) More...

#include "platform.h"
#include "gnunet_util_lib.h"
Include dependency graph for bandwidth.c:

Go to the source code of this file.

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "util-bandwidth", __VA_ARGS__)
 

Functions

struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second)
 Create a new bandwidth value. More...
 
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2)
 Compute the MIN of two bandwidth values. More...
 
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_max (struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2)
 Compute the MAX of two bandwidth values. More...
 
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_sum (struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2)
 Compute the SUM of two bandwidth values. More...
 
uint64_t GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO bps, struct GNUNET_TIME_Relative deadline)
 At the given bandwidth, calculate how much traffic will be available until the given deadline. More...
 
struct GNUNET_TIME_Relative GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps, uint64_t size)
 At the given bandwidth, calculate how long it would take for size bytes to be transmitted. More...
 
static void excess_trigger (void *cls)
 Task run whenever we hit the bandwidth limit for a tracker. More...
 
static void update_excess (struct GNUNET_BANDWIDTH_Tracker *av)
 Recalculate when we might need to call the excess callback. More...
 
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)
 Initialize bandwidth tracker. More...
 
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)
 Initialize bandwidth tracker. More...
 
void GNUNET_BANDWIDTH_tracker_notification_stop (struct GNUNET_BANDWIDTH_Tracker *av)
 Stop notifying about tracker updates and excess notifications. More...
 
static void update_tracker (struct GNUNET_BANDWIDTH_Tracker *av)
 Update the tracker, looking at the current time and bandwidth consumption data. More...
 
int GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av, ssize_t size)
 Notify the tracker that a certain number of bytes of bandwidth have been consumed. More...
 
struct GNUNET_TIME_Relative GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av, size_t size)
 Compute how long we should wait until consuming 'size' bytes of bandwidth in order to stay within the given quota. More...
 
int64_t GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker *av)
 Compute how many bytes are available for consumption right now. More...
 
void GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av, struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit)
 Update quota of bandwidth tracker. More...
 

Detailed Description

functions related to bandwidth (unit)

Author
Christian Grothoff

Definition in file bandwidth.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "util-bandwidth", __VA_ARGS__)

Definition at line 30 of file bandwidth.c.

Function Documentation

◆ excess_trigger()

static void excess_trigger ( void *  cls)
static

Task run whenever we hit the bandwidth limit for a tracker.

Parameters
clsthe struct GNUNET_BANDWIDTH_Tracker

Definition at line 149 of file bandwidth.c.

150 {
151  struct GNUNET_BANDWIDTH_Tracker *av = cls;
152 
153  av->excess_task = NULL;
154  if (NULL != av->excess_cb)
155  {
157  "Notifying application about excess bandwidth\n");
158  av->excess_cb (av->excess_cb_cls);
159  }
160 }
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG
Struct to track available bandwidth.
struct GNUNET_SCHEDULER_Task * excess_task
Task scheduled to call the excess_cb once we have reached the maximum bandwidth the tracker can hold.
GNUNET_BANDWIDTH_ExcessNotificationCallback excess_cb
Function we call if the tracker is about to throw away bandwidth due to excess (max carry exceeded).
void * excess_cb_cls
Closure for excess_cb.

References GNUNET_BANDWIDTH_Tracker::excess_cb, GNUNET_BANDWIDTH_Tracker::excess_cb_cls, GNUNET_BANDWIDTH_Tracker::excess_task, GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by update_excess().

Here is the caller graph for this function:

◆ update_excess()

static void update_excess ( struct GNUNET_BANDWIDTH_Tracker av)
static

Recalculate when we might need to call the excess callback.

Definition at line 167 of file bandwidth.c.

168 {
170  struct GNUNET_TIME_Absolute now;
171  uint64_t delta_time;
172  uint64_t delta_avail;
173  int64_t left_bytes;
174  uint64_t max_carry;
175  int64_t current_consumption;
176 
177  if (NULL == av->excess_cb)
178  return; /* nothing to do */
179  now = GNUNET_TIME_absolute_get ();
180  delta_time = now.abs_value_us - av->last_update__.abs_value_us;
181  delta_avail =
182  (delta_time * ((unsigned long long) av->available_bytes_per_s__)
183  + 500000LL)
184  / 1000000LL;
185  current_consumption = av->consumption_since_last_update__ - delta_avail;
186  if (current_consumption > av->consumption_since_last_update__)
187  {
188  /* integer underflow, cap! */
189  current_consumption = INT64_MIN;
190  }
191  /* negative current_consumption means that we have savings */
192  max_carry = ((uint64_t) av->available_bytes_per_s__) * av->max_carry_s__;
193  if (max_carry < GNUNET_MAX_MESSAGE_SIZE)
194  max_carry = GNUNET_MAX_MESSAGE_SIZE;
195  if (max_carry > INT64_MAX)
196  max_carry = INT64_MAX;
197  left_bytes = current_consumption + max_carry;
198  if (left_bytes < current_consumption)
199  {
200  /* integer overflow, cap! */
201  left_bytes = INT64_MAX;
202  }
203  /* left_bytes now contains the number of bytes needed until
204  we have more savings than allowed */
205  if (left_bytes < 0)
206  {
207  /* having excess already */
209  }
210  else
211  {
212  double factor = 1.0 * left_bytes / (double) av->available_bytes_per_s__;
213  delay =
215  (unsigned long long) factor);
216  }
217  GNUNET_log (
219  "At %llu bps it will take us %s for %lld bytes to reach excess threshold\n",
220  (unsigned long long) av->available_bytes_per_s__,
222  (long long) left_bytes);
223  if (NULL != av->excess_task)
226 }
static void excess_trigger(void *cls)
Task run whenever we hit the bandwidth limit for a tracker.
Definition: bandwidth.c:149
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
@ GNUNET_NO
Definition: gnunet_common.h:98
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1254
struct GNUNET_TIME_Relative GNUNET_TIME_relative_saturating_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Saturating multiply relative time by a given factor.
Definition: time.c:530
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:110
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:570
int64_t consumption_since_last_update__
Number of bytes consumed since we last updated the tracker.
struct GNUNET_TIME_Absolute last_update__
Time when we last updated the tracker.
uint32_t available_bytes_per_s__
Bandwidth limit to enforce in bytes per second.
uint32_t max_carry_s__
Maximum number of seconds over which bandwidth may "accumulate".
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_BANDWIDTH_Tracker::available_bytes_per_s__, GNUNET_BANDWIDTH_Tracker::consumption_since_last_update__, delay, GNUNET_BANDWIDTH_Tracker::excess_cb, GNUNET_BANDWIDTH_Tracker::excess_task, excess_trigger(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_saturating_multiply(), GNUNET_TIME_UNIT_SECONDS, GNUNET_TIME_UNIT_ZERO, GNUNET_BANDWIDTH_Tracker::last_update__, and GNUNET_BANDWIDTH_Tracker::max_carry_s__.

Referenced by GNUNET_BANDWIDTH_tracker_consume(), GNUNET_BANDWIDTH_tracker_init2(), and GNUNET_BANDWIDTH_tracker_update_quota().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ update_tracker()

static void update_tracker ( struct GNUNET_BANDWIDTH_Tracker av)
static

Update the tracker, looking at the current time and bandwidth consumption data.

Parameters
avtracker to update

Definition at line 320 of file bandwidth.c.

321 {
322  struct GNUNET_TIME_Absolute now;
323  uint64_t delta_time;
324  uint64_t delta_avail;
325  uint64_t left_bytes;
326  uint64_t max_carry;
327 
328  now = GNUNET_TIME_absolute_get ();
329  delta_time = now.abs_value_us - av->last_update__.abs_value_us;
330  delta_avail =
331  (delta_time * ((unsigned long long) av->available_bytes_per_s__)
332  + 500000LL)
333  / 1000000LL;
334  av->consumption_since_last_update__ -= delta_avail;
335  av->last_update__ = now;
337  {
338  left_bytes = -av->consumption_since_last_update__;
339  max_carry =
340  ((unsigned long long) av->available_bytes_per_s__) * av->max_carry_s__;
341  if (max_carry < GNUNET_MAX_MESSAGE_SIZE)
342  max_carry = GNUNET_MAX_MESSAGE_SIZE;
343  if (max_carry > INT64_MAX)
344  max_carry = INT64_MAX;
345  if (max_carry > left_bytes)
346  av->consumption_since_last_update__ = -left_bytes;
347  else
348  av->consumption_since_last_update__ = -max_carry;
349  }
350 #if ! defined(GNUNET_CULL_LOGGING)
351  {
353 
354  delta.rel_value_us = delta_time;
356  "Tracker %p updated, consumption at %lld at %u Bps, last update was %s ago\n",
357  av,
358  (long long) av->consumption_since_last_update__,
359  (unsigned int) av->available_bytes_per_s__,
361  }
362 #endif
363 }
#define LOG(kind,...)
Definition: bandwidth.c:30
@ GNUNET_YES
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
uint64_t rel_value_us
The actual value.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_BANDWIDTH_Tracker::available_bytes_per_s__, GNUNET_BANDWIDTH_Tracker::consumption_since_last_update__, delta, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MAX_MESSAGE_SIZE, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_YES, GNUNET_BANDWIDTH_Tracker::last_update__, LOG, GNUNET_BANDWIDTH_Tracker::max_carry_s__, and GNUNET_TIME_Relative::rel_value_us.

Referenced by GNUNET_BANDWIDTH_tracker_consume(), GNUNET_BANDWIDTH_tracker_get_available(), and GNUNET_BANDWIDTH_tracker_update_quota().

Here is the call graph for this function:
Here is the caller graph for this function: