]>
git.ipfire.org Git - thirdparty/git.git/blob - progress.c
2 * Simple text-based progress display module for GIT
4 * Copyright (c) 2007 by Nicolas Pitre <nico@fluxnic.net>
6 * This code is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include "git-compat-util.h"
23 unsigned int avg_bytes
;
24 unsigned int avg_misecs
;
25 unsigned int last_bytes
[TP_IDX_MAX
];
26 unsigned int last_misecs
[TP_IDX_MAX
];
28 struct strbuf display
;
35 unsigned last_percent
;
37 struct throughput
*throughput
;
39 struct strbuf counters_sb
;
42 static volatile sig_atomic_t progress_update
;
44 static void progress_interval(int signum
)
49 static void set_progress_signal(void)
56 memset(&sa
, 0, sizeof(sa
));
57 sa
.sa_handler
= progress_interval
;
58 sigemptyset(&sa
.sa_mask
);
59 sa
.sa_flags
= SA_RESTART
;
60 sigaction(SIGALRM
, &sa
, NULL
);
62 v
.it_interval
.tv_sec
= 1;
63 v
.it_interval
.tv_usec
= 0;
64 v
.it_value
= v
.it_interval
;
65 setitimer(ITIMER_REAL
, &v
, NULL
);
68 static void clear_progress_signal(void)
70 struct itimerval v
= {{0,},};
71 setitimer(ITIMER_REAL
, &v
, NULL
);
72 signal(SIGALRM
, SIG_IGN
);
76 static int is_foreground_fd(int fd
)
78 int tpgrp
= tcgetpgrp(fd
);
79 return tpgrp
< 0 || tpgrp
== getpgid(0);
82 static void display(struct progress
*progress
, uint64_t n
, const char *done
)
85 struct strbuf
*counters_sb
= &progress
->counters_sb
;
88 if (progress
->delay
&& (!progress_update
|| --progress
->delay
))
91 progress
->last_value
= n
;
92 tp
= (progress
->throughput
) ? progress
->throughput
->display
.buf
: "";
93 if (progress
->total
) {
94 unsigned percent
= n
* 100 / progress
->total
;
95 if (percent
!= progress
->last_percent
|| progress_update
) {
96 progress
->last_percent
= percent
;
98 strbuf_reset(counters_sb
);
99 strbuf_addf(counters_sb
,
100 "%3u%% (%"PRIuMAX
"/%"PRIuMAX
")%s", percent
,
101 (uintmax_t)n
, (uintmax_t)progress
->total
,
105 } else if (progress_update
) {
106 strbuf_reset(counters_sb
);
107 strbuf_addf(counters_sb
, "%"PRIuMAX
"%s", (uintmax_t)n
, tp
);
112 if (is_foreground_fd(fileno(stderr
)) || done
) {
113 const char *eol
= done
? done
: " \r";
115 fprintf(stderr
, "%s: %s%s", progress
->title
,
116 counters_sb
->buf
, eol
);
123 static void throughput_string(struct strbuf
*buf
, uint64_t total
,
127 strbuf_addstr(buf
, ", ");
128 strbuf_humanise_bytes(buf
, total
);
129 strbuf_addstr(buf
, " | ");
130 strbuf_humanise_bytes(buf
, rate
* 1024);
131 strbuf_addstr(buf
, "/s");
134 void display_throughput(struct progress
*progress
, uint64_t total
)
136 struct throughput
*tp
;
138 unsigned int misecs
, count
, rate
;
142 tp
= progress
->throughput
;
144 now_ns
= getnanotime();
147 progress
->throughput
= tp
= calloc(1, sizeof(*tp
));
149 tp
->prev_total
= tp
->curr_total
= total
;
150 tp
->prev_ns
= now_ns
;
151 strbuf_init(&tp
->display
, 0);
155 tp
->curr_total
= total
;
157 /* only update throughput every 0.5 s */
158 if (now_ns
- tp
->prev_ns
<= 500000000)
162 * We have x = bytes and y = nanosecs. We want z = KiB/s:
164 * z = (x / 1024) / (y / 1000000000)
165 * z = x / y * 1000000000 / 1024
166 * z = x / (y * 1024 / 1000000000)
169 * To simplify things we'll keep track of misecs, or 1024th of a sec
172 * y' = y * 1024 / 1000000000
173 * y' = y * (2^10 / 2^42) * (2^42 / 1000000000)
174 * y' = y / 2^32 * 4398
175 * y' = (y * 4398) >> 32
177 misecs
= ((now_ns
- tp
->prev_ns
) * 4398) >> 32;
179 count
= total
- tp
->prev_total
;
180 tp
->prev_total
= total
;
181 tp
->prev_ns
= now_ns
;
182 tp
->avg_bytes
+= count
;
183 tp
->avg_misecs
+= misecs
;
184 rate
= tp
->avg_bytes
/ tp
->avg_misecs
;
185 tp
->avg_bytes
-= tp
->last_bytes
[tp
->idx
];
186 tp
->avg_misecs
-= tp
->last_misecs
[tp
->idx
];
187 tp
->last_bytes
[tp
->idx
] = count
;
188 tp
->last_misecs
[tp
->idx
] = misecs
;
189 tp
->idx
= (tp
->idx
+ 1) % TP_IDX_MAX
;
191 throughput_string(&tp
->display
, total
, rate
);
192 if (progress
->last_value
!= -1 && progress_update
)
193 display(progress
, progress
->last_value
, NULL
);
196 void display_progress(struct progress
*progress
, uint64_t n
)
199 display(progress
, n
, NULL
);
202 static struct progress
*start_progress_delay(const char *title
, uint64_t total
,
205 struct progress
*progress
= malloc(sizeof(*progress
));
207 /* unlikely, but here's a good fallback */
208 fprintf(stderr
, "%s...\n", title
);
212 progress
->title
= title
;
213 progress
->total
= total
;
214 progress
->last_value
= -1;
215 progress
->last_percent
= -1;
216 progress
->delay
= delay
;
217 progress
->throughput
= NULL
;
218 progress
->start_ns
= getnanotime();
219 strbuf_init(&progress
->counters_sb
, 0);
220 set_progress_signal();
224 struct progress
*start_delayed_progress(const char *title
, uint64_t total
)
226 return start_progress_delay(title
, total
, 2);
229 struct progress
*start_progress(const char *title
, uint64_t total
)
231 return start_progress_delay(title
, total
, 0);
234 void stop_progress(struct progress
**p_progress
)
236 stop_progress_msg(p_progress
, _("done"));
239 void stop_progress_msg(struct progress
**p_progress
, const char *msg
)
241 struct progress
*progress
= *p_progress
;
245 if (progress
->last_value
!= -1) {
246 /* Force the last update */
248 struct throughput
*tp
= progress
->throughput
;
251 uint64_t now_ns
= getnanotime();
252 unsigned int misecs
, rate
;
253 misecs
= ((now_ns
- progress
->start_ns
) * 4398) >> 32;
254 rate
= tp
->curr_total
/ (misecs
? misecs
: 1);
255 throughput_string(&tp
->display
, tp
->curr_total
, rate
);
258 buf
= xstrfmt(", %s.\n", msg
);
259 display(progress
, progress
->last_value
, buf
);
262 clear_progress_signal();
263 strbuf_release(&progress
->counters_sb
);
264 if (progress
->throughput
)
265 strbuf_release(&progress
->throughput
->display
);
266 free(progress
->throughput
);