GIT 1.5.6
[gitweb.git] / progress.c
index 3f6a602a534a7bd5dfea2fca4239af6f9ed5ceca..55a8687ad15788f8ea5a5beb463d216908f618b2 100644 (file)
 #define TP_IDX_MAX      8
 
 struct throughput {
+       off_t curr_total;
+       off_t prev_total;
        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 avg_misecs;
+       unsigned int last_bytes[TP_IDX_MAX];
        unsigned int last_misecs[TP_IDX_MAX];
        unsigned int idx;
        char display[32];
@@ -69,9 +69,9 @@ static void clear_progress_signal(void)
        progress_update = 0;
 }
 
-static int display(struct progress *progress, unsigned n, int done)
+static int display(struct progress *progress, unsigned n, const char *done)
 {
-       char *eol, *tp;
+       const char *eol, *tp;
 
        if (progress->delay) {
                if (!progress_update || --progress->delay)
@@ -90,7 +90,7 @@ static int display(struct progress *progress, unsigned n, int done)
 
        progress->last_value = n;
        tp = (progress->throughput) ? progress->throughput->display : "";
-       eol = done ? ", done.   \n" : "   \r";
+       eol = done ? done : "   \r";
        if (progress->total) {
                unsigned percent = n * 100 / progress->total;
                if (percent != progress->last_percent || progress_update) {
@@ -98,11 +98,13 @@ static int display(struct progress *progress, unsigned n, int done)
                        fprintf(stderr, "%s: %3u%% (%u/%u)%s%s",
                                progress->title, percent, n,
                                progress->total, tp, eol);
+                       fflush(stderr);
                        progress_update = 0;
                        return 1;
                }
        } else if (progress_update) {
                fprintf(stderr, "%s: %u%s%s", progress->title, n, tp, eol);
+               fflush(stderr);
                progress_update = 0;
                return 1;
        }
@@ -110,7 +112,31 @@ static int display(struct progress *progress, unsigned n, int done)
        return 0;
 }
 
-void display_throughput(struct progress *progress, unsigned long n)
+static void throughput_string(struct throughput *tp, off_t total,
+                             unsigned int rate)
+{
+       int l = sizeof(tp->display);
+       if (total > 1 << 30) {
+               l -= snprintf(tp->display, l, ", %u.%2.2u GiB",
+                             (int)(total >> 30),
+                             (int)(total & ((1 << 30) - 1)) / 10737419);
+       } else if (total > 1 << 20) {
+               l -= snprintf(tp->display, l, ", %u.%2.2u MiB",
+                             (int)(total >> 20),
+                             ((int)(total & ((1 << 20) - 1)) * 100) >> 20);
+       } else if (total > 1 << 10) {
+               l -= snprintf(tp->display, l, ", %u.%2.2u KiB",
+                             (int)(total >> 10),
+                             ((int)(total & ((1 << 10) - 1)) * 100) >> 10);
+       } else {
+               l -= snprintf(tp->display, l, ", %u bytes", (int)total);
+       }
+       if (rate)
+               snprintf(tp->display + sizeof(tp->display) - l, l,
+                        " | %u KiB/s", rate);
+}
+
+void display_throughput(struct progress *progress, off_t total)
 {
        struct throughput *tp;
        struct timeval tv;
@@ -124,13 +150,13 @@ void display_throughput(struct progress *progress, unsigned long n)
 
        if (!tp) {
                progress->throughput = tp = calloc(1, sizeof(*tp));
-               if (tp)
+               if (tp) {
+                       tp->prev_total = tp->curr_total = total;
                        tp->prev_tv = tv;
+               }
                return;
        }
-
-       tp->total += n;
-       tp->count += n;
+       tp->curr_total = total;
 
        /*
         * We have x = bytes and y = microsecs.  We want z = KiB/s:
@@ -151,47 +177,29 @@ void display_throughput(struct progress *progress, unsigned long n)
        misecs += (int)(tv.tv_usec - tp->prev_tv.tv_usec) / 977;
 
        if (misecs > 512) {
-               int l = sizeof(tp->display);
+               unsigned int count, rate;
+
+               count = total - tp->prev_total;
+               tp->prev_total = total;
                tp->prev_tv = tv;
-               tp->avg_bytes += tp->count;
+               tp->avg_bytes += count;
                tp->avg_misecs += misecs;
-
-               if (tp->total > 1 << 30) {
-                       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) {
-                       l -= snprintf(tp->display, l, ", %u.%2.2u MiB",
-                                     (int)(tp->total >> 20),
-                                     ((int)(tp->total & ((1 << 20) - 1))
-                                      * 100) >> 20);
-               } else if (tp->total > 1 << 10) {
-                       l -= snprintf(tp->display, l, ", %u.%2.2u KiB",
-                                     (int)(tp->total >> 10),
-                                     ((int)(tp->total & ((1 << 10) - 1))
-                                      * 100) >> 10);
-               } else {
-                       l -= snprintf(tp->display, l, ", %u bytes",
-                                     (int)tp->total);
-               }
-               snprintf(tp->display + sizeof(tp->display) - l, l,
-                        " | %lu KiB/s", tp->avg_bytes / tp->avg_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] = tp->count;
+               tp->last_bytes[tp->idx] = count;
                tp->last_misecs[tp->idx] = misecs;
                tp->idx = (tp->idx + 1) % TP_IDX_MAX;
-               tp->count = 0;
 
+               throughput_string(tp, total, rate);
                if (progress->last_value != -1 && progress_update)
-                       display(progress, progress->last_value, 0);
+                       display(progress, progress->last_value, NULL);
        }
 }
 
 int display_progress(struct progress *progress, unsigned n)
 {
-       return progress ? display(progress, n, 0) : 0;
+       return progress ? display(progress, n, NULL) : 0;
 }
 
 struct progress *start_progress_delay(const char *title, unsigned total,
@@ -201,6 +209,7 @@ struct progress *start_progress_delay(const char *title, unsigned total,
        if (!progress) {
                /* unlikely, but here's a good fallback */
                fprintf(stderr, "%s...\n", title);
+               fflush(stderr);
                return NULL;
        }
        progress->title = title;
@@ -220,6 +229,11 @@ struct progress *start_progress(const char *title, unsigned total)
 }
 
 void stop_progress(struct progress **p_progress)
+{
+       stop_progress_msg(p_progress, "done");
+}
+
+void stop_progress_msg(struct progress **p_progress, const char *msg)
 {
        struct progress *progress = *p_progress;
        if (!progress)
@@ -227,8 +241,21 @@ void stop_progress(struct progress **p_progress)
        *p_progress = NULL;
        if (progress->last_value != -1) {
                /* Force the last update */
+               char buf[128], *bufp;
+               size_t len = strlen(msg) + 5;
+               struct throughput *tp = progress->throughput;
+
+               bufp = (len < sizeof(buf)) ? buf : xmalloc(len + 1);
+               if (tp) {
+                       unsigned int rate = !tp->avg_misecs ? 0 :
+                                       tp->avg_bytes / tp->avg_misecs;
+                       throughput_string(tp, tp->curr_total, rate);
+               }
                progress_update = 1;
-               display(progress, progress->last_value, 1);
+               sprintf(bufp, ", %s.\n", msg);
+               display(progress, progress->last_value, bufp);
+               if (buf != bufp)
+                       free(bufp);
        }
        clear_progress_signal();
        free(progress->throughput);