X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fbandwidth.c;h=60cb50529f316d7a3dfcf085b286025cb6cb5fbb;hb=72c8645af31896829b674b575c5375706f362a30;hp=9ba6bd5ec018a8eea25ae76dcff096d9588acf78;hpb=ca1869a6d9604fb4c4a55b908a28898bd2b4e9f2;p=oweals%2Fgnunet.git diff --git a/src/util/bandwidth.c b/src/util/bandwidth.c index 9ba6bd5ec..60cb50529 100644 --- a/src/util/bandwidth.c +++ b/src/util/bandwidth.c @@ -20,14 +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 DEBUG_BANDWIDTH GNUNET_YES + +#define LOG(kind,...) GNUNET_log_from (kind, "util-bandwidth", __VA_ARGS__) /** * Create a new bandwidth value. @@ -40,11 +40,8 @@ GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second) { struct GNUNET_BANDWIDTH_Value32NBO ret; -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Initializing bandwidth of %u bps\n", - (unsigned int) bytes_per_second); -#endif + LOG (GNUNET_ERROR_TYPE_DEBUG, "Initializing bandwidth of %u Bps\n", + (unsigned int) bytes_per_second); ret.value__ = htonl (bytes_per_second); return ret; } @@ -59,10 +56,11 @@ 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__))); + return + GNUNET_BANDWIDTH_value_init (GNUNET_MIN + (ntohl (b1.value__), ntohl (b2.value__))); } @@ -74,20 +72,20 @@ GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1, * @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 +GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO + bps, + struct GNUNET_TIME_Relative + deadline) { uint64_t b; b = ntohl (bps.value__); -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Bandwidth has %llu bytes available until deadline in %llums\n", - (unsigned long long) ((b * deadline.value + 500LL) / 1000LL), - deadline.value); -#endif - return (b * deadline.value + 500LL) / 1000LL; + 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; } @@ -101,27 +99,22 @@ GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO b */ struct GNUNET_TIME_Relative GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps, - uint64_t size) + uint64_t size) { uint64_t b; struct GNUNET_TIME_Relative ret; b = ntohl (bps.value__); if (b == 0) - { -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Bandwidth suggests delay of infinity (zero bandwidth)\n"); -#endif - return GNUNET_TIME_UNIT_FOREVER_REL; - } - ret.value = size * 1000LL / b; -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Bandwidth suggests delay of %llu ms for %llu bytes of traffic\n", - (unsigned long long) ret.value, - (unsigned long long) size); -#endif + { + 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; } @@ -142,20 +135,16 @@ GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps, */ 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; -#if DEBUG_BANDWIDTH - GNUNET_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); -#endif + 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); } @@ -169,54 +158,33 @@ 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__) + 500LL) / 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__ + 500LL) / 1000LL; - if (avail_per_ms > 0) - { - left_time_ms = left_bytes / avail_per_ms; - 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; - } - } - } - else - { - left_time_ms = 0; - } - av->consumption_since_last_update__ = 0; - av->last_update__.value = now.value - left_time_ms; - } -#if DEBUG_BANDWIDTH - GNUNET_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) (now.value - av->last_update__.value)); -#endif + 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); } @@ -233,42 +201,34 @@ update_tracker (struct GNUNET_BANDWIDTH_Tracker *av) */ int GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av, - ssize_t size) + ssize_t size) { - uint64_t nc; - -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p consumes %d bytes\n", - av, - (int) size); -#endif + int64_t nc; + + 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__) { - nc = av->consumption_since_last_update__ + size; - if (nc < av->consumption_since_last_update__) - { - GNUNET_break (0); - return GNUNET_SYSERR; - } - av->consumption_since_last_update__ = nc; - update_tracker (av); - if (av->consumption_since_last_update__ > 0) - { -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p consumption %llu bytes above limit\n", - av, - (unsigned long long) av->consumption_since_last_update__); -#endif - return GNUNET_YES; - } + GNUNET_break (0); + return GNUNET_SYSERR; } - else + av->consumption_since_last_update__ = nc; + update_tracker (av); + if (av->consumption_since_last_update__ > 0) { - av->last_update__.value -= (size * av->available_bytes_per_s__ + 500LL) / 1000LL; - update_tracker (av); + 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; } @@ -280,50 +240,33 @@ 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) - { -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p delay is infinity\n", - av); -#endif - return GNUNET_TIME_UNIT_FOREVER_REL; - } + { + 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__) + 500LL) / 1000LL; - if (delta_avail >= size) - { -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p delay for %u bytes is zero\n", - av, - (unsigned int) size); -#endif - return GNUNET_TIME_UNIT_ZERO; - } - bytes_needed = size - delta_avail; - ret.value = 1000LL * bytes_needed / (unsigned long long) av->available_bytes_per_s__; -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p delay for %u bytes is %llu ms\n", - av, - (unsigned int) size, - (unsigned long long) ret.value); -#endif + 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; + } + 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; } @@ -335,24 +278,23 @@ GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av, * @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) +int64_t +GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker * av) { struct GNUNET_BANDWIDTH_Value32NBO bps; uint64_t avail; - uint64_t used; + 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__)); + avail = + GNUNET_BANDWIDTH_value_get_available_until (bps, + GNUNET_TIME_absolute_get_duration + (av->last_update__)); used = av->consumption_since_last_update__; -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p available bandwith is %lld ms\n", - av, - (long long) (int64_t) (avail - used)); -#endif + 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); } @@ -365,23 +307,20 @@ 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; new_limit = ntohl (bytes_per_second_limit.value__); -#if DEBUG_BANDWIDTH - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p bandwith changed to %u bps\n", - av, - (unsigned int) new_limit); -#endif + 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 */ }