git/progress.c

261 lines
6.1 KiB
C
Raw Normal View History

/*
* Simple text-based progress display module for GIT
*
* Copyright (c) 2007 by Nicolas Pitre <nico@fluxnic.net>
*
* This code is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include "git-compat-util.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;
uint64_t prev_ns;
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;
struct strbuf display;
};
struct progress {
const char *title;
uint64_t last_value;
uint64_t total;
unsigned last_percent;
unsigned delay;
struct throughput *throughput;
uint64_t start_ns;
};
static volatile sig_atomic_t progress_update;
static void progress_interval(int signum)
{
progress_update = 1;
}
static void set_progress_signal(void)
{
struct sigaction sa;
struct itimerval v;
progress_update = 0;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = progress_interval;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sigaction(SIGALRM, &sa, NULL);
v.it_interval.tv_sec = 1;
v.it_interval.tv_usec = 0;
v.it_value = v.it_interval;
setitimer(ITIMER_REAL, &v, NULL);
}
static void clear_progress_signal(void)
{
struct itimerval v = {{0,},};
setitimer(ITIMER_REAL, &v, NULL);
signal(SIGALRM, SIG_IGN);
progress_update = 0;
}
static int is_foreground_fd(int fd)
{
int tpgrp = tcgetpgrp(fd);
return tpgrp < 0 || tpgrp == getpgid(0);
}
static int display(struct progress *progress, uint64_t n, const char *done)
{
const char *eol, *tp;
if (progress->delay && (!progress_update || --progress->delay))
return 0;
progress->last_value = n;
tp = (progress->throughput) ? progress->throughput->display.buf : "";
eol = done ? done : " \r";
if (progress->total) {
unsigned percent = n * 100 / progress->total;
if (percent != progress->last_percent || progress_update) {
progress->last_percent = percent;
if (is_foreground_fd(fileno(stderr)) || done) {
fprintf(stderr, "%s: %3u%% (%"PRIuMAX"/%"PRIuMAX")%s%s",
progress->title, percent,
(uintmax_t)n, (uintmax_t)progress->total,
tp, eol);
fflush(stderr);
}
progress_update = 0;
return 1;
}
} else if (progress_update) {
if (is_foreground_fd(fileno(stderr)) || done) {
fprintf(stderr, "%s: %"PRIuMAX"%s%s",
progress->title, (uintmax_t)n, tp, eol);
fflush(stderr);
}
progress_update = 0;
return 1;
}
return 0;
}
static void throughput_string(struct strbuf *buf, uint64_t total,
unsigned int rate)
{
strbuf_reset(buf);
strbuf_addstr(buf, ", ");
strbuf_humanise_bytes(buf, total);
strbuf_addstr(buf, " | ");
strbuf_humanise_bytes(buf, rate * 1024);
strbuf_addstr(buf, "/s");
}
void display_throughput(struct progress *progress, uint64_t total)
{
struct throughput *tp;
uint64_t now_ns;
unsigned int misecs, count, rate;
if (!progress)
return;
tp = progress->throughput;
now_ns = getnanotime();
if (!tp) {
progress->throughput = tp = calloc(1, sizeof(*tp));
if (tp) {
tp->prev_total = tp->curr_total = total;
tp->prev_ns = now_ns;
strbuf_init(&tp->display, 0);
}
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 = nanosecs. We want z = KiB/s:
*
* 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:
*
* y' = y * 1024 / 1000000000
* y' = y * (2^10 / 2^42) * (2^42 / 1000000000)
* y' = y / 2^32 * 4398
* y' = (y * 4398) >> 32
*/
misecs = ((now_ns - tp->prev_ns) * 4398) >> 32;
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;
throughput_string(&tp->display, total, rate);
if (progress->last_value != -1 && progress_update)
display(progress, progress->last_value, NULL);
}
int display_progress(struct progress *progress, uint64_t n)
{
return progress ? display(progress, n, NULL) : 0;
}
static struct progress *start_progress_delay(const char *title, uint64_t total,
unsigned delay)
{
struct progress *progress = malloc(sizeof(*progress));
if (!progress) {
/* unlikely, but here's a good fallback */
fprintf(stderr, "%s...\n", title);
fflush(stderr);
return NULL;
}
progress->title = title;
progress->total = total;
progress->last_value = -1;
progress->last_percent = -1;
progress->delay = delay;
progress->throughput = NULL;
progress->start_ns = getnanotime();
set_progress_signal();
return progress;
}
struct progress *start_delayed_progress(const char *title, uint64_t total)
progress: simplify "delayed" progress API We used to expose the full power of the delayed progress API to the callers, so that they can specify, not just the message to show and expected total amount of work that is used to compute the percentage of work performed so far, the percent-threshold parameter P and the delay-seconds parameter N. The progress meter starts to show at N seconds into the operation only if we have not yet completed P per-cent of the total work. Most callers used either (0%, 2s) or (50%, 1s) as (P, N), but there are oddballs that chose more random-looking values like 95%. For a smoother workload, (50%, 1s) would allow us to start showing the progress meter earlier than (0%, 2s), while keeping the chance of not showing progress meter for long running operation the same as the latter. For a task that would take 2s or more to complete, it is likely that less than half of it would complete within the first second, if the workload is smooth. But for a spiky workload whose earlier part is easier, such a setting is likely to fail to show the progress meter entirely and (0%, 2s) is more appropriate. But that is merely a theory. Realistically, it is of dubious value to ask each codepath to carefully consider smoothness of their workload and specify their own setting by passing two extra parameters. Let's simplify the API by dropping both parameters and have everybody use (0%, 2s). Oh, by the way, the percent-threshold parameter and the structure member were consistently misspelled, which also is now fixed ;-) Helped-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-08-19 17:39:41 +00:00
{
return start_progress_delay(title, total, 2);
progress: simplify "delayed" progress API We used to expose the full power of the delayed progress API to the callers, so that they can specify, not just the message to show and expected total amount of work that is used to compute the percentage of work performed so far, the percent-threshold parameter P and the delay-seconds parameter N. The progress meter starts to show at N seconds into the operation only if we have not yet completed P per-cent of the total work. Most callers used either (0%, 2s) or (50%, 1s) as (P, N), but there are oddballs that chose more random-looking values like 95%. For a smoother workload, (50%, 1s) would allow us to start showing the progress meter earlier than (0%, 2s), while keeping the chance of not showing progress meter for long running operation the same as the latter. For a task that would take 2s or more to complete, it is likely that less than half of it would complete within the first second, if the workload is smooth. But for a spiky workload whose earlier part is easier, such a setting is likely to fail to show the progress meter entirely and (0%, 2s) is more appropriate. But that is merely a theory. Realistically, it is of dubious value to ask each codepath to carefully consider smoothness of their workload and specify their own setting by passing two extra parameters. Let's simplify the API by dropping both parameters and have everybody use (0%, 2s). Oh, by the way, the percent-threshold parameter and the structure member were consistently misspelled, which also is now fixed ;-) Helped-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-08-19 17:39:41 +00:00
}
struct progress *start_progress(const char *title, uint64_t total)
{
return start_progress_delay(title, total, 0);
}
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)
return;
*p_progress = NULL;
if (progress->last_value != -1) {
/* Force the last update */
char *buf;
struct throughput *tp = progress->throughput;
if (tp) {
uint64_t now_ns = getnanotime();
unsigned int misecs, rate;
misecs = ((now_ns - progress->start_ns) * 4398) >> 32;
rate = tp->curr_total / (misecs ? misecs : 1);
throughput_string(&tp->display, tp->curr_total, rate);
}
progress_update = 1;
buf = xstrfmt(", %s.\n", msg);
display(progress, progress->last_value, buf);
free(buf);
}
clear_progress_signal();
if (progress->throughput)
strbuf_release(&progress->throughput->display);
free(progress->throughput);
free(progress);
}