mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![Jeff King](/assets/img/avatar_default.png)
The usual arguments for using xsnprintf over sprintf apply, but this case is a little tricky. We print to a fixed-size buffer if we have room, and otherwise to an allocated buffer. So there should be no overflow here, but it is still good to communicate our intention, as well as to check our earlier math for how much space the string will need. Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
268 lines
6.3 KiB
C
268 lines
6.3 KiB
C
/*
|
|
* 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;
|
|
int last_value;
|
|
unsigned total;
|
|
unsigned last_percent;
|
|
unsigned delay;
|
|
unsigned delayed_percent_treshold;
|
|
struct throughput *throughput;
|
|
};
|
|
|
|
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, unsigned n, const char *done)
|
|
{
|
|
const char *eol, *tp;
|
|
|
|
if (progress->delay) {
|
|
if (!progress_update || --progress->delay)
|
|
return 0;
|
|
if (progress->total) {
|
|
unsigned percent = n * 100 / progress->total;
|
|
if (percent > progress->delayed_percent_treshold) {
|
|
/* inhibit this progress report entirely */
|
|
clear_progress_signal();
|
|
progress->delay = -1;
|
|
progress->total = 0;
|
|
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%% (%u/%u)%s%s",
|
|
progress->title, percent, n,
|
|
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: %u%s%s",
|
|
progress->title, n, tp, eol);
|
|
fflush(stderr);
|
|
}
|
|
progress_update = 0;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void throughput_string(struct strbuf *buf, off_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, off_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, unsigned n)
|
|
{
|
|
return progress ? display(progress, n, NULL) : 0;
|
|
}
|
|
|
|
struct progress *start_progress_delay(const char *title, unsigned total,
|
|
unsigned percent_treshold, 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->delayed_percent_treshold = percent_treshold;
|
|
progress->delay = delay;
|
|
progress->throughput = NULL;
|
|
set_progress_signal();
|
|
return progress;
|
|
}
|
|
|
|
struct progress *start_progress(const char *title, unsigned total)
|
|
{
|
|
return start_progress_delay(title, total, 0, 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[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->display, tp->curr_total, rate);
|
|
}
|
|
progress_update = 1;
|
|
xsnprintf(bufp, len + 1, ", %s.\n", msg);
|
|
display(progress, progress->last_value, bufp);
|
|
if (buf != bufp)
|
|
free(bufp);
|
|
}
|
|
clear_progress_signal();
|
|
if (progress->throughput)
|
|
strbuf_release(&progress->throughput->display);
|
|
free(progress->throughput);
|
|
free(progress);
|
|
}
|