X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fbandwidth.c;h=60cb50529f316d7a3dfcf085b286025cb6cb5fbb;hb=9b0414d6f98f33d7e1c33dafe105eb58da0bf79b;hp=aaf57619fa1f5b3b332bedb4dab5eb0738e26a6b;hpb=3caf199795bd1c7b475f9cb7941186ee4b66eaec;p=oweals%2Fgnunet.git diff --git a/src/util/bandwidth.c b/src/util/bandwidth.c index aaf57619f..60cb50529 100644 --- a/src/util/bandwidth.c +++ b/src/util/bandwidth.c @@ -20,12 +20,14 @@ /** * @file util/bandwidth.c - * @brief functions related to bandwidth (unit) + * @brief functions related to bandwidth (unit) * @author Christian Grothoff */ #include "platform.h" -#include "gnunet_bandwidth_lib.h" -#include "gnunet_server_lib.h" +#include "gnunet_util_lib.h" + + +#define LOG(kind,...) GNUNET_log_from (kind, "util-bandwidth", __VA_ARGS__) /** * Create a new bandwidth value. @@ -38,6 +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", + (unsigned int) bytes_per_second); ret.value__ = htonl (bytes_per_second); return ret; } @@ -52,10 +56,66 @@ GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second) */ struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1, - struct GNUNET_BANDWIDTH_Value32NBO b2) + struct GNUNET_BANDWIDTH_Value32NBO b2) +{ + return + GNUNET_BANDWIDTH_value_init (GNUNET_MIN + (ntohl (b1.value__), ntohl (b2.value__))); +} + + +/** + * At the given bandwidth, calculate how much traffic will be + * available until the given deadline. + * + * @param bps bandwidth + * @param deadline when is the deadline + * @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) +{ + uint64_t b; + + b = ntohl (bps.value__); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Bandwidth has %llu bytes available until deadline in %s\n", + (unsigned long long) ((b * deadline.rel_value + 500LL) / 1000LL), + GNUNET_STRINGS_relative_time_to_string (deadline, GNUNET_YES)); + return (b * deadline.rel_value + 500LL) / 1000LL; +} + + +/** + * At the given bandwidth, calculate how long it would take for + * 'size' bytes to be transmitted. + * + * @param bps bandwidth + * @param size number of bytes we want to have available + * @return how long it would take + */ +struct GNUNET_TIME_Relative +GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps, + uint64_t size) { - return GNUNET_BANDWIDTH_value_init (GNUNET_MIN (ntohl (b1.value__), - ntohl (b2.value__))); + uint64_t b; + struct GNUNET_TIME_Relative ret; + + b = ntohl (bps.value__); + if (b == 0) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Bandwidth suggests delay of infinity (zero bandwidth)\n"); + return GNUNET_TIME_UNIT_FOREVER_REL; + } + ret.rel_value = size * 1000LL / b; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Bandwidth suggests delay of %llu ms for %llu bytes of traffic\n", + (unsigned long long) ret.rel_value, (unsigned long long) size); + return ret; } @@ -75,13 +135,16 @@ GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1, */ void GNUNET_BANDWIDTH_tracker_init (struct GNUNET_BANDWIDTH_Tracker *av, - struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, - uint32_t max_carry_s) + struct GNUNET_BANDWIDTH_Value32NBO + bytes_per_second_limit, uint32_t max_carry_s) { 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; + 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); } @@ -95,47 +158,36 @@ static void update_tracker (struct GNUNET_BANDWIDTH_Tracker *av) { struct GNUNET_TIME_Absolute now; - uint64_t avail_per_ms; uint64_t delta_time; uint64_t delta_avail; uint64_t left_bytes; - uint64_t left_time_ms; + uint64_t max_carry; now = GNUNET_TIME_absolute_get (); - delta_time = now.value - av->last_update__.value; - delta_avail = (delta_time * ((unsigned long long) av->available_bytes_per_s__)) / 1000LL; - if (av->consumption_since_last_update__ >= delta_avail) - { - av->consumption_since_last_update__ -= delta_avail; - av->last_update__ = now; - } - else - { - left_bytes = delta_avail - av->consumption_since_last_update__; - avail_per_ms = ((unsigned long long) av->available_bytes_per_s__) / 1000LL; - if (avail_per_ms > 0) - left_time_ms = left_bytes / avail_per_ms; - else - left_time_ms = 0; - if (left_time_ms > ((unsigned long long) av->max_carry_s__) * 1000LL) - { - /* need to limit accumulation of unused bandwidth */ - left_time_ms = ((unsigned long long) av->max_carry_s__) * 1000LL; - if (left_time_ms * avail_per_ms < GNUNET_SERVER_MAX_MESSAGE_SIZE) - { - /* need to still allow GNUNET_SERVER_MAX_MESSAGE_SIZE accumulation */ - if (left_bytes > GNUNET_SERVER_MAX_MESSAGE_SIZE) - left_bytes = GNUNET_SERVER_MAX_MESSAGE_SIZE; - left_time_ms = left_bytes / avail_per_ms; - } - } - av->consumption_since_last_update__ = 0; - av->last_update__.value = now.value - left_time_ms; - } + delta_time = now.abs_value - av->last_update__.abs_value; + delta_avail = + (delta_time * ((unsigned long long) av->available_bytes_per_s__) + + 500LL) / 1000LL; + av->consumption_since_last_update__ -= delta_avail; + av->last_update__ = now; + if (av->consumption_since_last_update__ < 0) + { + left_bytes = -av->consumption_since_last_update__; + 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; + if (max_carry > left_bytes) + av->consumption_since_last_update__ = -left_bytes; + else + av->consumption_since_last_update__ = -max_carry; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Tracker %p updated, have %u Bps, last update was %llu ms ago\n", av, + (unsigned int) av->available_bytes_per_s__, + (unsigned long long) delta_time); } - /** * 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 @@ -145,21 +197,39 @@ update_tracker (struct GNUNET_BANDWIDTH_Tracker *av) * * @param av tracker to update * @param size number of bytes consumed + * @return GNUNET_YES if this consumption is above the limit */ -void +int GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av, - size_t size) + ssize_t size) { - uint64_t nc; + int64_t nc; - nc = av->consumption_since_last_update__ + size; - if (nc < av->consumption_since_last_update__) + LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p consumes %d bytes\n", av, + (int) size); + if (size > 0) + { + nc = av->consumption_since_last_update__ + size; + if (nc < av->consumption_since_last_update__) { GNUNET_break (0); - return; + return GNUNET_SYSERR; } - av->consumption_since_last_update__ += size; - update_tracker (av); + av->consumption_since_last_update__ = nc; + update_tracker (av); + if (av->consumption_since_last_update__ > 0) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Tracker %p consumption %llu bytes above limit\n", av, + (unsigned long long) av->consumption_since_last_update__); + return GNUNET_YES; + } + } + else + { + av->consumption_since_last_update__ += size; + } + return GNUNET_NO; } @@ -170,32 +240,65 @@ GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av, * * @param av tracker to query * @param size number of bytes we would like to consume - * @return time to wait for consumption to be OK + * @return time in ms to wait for consumption to be OK */ struct GNUNET_TIME_Relative GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av, - size_t size) + size_t size) { struct GNUNET_TIME_Relative ret; - struct GNUNET_TIME_Absolute now; - uint64_t delta_avail; - uint64_t delta_time; - uint64_t bytes_needed; + int64_t bytes_needed; if (av->available_bytes_per_s__ == 0) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay is infinity\n", av); return GNUNET_TIME_UNIT_FOREVER_REL; + } update_tracker (av); - now = GNUNET_TIME_absolute_get (); - delta_time = now.value - av->last_update__.value; - delta_avail = (delta_time * ((unsigned long long) av->available_bytes_per_s__)) / 1000LL; - if (delta_avail >= size) + bytes_needed = size + av->consumption_since_last_update__; + if (bytes_needed <= 0) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay for %u bytes is zero\n", av, + (unsigned int) size); return GNUNET_TIME_UNIT_ZERO; - bytes_needed = size - delta_avail; - ret.value = 1000LL * bytes_needed / (unsigned long long) av->available_bytes_per_s__; + } + ret.rel_value = + (1000LL * bytes_needed) / + (unsigned long long) av->available_bytes_per_s__; + LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay for %u bytes is %llu ms\n", + av, (unsigned int) size, (unsigned long long) ret.rel_value); return ret; } +/** + * Compute how many bytes are available for consumption right now. + * quota. + * + * @param av tracker to query + * @return number of bytes available for consumption right now + */ +int64_t +GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker * av) +{ + struct GNUNET_BANDWIDTH_Value32NBO bps; + uint64_t avail; + int64_t used; + + update_tracker (av); + bps = GNUNET_BANDWIDTH_value_init (av->available_bytes_per_s__); + avail = + GNUNET_BANDWIDTH_value_get_available_until (bps, + GNUNET_TIME_absolute_get_duration + (av->last_update__)); + used = av->consumption_since_last_update__; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Tracker %p available bandwidth is %lld bytes\n", av, + (long long) (int64_t) (avail - used)); + return (int64_t) (avail - used); +} + + /** * Update quota of bandwidth tracker. * @@ -204,17 +307,20 @@ GNUNET_BANDWIDTH_tracker_get_delay (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; new_limit = ntohl (bytes_per_second_limit.value__); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p bandwidth changed to %u Bps\n", av, + (unsigned int) new_limit); update_tracker (av); old_limit = av->available_bytes_per_s__; av->available_bytes_per_s__ = new_limit; if (old_limit > new_limit) - update_tracker (av); /* maximum excess might be less now */ + update_tracker (av); /* maximum excess might be less now */ }