make display of total transferred more accurate

The throughput display needs a delay period before accounting and
displaying anything.  Yet it might be called after some amount of data
has already been transferred.  The display of total data is therefore
accounted late and therefore smaller than the reality.

Let's call display_throughput() with an absolute amount of transferred
data instead of a relative number, and let the throughput code find the
relative amount of data by itself as needed.  This way the displayed
total is always exact.

Signed-off-by: Nicolas Pitre <nico@cam.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/csum-file.c b/csum-file.c
index 3729e73e19e18a78c15fb90dfc28133f541176ef..b445e6a2e576cc2ee5f99b33c04293e1bd39da0d 100644 (file)
--- a/csum-file.c
+++ b/csum-file.c
@@ -18,7 +18,8 @@ static void sha1flush(struct sha1file *f, unsigned int count)
        for (;;) {
                int ret = xwrite(f->fd, buf, count);
                if (ret > 0) {
        for (;;) {
                int ret = xwrite(f->fd, buf, count);
                if (ret > 0) {

-                       display_throughput(f->tp, ret);
+                       f->total += ret;
+                       display_throughput(f->tp, f->total);

                        buf = (char *) buf + ret;
                        count -= ret;
                        if (count)
                        buf = (char *) buf + ret;
                        count -= ret;
                        if (count)


@@ -101,6 +102,7 @@ struct sha1file *sha1fd_throughput(int fd, const char *name, struct progress *tp
        f->fd = fd;
        f->error = 0;
        f->offset = 0;
        f->fd = fd;
        f->error = 0;
        f->offset = 0;

+       f->total = 0;

        f->tp = tp;
        f->do_crc = 0;
        SHA1_Init(&f->ctx);
        f->tp = tp;
        f->do_crc = 0;
        SHA1_Init(&f->ctx);

diff --git a/csum-file.h b/csum-file.h
index 4d1b231292ad4cfc7996b73ea31fa74a5eff2687..a38cc3a2d725adbf44d9965ce911d2a19d79074e 100644 (file)
--- a/csum-file.h
+++ b/csum-file.h
@@ -8,6 +8,7 @@ struct sha1file {
        int fd, error;
        unsigned int offset, namelen;
        SHA_CTX ctx;
        int fd, error;
        unsigned int offset, namelen;
        SHA_CTX ctx;

+       off_t total;

        struct progress *tp;
        char name[PATH_MAX];
        int do_crc;
        struct progress *tp;
        char name[PATH_MAX];
        int do_crc;

diff --git a/index-pack.c b/index-pack.c
index 715a5bb7a6e42694b3e35de703e44e792a5442fe..581a7f5650d88b7ebffa34ee7b15f844757845b6 100644 (file)
--- a/index-pack.c
+++ b/index-pack.c
@@ -87,9 +87,9 @@ static void *fill(int min)
                                die("early EOF");
                        die("read error on input: %s", strerror(errno));
                }
                                die("early EOF");
                        die("read error on input: %s", strerror(errno));
                }

-               if (from_stdin)
-                       display_throughput(progress, ret);

                input_len += ret;
                input_len += ret;

+               if (from_stdin)
+                       display_throughput(progress, consumed_bytes + input_len);

        } while (input_len < min);
        return input_buffer;
 }
        } while (input_len < min);
        return input_buffer;
 }

diff --git a/progress.c b/progress.c
index 3f6a602a534a7bd5dfea2fca4239af6f9ed5ceca..a963bd8bfc84b1b5e0f05857d43ff3e04abce914 100644 (file)
--- a/progress.c
+++ b/progress.c
@@ -14,11 +14,10 @@
 #define TP_IDX_MAX      8
 
 struct throughput {
 #define TP_IDX_MAX      8
 
 struct throughput {

+       off_t prev_total;

        struct timeval prev_tv;
        struct timeval prev_tv;

-       off_t total;
-       unsigned long count;
-       unsigned long avg_bytes;
-       unsigned long last_bytes[TP_IDX_MAX];
+       unsigned int avg_bytes;
+       unsigned int last_bytes[TP_IDX_MAX];

        unsigned int avg_misecs;
        unsigned int last_misecs[TP_IDX_MAX];
        unsigned int idx;
        unsigned int avg_misecs;
        unsigned int last_misecs[TP_IDX_MAX];
        unsigned int idx;


@@ -110,7 +109,7 @@ static int display(struct progress *progress, unsigned n, int done)
        return 0;
 }
 
        return 0;
 }
 

-void display_throughput(struct progress *progress, unsigned long n)
+void display_throughput(struct progress *progress, off_t total)

 {
        struct throughput *tp;
        struct timeval tv;
 {
        struct throughput *tp;
        struct timeval tv;


@@ -124,14 +123,13 @@ void display_throughput(struct progress *progress, unsigned long n)
 
        if (!tp) {
                progress->throughput = tp = calloc(1, sizeof(*tp));
 
        if (!tp) {
                progress->throughput = tp = calloc(1, sizeof(*tp));

-               if (tp)
+               if (tp) {
+                       tp->prev_total = total;

                        tp->prev_tv = tv;
                        tp->prev_tv = tv;

+               }

                return;
        }
 
                return;
        }
 

-       tp->total += n;
-       tp->count += n;
-

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


@@ -152,37 +150,37 @@ void display_throughput(struct progress *progress, unsigned long n)
 
        if (misecs > 512) {
                int l = sizeof(tp->display);
 
        if (misecs > 512) {
                int l = sizeof(tp->display);

+               unsigned int count = total - tp->prev_total;
+               tp->prev_total = total;

                tp->prev_tv = tv;
                tp->prev_tv = tv;

-               tp->avg_bytes += tp->count;
+               tp->avg_bytes += count;

                tp->avg_misecs += misecs;
 
                tp->avg_misecs += misecs;
 

-               if (tp->total > 1 << 30) {
+               if (total > 1 << 30) {

                        l -= snprintf(tp->display, l, ", %u.%2.2u GiB",
                        l -= snprintf(tp->display, l, ", %u.%2.2u GiB",

-                                     (int)(tp->total >> 30),
-                                     (int)(tp->total & ((1 << 30) - 1)) / 10737419);
-               } else if (tp->total > 1 << 20) {
+                                     (int)(total >> 30),
+                                     (int)(total & ((1 << 30) - 1)) / 10737419);
+               } else if (total > 1 << 20) {

                        l -= snprintf(tp->display, l, ", %u.%2.2u MiB",
                        l -= snprintf(tp->display, l, ", %u.%2.2u MiB",

-                                     (int)(tp->total >> 20),
-                                     ((int)(tp->total & ((1 << 20) - 1))
+                                     (int)(total >> 20),
+                                     ((int)(total & ((1 << 20) - 1))

                                       * 100) >> 20);
                                       * 100) >> 20);

-               } else if (tp->total > 1 << 10) {
+               } else if (total > 1 << 10) {

                        l -= snprintf(tp->display, l, ", %u.%2.2u KiB",
                        l -= snprintf(tp->display, l, ", %u.%2.2u KiB",

-                                     (int)(tp->total >> 10),
-                                     ((int)(tp->total & ((1 << 10) - 1))
+                                     (int)(total >> 10),
+                                     ((int)(total & ((1 << 10) - 1))

                                       * 100) >> 10);
                } else {
                                       * 100) >> 10);
                } else {

-                       l -= snprintf(tp->display, l, ", %u bytes",
-                                     (int)tp->total);
+                       l -= snprintf(tp->display, l, ", %u bytes", (int)total);

                }
                snprintf(tp->display + sizeof(tp->display) - l, l,
                }
                snprintf(tp->display + sizeof(tp->display) - l, l,

-                        " | %lu KiB/s", tp->avg_bytes / tp->avg_misecs);
+                        " | %u KiB/s", tp->avg_bytes / tp->avg_misecs);

 
                tp->avg_bytes -= tp->last_bytes[tp->idx];
                tp->avg_misecs -= tp->last_misecs[tp->idx];
 
                tp->avg_bytes -= tp->last_bytes[tp->idx];
                tp->avg_misecs -= tp->last_misecs[tp->idx];

-               tp->last_bytes[tp->idx] = tp->count;
+               tp->last_bytes[tp->idx] = count;

                tp->last_misecs[tp->idx] = misecs;
                tp->idx = (tp->idx + 1) % TP_IDX_MAX;
                tp->last_misecs[tp->idx] = misecs;
                tp->idx = (tp->idx + 1) % TP_IDX_MAX;

-               tp->count = 0;

 
                if (progress->last_value != -1 && progress_update)
                        display(progress, progress->last_value, 0);
 
                if (progress->last_value != -1 && progress_update)
                        display(progress, progress->last_value, 0);

diff --git a/progress.h b/progress.h
index 61cb68dfa512bb3668d7e6060262041937aa82d3..3912969e6039405758fde6ac1169d516adc0f3a3 100644 (file)
--- a/progress.h
+++ b/progress.h
@@ -3,7 +3,7 @@
 
 struct progress;
 
 
 struct progress;
 

-void display_throughput(struct progress *progress, unsigned long n);
+void display_throughput(struct progress *progress, off_t total);

 int display_progress(struct progress *progress, unsigned n);
 struct progress *start_progress(const char *title, unsigned total);
 struct progress *start_progress_delay(const char *title, unsigned total,
 int display_progress(struct progress *progress, unsigned n);
 struct progress *start_progress(const char *title, unsigned total);
 struct progress *start_progress_delay(const char *title, unsigned total,