8aade107dd
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>
421 lines
11 KiB
C
421 lines
11 KiB
C
#include "cache.h"
|
|
#include "config.h"
|
|
#include "commit.h"
|
|
#include "diff.h"
|
|
#include "revision.h"
|
|
#include "list-objects.h"
|
|
#include "pack.h"
|
|
#include "pack-bitmap.h"
|
|
#include "builtin.h"
|
|
#include "log-tree.h"
|
|
#include "graph.h"
|
|
#include "bisect.h"
|
|
#include "progress.h"
|
|
|
|
static const char rev_list_usage[] =
|
|
"git rev-list [OPTION] <commit-id>... [ -- paths... ]\n"
|
|
" limiting output:\n"
|
|
" --max-count=<n>\n"
|
|
" --max-age=<epoch>\n"
|
|
" --min-age=<epoch>\n"
|
|
" --sparse\n"
|
|
" --no-merges\n"
|
|
" --min-parents=<n>\n"
|
|
" --no-min-parents\n"
|
|
" --max-parents=<n>\n"
|
|
" --no-max-parents\n"
|
|
" --remove-empty\n"
|
|
" --all\n"
|
|
" --branches\n"
|
|
" --tags\n"
|
|
" --remotes\n"
|
|
" --stdin\n"
|
|
" --quiet\n"
|
|
" ordering output:\n"
|
|
" --topo-order\n"
|
|
" --date-order\n"
|
|
" --reverse\n"
|
|
" formatting output:\n"
|
|
" --parents\n"
|
|
" --children\n"
|
|
" --objects | --objects-edge\n"
|
|
" --unpacked\n"
|
|
" --header | --pretty\n"
|
|
" --abbrev=<n> | --no-abbrev\n"
|
|
" --abbrev-commit\n"
|
|
" --left-right\n"
|
|
" --count\n"
|
|
" special purpose:\n"
|
|
" --bisect\n"
|
|
" --bisect-vars\n"
|
|
" --bisect-all"
|
|
;
|
|
|
|
static struct progress *progress;
|
|
static unsigned progress_counter;
|
|
|
|
static void finish_commit(struct commit *commit, void *data);
|
|
static void show_commit(struct commit *commit, void *data)
|
|
{
|
|
struct rev_list_info *info = data;
|
|
struct rev_info *revs = info->revs;
|
|
|
|
display_progress(progress, ++progress_counter);
|
|
|
|
if (info->flags & REV_LIST_QUIET) {
|
|
finish_commit(commit, data);
|
|
return;
|
|
}
|
|
|
|
graph_show_commit(revs->graph);
|
|
|
|
if (revs->count) {
|
|
if (commit->object.flags & PATCHSAME)
|
|
revs->count_same++;
|
|
else if (commit->object.flags & SYMMETRIC_LEFT)
|
|
revs->count_left++;
|
|
else
|
|
revs->count_right++;
|
|
finish_commit(commit, data);
|
|
return;
|
|
}
|
|
|
|
if (info->show_timestamp)
|
|
printf("%"PRItime" ", commit->date);
|
|
if (info->header_prefix)
|
|
fputs(info->header_prefix, stdout);
|
|
|
|
if (!revs->graph)
|
|
fputs(get_revision_mark(revs, commit), stdout);
|
|
if (revs->abbrev_commit && revs->abbrev)
|
|
fputs(find_unique_abbrev(commit->object.oid.hash, revs->abbrev),
|
|
stdout);
|
|
else
|
|
fputs(oid_to_hex(&commit->object.oid), stdout);
|
|
if (revs->print_parents) {
|
|
struct commit_list *parents = commit->parents;
|
|
while (parents) {
|
|
printf(" %s", oid_to_hex(&parents->item->object.oid));
|
|
parents = parents->next;
|
|
}
|
|
}
|
|
if (revs->children.name) {
|
|
struct commit_list *children;
|
|
|
|
children = lookup_decoration(&revs->children, &commit->object);
|
|
while (children) {
|
|
printf(" %s", oid_to_hex(&children->item->object.oid));
|
|
children = children->next;
|
|
}
|
|
}
|
|
show_decorations(revs, commit);
|
|
if (revs->commit_format == CMIT_FMT_ONELINE)
|
|
putchar(' ');
|
|
else
|
|
putchar('\n');
|
|
|
|
if (revs->verbose_header && get_cached_commit_buffer(commit, NULL)) {
|
|
struct strbuf buf = STRBUF_INIT;
|
|
struct pretty_print_context ctx = {0};
|
|
ctx.abbrev = revs->abbrev;
|
|
ctx.date_mode = revs->date_mode;
|
|
ctx.date_mode_explicit = revs->date_mode_explicit;
|
|
ctx.fmt = revs->commit_format;
|
|
ctx.output_encoding = get_log_output_encoding();
|
|
pretty_print_commit(&ctx, commit, &buf);
|
|
if (buf.len) {
|
|
if (revs->commit_format != CMIT_FMT_ONELINE)
|
|
graph_show_oneline(revs->graph);
|
|
|
|
graph_show_commit_msg(revs->graph, stdout, &buf);
|
|
|
|
/*
|
|
* Add a newline after the commit message.
|
|
*
|
|
* Usually, this newline produces a blank
|
|
* padding line between entries, in which case
|
|
* we need to add graph padding on this line.
|
|
*
|
|
* However, the commit message may not end in a
|
|
* newline. In this case the newline simply
|
|
* ends the last line of the commit message,
|
|
* and we don't need any graph output. (This
|
|
* always happens with CMIT_FMT_ONELINE, and it
|
|
* happens with CMIT_FMT_USERFORMAT when the
|
|
* format doesn't explicitly end in a newline.)
|
|
*/
|
|
if (buf.len && buf.buf[buf.len - 1] == '\n')
|
|
graph_show_padding(revs->graph);
|
|
putchar(info->hdr_termination);
|
|
} else {
|
|
/*
|
|
* If the message buffer is empty, just show
|
|
* the rest of the graph output for this
|
|
* commit.
|
|
*/
|
|
if (graph_show_remainder(revs->graph))
|
|
putchar('\n');
|
|
if (revs->commit_format == CMIT_FMT_ONELINE)
|
|
putchar('\n');
|
|
}
|
|
strbuf_release(&buf);
|
|
} else {
|
|
if (graph_show_remainder(revs->graph))
|
|
putchar('\n');
|
|
}
|
|
maybe_flush_or_die(stdout, "stdout");
|
|
finish_commit(commit, data);
|
|
}
|
|
|
|
static void finish_commit(struct commit *commit, void *data)
|
|
{
|
|
if (commit->parents) {
|
|
free_commit_list(commit->parents);
|
|
commit->parents = NULL;
|
|
}
|
|
free_commit_buffer(commit);
|
|
}
|
|
|
|
static void finish_object(struct object *obj, const char *name, void *cb_data)
|
|
{
|
|
struct rev_list_info *info = cb_data;
|
|
if (obj->type == OBJ_BLOB && !has_object_file(&obj->oid))
|
|
die("missing blob object '%s'", oid_to_hex(&obj->oid));
|
|
if (info->revs->verify_objects && !obj->parsed && obj->type != OBJ_COMMIT)
|
|
parse_object(&obj->oid);
|
|
}
|
|
|
|
static void show_object(struct object *obj, const char *name, void *cb_data)
|
|
{
|
|
struct rev_list_info *info = cb_data;
|
|
finish_object(obj, name, cb_data);
|
|
display_progress(progress, ++progress_counter);
|
|
if (info->flags & REV_LIST_QUIET)
|
|
return;
|
|
show_object_with_name(stdout, obj, name);
|
|
}
|
|
|
|
static void show_edge(struct commit *commit)
|
|
{
|
|
printf("-%s\n", oid_to_hex(&commit->object.oid));
|
|
}
|
|
|
|
static void print_var_str(const char *var, const char *val)
|
|
{
|
|
printf("%s='%s'\n", var, val);
|
|
}
|
|
|
|
static void print_var_int(const char *var, int val)
|
|
{
|
|
printf("%s=%d\n", var, val);
|
|
}
|
|
|
|
static int show_bisect_vars(struct rev_list_info *info, int reaches, int all)
|
|
{
|
|
int cnt, flags = info->flags;
|
|
char hex[GIT_MAX_HEXSZ + 1] = "";
|
|
struct commit_list *tried;
|
|
struct rev_info *revs = info->revs;
|
|
|
|
if (!revs->commits)
|
|
return 1;
|
|
|
|
revs->commits = filter_skipped(revs->commits, &tried,
|
|
flags & BISECT_SHOW_ALL,
|
|
NULL, NULL);
|
|
|
|
/*
|
|
* revs->commits can reach "reaches" commits among
|
|
* "all" commits. If it is good, then there are
|
|
* (all-reaches) commits left to be bisected.
|
|
* On the other hand, if it is bad, then the set
|
|
* to bisect is "reaches".
|
|
* A bisect set of size N has (N-1) commits further
|
|
* to test, as we already know one bad one.
|
|
*/
|
|
cnt = all - reaches;
|
|
if (cnt < reaches)
|
|
cnt = reaches;
|
|
|
|
if (revs->commits)
|
|
oid_to_hex_r(hex, &revs->commits->item->object.oid);
|
|
|
|
if (flags & BISECT_SHOW_ALL) {
|
|
traverse_commit_list(revs, show_commit, show_object, info);
|
|
printf("------\n");
|
|
}
|
|
|
|
print_var_str("bisect_rev", hex);
|
|
print_var_int("bisect_nr", cnt - 1);
|
|
print_var_int("bisect_good", all - reaches - 1);
|
|
print_var_int("bisect_bad", reaches - 1);
|
|
print_var_int("bisect_all", all);
|
|
print_var_int("bisect_steps", estimate_bisect_steps(all));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int show_object_fast(
|
|
const unsigned char *sha1,
|
|
enum object_type type,
|
|
int exclude,
|
|
uint32_t name_hash,
|
|
struct packed_git *found_pack,
|
|
off_t found_offset)
|
|
{
|
|
fprintf(stdout, "%s\n", sha1_to_hex(sha1));
|
|
return 1;
|
|
}
|
|
|
|
int cmd_rev_list(int argc, const char **argv, const char *prefix)
|
|
{
|
|
struct rev_info revs;
|
|
struct rev_list_info info;
|
|
int i;
|
|
int bisect_list = 0;
|
|
int bisect_show_vars = 0;
|
|
int bisect_find_all = 0;
|
|
int use_bitmap_index = 0;
|
|
const char *show_progress = NULL;
|
|
|
|
if (argc == 2 && !strcmp(argv[1], "-h"))
|
|
usage(rev_list_usage);
|
|
|
|
git_config(git_default_config, NULL);
|
|
init_revisions(&revs, prefix);
|
|
revs.abbrev = DEFAULT_ABBREV;
|
|
revs.commit_format = CMIT_FMT_UNSPECIFIED;
|
|
argc = setup_revisions(argc, argv, &revs, NULL);
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
info.revs = &revs;
|
|
if (revs.bisect)
|
|
bisect_list = 1;
|
|
|
|
if (DIFF_OPT_TST(&revs.diffopt, QUICK))
|
|
info.flags |= REV_LIST_QUIET;
|
|
for (i = 1 ; i < argc; i++) {
|
|
const char *arg = argv[i];
|
|
|
|
if (!strcmp(arg, "--header")) {
|
|
revs.verbose_header = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp(arg, "--timestamp")) {
|
|
info.show_timestamp = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp(arg, "--bisect")) {
|
|
bisect_list = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp(arg, "--bisect-all")) {
|
|
bisect_list = 1;
|
|
bisect_find_all = 1;
|
|
info.flags |= BISECT_SHOW_ALL;
|
|
revs.show_decorations = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp(arg, "--bisect-vars")) {
|
|
bisect_list = 1;
|
|
bisect_show_vars = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp(arg, "--use-bitmap-index")) {
|
|
use_bitmap_index = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp(arg, "--test-bitmap")) {
|
|
test_bitmap_walk(&revs);
|
|
return 0;
|
|
}
|
|
if (skip_prefix(arg, "--progress=", &arg)) {
|
|
show_progress = arg;
|
|
continue;
|
|
}
|
|
usage(rev_list_usage);
|
|
|
|
}
|
|
if (revs.commit_format != CMIT_FMT_UNSPECIFIED) {
|
|
/* The command line has a --pretty */
|
|
info.hdr_termination = '\n';
|
|
if (revs.commit_format == CMIT_FMT_ONELINE)
|
|
info.header_prefix = "";
|
|
else
|
|
info.header_prefix = "commit ";
|
|
}
|
|
else if (revs.verbose_header)
|
|
/* Only --header was specified */
|
|
revs.commit_format = CMIT_FMT_RAW;
|
|
|
|
if ((!revs.commits &&
|
|
(!(revs.tag_objects || revs.tree_objects || revs.blob_objects) &&
|
|
!revs.pending.nr)) ||
|
|
revs.diff)
|
|
usage(rev_list_usage);
|
|
|
|
if (revs.show_notes)
|
|
die(_("rev-list does not support display of notes"));
|
|
|
|
save_commit_buffer = (revs.verbose_header ||
|
|
revs.grep_filter.pattern_list ||
|
|
revs.grep_filter.header_list);
|
|
if (bisect_list)
|
|
revs.limited = 1;
|
|
|
|
if (show_progress)
|
|
progress = start_delayed_progress(show_progress, 0);
|
|
|
|
if (use_bitmap_index && !revs.prune) {
|
|
if (revs.count && !revs.left_right && !revs.cherry_mark) {
|
|
uint32_t commit_count;
|
|
int max_count = revs.max_count;
|
|
if (!prepare_bitmap_walk(&revs)) {
|
|
count_bitmap_commit_list(&commit_count, NULL, NULL, NULL);
|
|
if (max_count >= 0 && max_count < commit_count)
|
|
commit_count = max_count;
|
|
printf("%d\n", commit_count);
|
|
return 0;
|
|
}
|
|
} else if (revs.max_count < 0 &&
|
|
revs.tag_objects && revs.tree_objects && revs.blob_objects) {
|
|
if (!prepare_bitmap_walk(&revs)) {
|
|
traverse_bitmap_commit_list(&show_object_fast);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (prepare_revision_walk(&revs))
|
|
die("revision walk setup failed");
|
|
if (revs.tree_objects)
|
|
mark_edges_uninteresting(&revs, show_edge);
|
|
|
|
if (bisect_list) {
|
|
int reaches = reaches, all = all;
|
|
|
|
revs.commits = find_bisection(revs.commits, &reaches, &all,
|
|
bisect_find_all);
|
|
|
|
if (bisect_show_vars)
|
|
return show_bisect_vars(&info, reaches, all);
|
|
}
|
|
|
|
traverse_commit_list(&revs, show_commit, show_object, &info);
|
|
|
|
stop_progress(&progress);
|
|
|
|
if (revs.count) {
|
|
if (revs.left_right && revs.cherry_mark)
|
|
printf("%d\t%d\t%d\n", revs.count_left, revs.count_right, revs.count_same);
|
|
else if (revs.left_right)
|
|
printf("%d\t%d\n", revs.count_left, revs.count_right);
|
|
else if (revs.cherry_mark)
|
|
printf("%d\t%d\n", revs.count_left + revs.count_right, revs.count_same);
|
|
else
|
|
printf("%d\n", revs.count_left + revs.count_right);
|
|
}
|
|
|
|
return 0;
|
|
}
|