/**
* Compute how long we should wait until consuming 'size'
* bytes of bandwidth in order to stay within the given
* quota.
*
* @param av tracker to query
* @param size number of bytes we would like to consume
* @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)
{
struct GNUNET_TIME_Relative ret;
int64_t bytes_needed;
if (0 == av->available_bytes_per_s__)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Tracker %p delay is infinity\n", av);
return GNUNET_TIME_UNIT_FOREVER_REL;
}
update_tracker (av);
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;
}
/**
* 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
* enough bandwidth is available (in that case,
* GNUNET_BANDWIDTH_tracker_get_delay may return non-zero delay values
* even for a size of zero for a while).
*
* @param av tracker to update
* @param size number of bytes consumed
* @return GNUNET_YES if this consumption is above the limit
*/
int
GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av,
ssize_t size)
{
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__)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
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;
}
void download(){
/***1.we need to where our file's tracker should be stored***/
query();
//printf("Step 1 finished\n");
if(rep_flag==0){
/***2.we need to query from chord to get tracker information***/
get_tracker();
//printf("Step 2 finished\n");
//debug_info();
/***3.contact to the peers to get different pieces***/
request_pieces();
//printf("Step 3 finished\n");
/***4.combine different pieces to a whole***/
combine_pieces();
//printf("Step 4 finished\n");
/***5.update tracker information***/
update_tracker();
//printf("Step 5 finished\n");
}
else{
printf("You have already downloaded this file. You don't need to download it again!\n");
}
/***6.garbage collection***/
reset();
//printf("Step 6 finished\n");
}
/**
* Update quota of bandwidth tracker.
*
* @param av tracker to initialize
* @param bytes_per_second_limit new limit to assume
*/
void
GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av,
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 */
}
/**
* 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);
}
bool
SkinMeme::track_to_target(CWpt& target, Wpt& near_pt)
{
// Do a local search to find the closest point to 'target' on the
// tracked surface. Do the search starting from our own track
// simplex, and then repeat the search starting from each track
// simplex that can be borrowed from our SkinMeme neighbors. In the
// end take the one that yielded the closest result, and store the
// corresponding track simplex.
if (is_frozen())
return is_tracking();
Wvec near_bc;
Bsimplex* track_sim = update_tracker(
target, get_local_trackers(), near_pt, near_bc
);
// Record the result, even if unsuccessful:
set(track_sim, near_bc);
return (track_simplex() != 0);
}
