progress: simplify performance measurement by using getnanotime()

Calculating duration from a single uint64_t is simpler than from a struct
timeval. Change throughput measurement from gettimeofday() to
getnanotime().

Also calculate misec only if needed, and change integer division to integer
multiplication + shift, which should be slightly faster.

Signed-off-by: Karsten Blees <blees@dcon.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/progress.c b/progress.c
index 261314ef3cd60662300129df98afff7ea2a1673c..412e6b1ecc36e8bd8b7f090b7da3dcf0c7e4e5bd 100644 (file)
--- a/progress.c
+++ b/progress.c
@@ -12,13 +12,14 @@
 #include "gettext.h"
 #include "progress.h"
 #include "strbuf.h"
 #include "gettext.h"
 #include "progress.h"
 #include "strbuf.h"

+#include "trace.h"

 
 #define TP_IDX_MAX      8
 
 struct throughput {
        off_t curr_total;
        off_t prev_total;
 
 #define TP_IDX_MAX      8
 
 struct throughput {
        off_t curr_total;
        off_t prev_total;

-       struct timeval prev_tv;
+       uint64_t prev_ns;

        unsigned int avg_bytes;
        unsigned int avg_misecs;
        unsigned int last_bytes[TP_IDX_MAX];
        unsigned int avg_bytes;
        unsigned int avg_misecs;
        unsigned int last_bytes[TP_IDX_MAX];


@@ -127,65 +128,65 @@ static void throughput_string(struct strbuf *buf, off_t total,
 void display_throughput(struct progress *progress, off_t total)
 {
        struct throughput *tp;
 void display_throughput(struct progress *progress, off_t total)
 {
        struct throughput *tp;

-       struct timeval tv;
-       unsigned int misecs;
+       uint64_t now_ns;
+       unsigned int misecs, count, rate;
+       struct strbuf buf = STRBUF_INIT;

 
        if (!progress)
                return;
        tp = progress->throughput;
 
 
        if (!progress)
                return;
        tp = progress->throughput;
 

-       gettimeofday(&tv, NULL);
+       now_ns = getnanotime();

 
        if (!tp) {
                progress->throughput = tp = calloc(1, sizeof(*tp));
                if (tp) {
                        tp->prev_total = tp->curr_total = total;
 
        if (!tp) {
                progress->throughput = tp = calloc(1, sizeof(*tp));
                if (tp) {
                        tp->prev_total = tp->curr_total = total;

-                       tp->prev_tv = tv;
+                       tp->prev_ns = now_ns;

                }
                return;
        }
        tp->curr_total = total;
 
                }
                return;
        }
        tp->curr_total = total;
 

+       /* only update throughput every 0.5 s */
+       if (now_ns - tp->prev_ns <= 500000000)
+               return;
+

        /*
        /*

-        * We have x = bytes and y = microsecs.  We want z = KiB/s:
+        * We have x = bytes and y = nanosecs.  We want z = KiB/s:

         *
         *

-        *      z = (x / 1024) / (y / 1000000)
-        *      z = x / y * 1000000 / 1024
-        *      z = x / (y * 1024 / 1000000)
+        *      z = (x / 1024) / (y / 1000000000)
+        *      z = x / y * 1000000000 / 1024
+        *      z = x / (y * 1024 / 1000000000)

         *      z = x / y'
         *
         * To simplify things we'll keep track of misecs, or 1024th of a sec
         * obtained with:
         *
         *      z = x / y'
         *
         * To simplify things we'll keep track of misecs, or 1024th of a sec
         * obtained with:
         *

-        *      y' = y * 1024 / 1000000
-        *      y' = y / (1000000 / 1024)
-        *      y' = y / 977
+        *      y' = y * 1024 / 1000000000
+        *      y' = y * (2^10 / 2^42) * (2^42 / 1000000000)
+        *      y' = y / 2^32 * 4398
+        *      y' = (y * 4398) >> 32

         */
         */

-       misecs = (tv.tv_sec - tp->prev_tv.tv_sec) * 1024;
-       misecs += (int)(tv.tv_usec - tp->prev_tv.tv_usec) / 977;
+       misecs = ((now_ns - tp->prev_ns) * 4398) >> 32;

 
 

-       if (misecs > 512) {
-               struct strbuf buf = STRBUF_INIT;
-               unsigned int count, rate;
+       count = total - tp->prev_total;
+       tp->prev_total = total;
+       tp->prev_ns = now_ns;
+       tp->avg_bytes += count;
+       tp->avg_misecs += misecs;
+       rate = tp->avg_bytes / tp->avg_misecs;
+       tp->avg_bytes -= tp->last_bytes[tp->idx];
+       tp->avg_misecs -= tp->last_misecs[tp->idx];
+       tp->last_bytes[tp->idx] = count;
+       tp->last_misecs[tp->idx] = misecs;
+       tp->idx = (tp->idx + 1) % TP_IDX_MAX;

 
 

-               count = total - tp->prev_total;
-               tp->prev_total = total;
-               tp->prev_tv = tv;
-               tp->avg_bytes += count;
-               tp->avg_misecs += misecs;
-               rate = tp->avg_bytes / tp->avg_misecs;
-               tp->avg_bytes -= tp->last_bytes[tp->idx];
-               tp->avg_misecs -= tp->last_misecs[tp->idx];
-               tp->last_bytes[tp->idx] = count;
-               tp->last_misecs[tp->idx] = misecs;
-               tp->idx = (tp->idx + 1) % TP_IDX_MAX;
-
-               throughput_string(&buf, total, rate);
-               strncpy(tp->display, buf.buf, sizeof(tp->display));
-               strbuf_release(&buf);
-               if (progress->last_value != -1 && progress_update)
-                       display(progress, progress->last_value, NULL);
-       }
+       throughput_string(&buf, total, rate);
+       strncpy(tp->display, buf.buf, sizeof(tp->display));
+       strbuf_release(&buf);
+       if (progress->last_value != -1 && progress_update)
+               display(progress, progress->last_value, NULL);

 }
 
 int display_progress(struct progress *progress, unsigned n)
 }
 
 int display_progress(struct progress *progress, unsigned n)