X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fbandwidth.c;h=f056c1aeeb42b792634379c6c3fb9e4aa02e2055;hb=e34f367380ed951b51895e24d99a81a12899278c;hp=a3a46a7cafc9181f62383039e3ab0c5a9aefebd3;hpb=0d2a606bdb2375d283be00d18d73f3eae8b06e4c;p=oweals%2Fgnunet.git diff --git a/src/util/bandwidth.c b/src/util/bandwidth.c index a3a46a7ca..f056c1aee 100644 --- a/src/util/bandwidth.c +++ b/src/util/bandwidth.c @@ -1,10 +1,10 @@ /* This file is part of GNUnet. - (C) 2010 Christian Grothoff (and other contributing authors) + (C) 2010, 2013 Christian Grothoff (and other contributing authors) GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 2, or (at your + by the Free Software Foundation; either version 3, or (at your option) any later version. GNUnet is distributed in the hope that it will be useful, but @@ -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_NO + +#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_us + 500000LL) / 1000000LL), + GNUNET_STRINGS_relative_time_to_string (deadline, GNUNET_YES)); + return (b * deadline.rel_value_us + 500000LL) / 1000000LL; } @@ -101,31 +99,28 @@ 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 + if (0 == b) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Bandwidth suggests delay of infinity (zero bandwidth)\n"); + return GNUNET_TIME_UNIT_FOREVER_REL; + } + ret.rel_value_us = size * 1000LL * 1000LL / b; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Bandwidth suggests delay of %s for %llu bytes of traffic\n", + GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES), + (unsigned long long) size); return ret; } + /** * Initialize bandwidth tracker. Note that in addition to the * 'max_carry_s' limit, we also always allow at least @@ -136,26 +131,28 @@ GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps, * 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, - struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, - uint32_t max_carry_s) + GNUNET_BANDWIDTH_tracker_update_cb update_cb, + void *update_cb_cls, + struct GNUNET_BANDWIDTH_Value32NBO + bytes_per_second_limit, uint32_t max_carry_s) { + 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; -#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 +166,35 @@ static void update_tracker (struct GNUNET_BANDWIDTH_Tracker *av) { struct GNUNET_TIME_Absolute now; - uint64_t avail_per_ms; + struct GNUNET_TIME_Relative delta; 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_us - av->last_update__.abs_value_us; + delta_avail = + (delta_time * ((unsigned long long) av->available_bytes_per_s__) + + 500000LL) / 1000000LL; + 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; + } + delta.rel_value_us = delta_time; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Tracker %p updated, have %u Bps, last update was %s ago\n", av, + (unsigned int) av->available_bytes_per_s__, + GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES)); } @@ -233,42 +211,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 +250,37 @@ 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_us = + (1000LL * 1000LL * bytes_needed) / + (unsigned long long) av->available_bytes_per_s__; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Tracker %p delay for %u bytes is %s\n", + av, (unsigned int) size, + GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES)); return ret; } @@ -335,24 +292,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 +321,23 @@ 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 (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_tracker (av); /* maximum excess might be less now */ }