From 0bd6576cde9008ff4b83892a5fa160e0dbd143bf Mon Sep 17 00:00:00 2001 From: hniksic Date: Fri, 7 Nov 2003 20:55:44 -0800 Subject: [PATCH] [svn] Timer code update. --- src/ChangeLog | 8 ++++++++ src/convert.c | 3 ++- src/retr.c | 32 ++++++++++++++------------------ src/utils.c | 39 ++++++++++++++++++++++++++++++--------- src/utils.h | 3 ++- 5 files changed, 56 insertions(+), 29 deletions(-) diff --git a/src/ChangeLog b/src/ChangeLog index c305d991..40415df8 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,11 @@ +2003-11-08 Hrvoje Niksic + + * retr.c (get_contents): Pass the timer to limit_bandwidth(). + + * utils.c (wtimer_update): New function instead of wget_elapsed; + just update the timer, but don't return anything. + (wtimer_read): Read and return the last known value of the timer. + 2003-11-08 Hrvoje Niksic * http.c (persistent_available_p): Instead of matching all the diff --git a/src/convert.c b/src/convert.c index d3e85ae8..ca9e36b8 100644 --- a/src/convert.c +++ b/src/convert.c @@ -166,7 +166,8 @@ convert_all_links (void) free_urlpos (urls); } - msecs = wtimer_elapsed (timer); + wtimer_update (timer); + msecs = wtimer_read (timer); wtimer_delete (timer); logprintf (LOG_VERBOSE, _("Converted %d files in %.2f seconds.\n"), file_count, (double)msecs / 1000); diff --git a/src/retr.c b/src/retr.c index db8b1c18..5e4212f8 100644 --- a/src/retr.c +++ b/src/retr.c @@ -84,13 +84,13 @@ limit_bandwidth_reset (void) } /* Limit the bandwidth by pausing the download for an amount of time. - BYTES is the number of bytes received from the network, and DELTA - is the number of milliseconds it took to receive them. */ + BYTES is the number of bytes received from the network, and TIMER + is the timer that started at the beginning of download. */ static void -limit_bandwidth (long bytes, double *dltime, struct wget_timer *timer) +limit_bandwidth (long bytes, struct wget_timer *timer) { - double delta_t = *dltime - limit_data.chunk_start; + double delta_t = wtimer_read (timer) - limit_data.chunk_start; double expected; limit_data.chunk_bytes += bytes; @@ -113,23 +113,20 @@ limit_bandwidth (long bytes, double *dltime, struct wget_timer *timer) DEBUGP (("\nsleeping %.2f ms for %ld bytes, adjust %.2f ms\n", slp, limit_data.chunk_bytes, limit_data.sleep_adjust)); - t0 = *dltime; + t0 = wtimer_read (timer); xsleep (slp / 1000); - t1 = wtimer_elapsed (timer); + wtimer_update (timer); + t1 = wtimer_read (timer); /* Due to scheduling, we probably slept slightly longer (or shorter) than desired. Calculate the difference between the desired and the actual sleep, and adjust the next sleep by that amount. */ limit_data.sleep_adjust = slp - (t1 - t0); - - /* Since we've called wtimer_elapsed, we might as well update - the caller's dltime. */ - *dltime = t1; } limit_data.chunk_bytes = 0; - limit_data.chunk_start = *dltime; + limit_data.chunk_start = wtimer_read (timer); } #define MIN(i, j) ((i) <= (j) ? (i) : (j)) @@ -166,7 +163,6 @@ get_contents (int fd, FILE *fp, long *len, long restval, long expected, void *progress = NULL; struct wget_timer *timer = wtimer_allocate (); - double dltime = 0; *len = restval; @@ -222,7 +218,7 @@ get_contents (int fd, FILE *fp, long *len, long restval, long expected, /* Always flush the contents of the network packet. This should not hinder performance: fast downloads will be received in 16K chunks (which stdio would write out anyway), and slow - downloads won't be limited with disk performance. */ + downloads won't be limited by disk performance. */ fflush (fp); if (ferror (fp)) { @@ -230,13 +226,13 @@ get_contents (int fd, FILE *fp, long *len, long restval, long expected, goto out; } - dltime = wtimer_elapsed (timer); + wtimer_update (timer); if (opt.limit_rate) - limit_bandwidth (res, &dltime, timer); + limit_bandwidth (res, timer); *len += res; if (progress) - progress_update (progress, res, dltime); + progress_update (progress, res, wtimer_read (timer)); #ifdef WINDOWS if (use_expected && expected > 0) ws_percenttitle (100.0 * (double)(*len) / (double)expected); @@ -247,9 +243,9 @@ get_contents (int fd, FILE *fp, long *len, long restval, long expected, out: if (progress) - progress_finish (progress, dltime); + progress_finish (progress, wtimer_read (timer)); if (elapsed) - *elapsed = dltime; + *elapsed = wtimer_read (timer); wtimer_delete (timer); return res; diff --git a/src/utils.c b/src/utils.c index 5f99fa7e..1559b279 100644 --- a/src/utils.c +++ b/src/utils.c @@ -1395,8 +1395,11 @@ wtimer_sys_set (wget_sys_time *wst) } /* Reset timer WT. This establishes the starting point from which - wtimer_elapsed() will return the number of elapsed - milliseconds. It is allowed to reset a previously used timer. */ + wtimer_elapsed() will return the number of elapsed milliseconds. + It is allowed to reset a previously used timer. + + If a non-zero value is used as START, the timer's values will be + offset by START. */ void wtimer_reset (struct wget_timer *wt) @@ -1427,13 +1430,16 @@ wtimer_sys_diff (wget_sys_time *wst1, wget_sys_time *wst2) #endif } -/* Return the number of milliseconds elapsed since the timer was last - reset. It is allowed to call this function more than once to get - increasingly higher elapsed values. These timers handle clock - skew. */ +/* Update the timer's elapsed interval. This function causes the + timer to call gettimeofday (or time(), etc.) to update its idea of + current time. To get the elapsed interval in milliseconds, use + wtimer_read. -double -wtimer_elapsed (struct wget_timer *wt) + This function handles clock skew, i.e. time that moves backwards is + ignored. */ + +void +wtimer_update (struct wget_timer *wt) { wget_sys_time now; double elapsed; @@ -1462,7 +1468,22 @@ wtimer_elapsed (struct wget_timer *wt) } wt->elapsed_last = elapsed; - return elapsed; +} + +/* Return the elapsed time in milliseconds between the last call to + wtimer_reset and the last call to wtimer_update. + + A typical use of the timer interface would be: + + struct wtimer *timer = wtimer_new (); + ... do something that takes a while ... + wtimer_update (); + double msecs = wtimer_read (); */ + +double +wtimer_read (const struct wget_timer *wt) +{ + return wt->elapsed_last; } /* Return the assessed granularity of the timer implementation, in diff --git a/src/utils.h b/src/utils.h index 972d5502..28976ff5 100644 --- a/src/utils.h +++ b/src/utils.h @@ -111,7 +111,8 @@ struct wget_timer *wtimer_allocate PARAMS ((void)); struct wget_timer *wtimer_new PARAMS ((void)); void wtimer_delete PARAMS ((struct wget_timer *)); void wtimer_reset PARAMS ((struct wget_timer *)); -double wtimer_elapsed PARAMS ((struct wget_timer *)); +void wtimer_update PARAMS ((struct wget_timer *)); +double wtimer_read PARAMS ((const struct wget_timer *)); double wtimer_granularity PARAMS ((void)); char *html_quote_string PARAMS ((const char *)); -- 2.39.2