2005-04-24 02:04:40 +00:00
|
|
|
#include "cache.h"
|
2005-10-05 21:49:54 +00:00
|
|
|
#include "refs.h"
|
2005-06-29 18:30:24 +00:00
|
|
|
#include "tag.h"
|
2005-04-24 02:04:40 +00:00
|
|
|
#include "commit.h"
|
2005-06-25 05:56:58 +00:00
|
|
|
#include "tree.h"
|
|
|
|
#include "blob.h"
|
2005-10-21 04:25:09 +00:00
|
|
|
#include "diff.h"
|
2006-02-26 00:19:46 +00:00
|
|
|
#include "revision.h"
|
|
|
|
|
2006-03-01 08:58:56 +00:00
|
|
|
/* bits #0-4 in revision.h */
|
2005-04-24 02:04:40 +00:00
|
|
|
|
2006-03-01 08:58:56 +00:00
|
|
|
#define COUNTED (1u<<5)
|
2005-05-31 01:46:32 +00:00
|
|
|
|
2005-05-26 01:29:09 +00:00
|
|
|
static const char rev_list_usage[] =
|
2005-10-30 09:03:45 +00:00
|
|
|
"git-rev-list [OPTION] <commit-id>... [ -- paths... ]\n"
|
|
|
|
" limiting output:\n"
|
|
|
|
" --max-count=nr\n"
|
|
|
|
" --max-age=epoch\n"
|
|
|
|
" --min-age=epoch\n"
|
|
|
|
" --sparse\n"
|
|
|
|
" --no-merges\n"
|
2006-01-27 09:39:24 +00:00
|
|
|
" --remove-empty\n"
|
2005-10-30 09:03:45 +00:00
|
|
|
" --all\n"
|
|
|
|
" ordering output:\n"
|
|
|
|
" --topo-order\n"
|
2006-02-16 06:05:33 +00:00
|
|
|
" --date-order\n"
|
2005-10-30 09:03:45 +00:00
|
|
|
" formatting output:\n"
|
|
|
|
" --parents\n"
|
2006-02-19 11:32:31 +00:00
|
|
|
" --objects | --objects-edge\n"
|
2005-10-30 09:03:45 +00:00
|
|
|
" --unpacked\n"
|
|
|
|
" --header | --pretty\n"
|
2006-02-10 19:56:42 +00:00
|
|
|
" --abbrev=nr | --no-abbrev\n"
|
2005-10-30 09:03:45 +00:00
|
|
|
" special purpose:\n"
|
|
|
|
" --bisect"
|
|
|
|
;
|
2005-05-26 01:29:09 +00:00
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
struct rev_info revs;
|
|
|
|
|
2005-06-18 05:54:50 +00:00
|
|
|
static int bisect_list = 0;
|
2005-06-02 16:19:53 +00:00
|
|
|
static int verbose_header = 0;
|
2006-02-10 19:56:42 +00:00
|
|
|
static int abbrev = DEFAULT_ABBREV;
|
2005-06-02 16:19:53 +00:00
|
|
|
static int show_parents = 0;
|
|
|
|
static int hdr_termination = 0;
|
2005-08-24 21:58:42 +00:00
|
|
|
static const char *commit_prefix = "";
|
2005-06-05 16:02:03 +00:00
|
|
|
static enum cmit_fmt commit_format = CMIT_FMT_RAW;
|
2006-02-23 06:10:24 +00:00
|
|
|
|
2005-06-02 16:19:53 +00:00
|
|
|
static void show_commit(struct commit *commit)
|
|
|
|
{
|
2005-08-24 21:58:42 +00:00
|
|
|
printf("%s%s", commit_prefix, sha1_to_hex(commit->object.sha1));
|
2005-06-02 16:19:53 +00:00
|
|
|
if (show_parents) {
|
|
|
|
struct commit_list *parents = commit->parents;
|
|
|
|
while (parents) {
|
2006-01-29 23:24:42 +00:00
|
|
|
struct object *o = &(parents->item->object);
|
2005-06-02 16:19:53 +00:00
|
|
|
parents = parents->next;
|
2006-01-29 23:24:42 +00:00
|
|
|
if (o->flags & TMP_MARK)
|
|
|
|
continue;
|
|
|
|
printf(" %s", sha1_to_hex(o->sha1));
|
|
|
|
o->flags |= TMP_MARK;
|
2005-06-02 16:19:53 +00:00
|
|
|
}
|
2006-01-29 23:24:42 +00:00
|
|
|
/* TMP_MARK is a general purpose flag that can
|
|
|
|
* be used locally, but the user should clean
|
|
|
|
* things up after it is done with them.
|
|
|
|
*/
|
|
|
|
for (parents = commit->parents;
|
|
|
|
parents;
|
|
|
|
parents = parents->next)
|
|
|
|
parents->item->object.flags &= ~TMP_MARK;
|
2005-06-02 16:19:53 +00:00
|
|
|
}
|
2005-08-09 05:15:40 +00:00
|
|
|
if (commit_format == CMIT_FMT_ONELINE)
|
|
|
|
putchar(' ');
|
|
|
|
else
|
|
|
|
putchar('\n');
|
|
|
|
|
2005-06-02 16:19:53 +00:00
|
|
|
if (verbose_header) {
|
2005-06-05 16:02:03 +00:00
|
|
|
static char pretty_header[16384];
|
2006-02-10 19:56:42 +00:00
|
|
|
pretty_print_commit(commit_format, commit, ~0, pretty_header, sizeof(pretty_header), abbrev);
|
2005-06-05 16:02:03 +00:00
|
|
|
printf("%s%c", pretty_header, hdr_termination);
|
2005-07-04 23:36:48 +00:00
|
|
|
}
|
|
|
|
fflush(stdout);
|
2005-06-06 15:39:40 +00:00
|
|
|
}
|
|
|
|
|
2006-02-23 06:10:24 +00:00
|
|
|
static struct object_list **process_blob(struct blob *blob,
|
|
|
|
struct object_list **p,
|
|
|
|
struct name_path *path,
|
|
|
|
const char *name)
|
2005-06-25 05:56:58 +00:00
|
|
|
{
|
|
|
|
struct object *obj = &blob->object;
|
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
if (!revs.blob_objects)
|
2005-06-25 05:56:58 +00:00
|
|
|
return p;
|
|
|
|
if (obj->flags & (UNINTERESTING | SEEN))
|
|
|
|
return p;
|
|
|
|
obj->flags |= SEEN;
|
2006-02-23 06:10:24 +00:00
|
|
|
return add_object(obj, p, path, name);
|
2005-06-25 05:56:58 +00:00
|
|
|
}
|
|
|
|
|
2006-02-23 06:10:24 +00:00
|
|
|
static struct object_list **process_tree(struct tree *tree,
|
|
|
|
struct object_list **p,
|
|
|
|
struct name_path *path,
|
|
|
|
const char *name)
|
2005-06-25 05:56:58 +00:00
|
|
|
{
|
|
|
|
struct object *obj = &tree->object;
|
|
|
|
struct tree_entry_list *entry;
|
2006-02-23 06:10:24 +00:00
|
|
|
struct name_path me;
|
2005-06-25 05:56:58 +00:00
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
if (!revs.tree_objects)
|
2005-06-25 05:56:58 +00:00
|
|
|
return p;
|
|
|
|
if (obj->flags & (UNINTERESTING | SEEN))
|
|
|
|
return p;
|
|
|
|
if (parse_tree(tree) < 0)
|
|
|
|
die("bad tree object %s", sha1_to_hex(obj->sha1));
|
|
|
|
obj->flags |= SEEN;
|
2006-02-23 06:10:24 +00:00
|
|
|
p = add_object(obj, p, path, name);
|
|
|
|
me.up = path;
|
|
|
|
me.elem = name;
|
|
|
|
me.elem_len = strlen(name);
|
2005-09-16 21:32:48 +00:00
|
|
|
entry = tree->entries;
|
|
|
|
tree->entries = NULL;
|
|
|
|
while (entry) {
|
|
|
|
struct tree_entry_list *next = entry->next;
|
2005-06-25 05:56:58 +00:00
|
|
|
if (entry->directory)
|
2006-02-23 06:10:24 +00:00
|
|
|
p = process_tree(entry->item.tree, p, &me, entry->name);
|
2005-06-25 05:56:58 +00:00
|
|
|
else
|
2006-02-23 06:10:24 +00:00
|
|
|
p = process_blob(entry->item.blob, p, &me, entry->name);
|
2005-09-16 21:32:48 +00:00
|
|
|
free(entry);
|
|
|
|
entry = next;
|
2005-06-25 05:56:58 +00:00
|
|
|
}
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2006-02-28 19:24:00 +00:00
|
|
|
static void show_commit_list(struct rev_info *revs)
|
2005-06-02 16:19:53 +00:00
|
|
|
{
|
2006-02-28 19:24:00 +00:00
|
|
|
struct commit *commit;
|
2005-06-29 18:30:24 +00:00
|
|
|
struct object_list *objects = NULL, **p = &objects, *pending;
|
2005-06-02 16:19:53 +00:00
|
|
|
|
2006-02-28 19:24:00 +00:00
|
|
|
while ((commit = get_revision(revs)) != NULL) {
|
2006-02-23 06:10:24 +00:00
|
|
|
p = process_tree(commit->tree, p, NULL, "");
|
2006-02-28 23:07:20 +00:00
|
|
|
show_commit(commit);
|
2005-06-02 16:19:53 +00:00
|
|
|
}
|
2006-02-28 19:24:00 +00:00
|
|
|
for (pending = revs->pending_objects; pending; pending = pending->next) {
|
2005-06-29 18:30:24 +00:00
|
|
|
struct object *obj = pending->item;
|
|
|
|
const char *name = pending->name;
|
|
|
|
if (obj->flags & (UNINTERESTING | SEEN))
|
|
|
|
continue;
|
|
|
|
if (obj->type == tag_type) {
|
|
|
|
obj->flags |= SEEN;
|
2006-02-23 06:10:24 +00:00
|
|
|
p = add_object(obj, p, NULL, name);
|
2005-06-29 18:30:24 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (obj->type == tree_type) {
|
2006-02-23 06:10:24 +00:00
|
|
|
p = process_tree((struct tree *)obj, p, NULL, name);
|
2005-06-29 18:30:24 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (obj->type == blob_type) {
|
2006-02-23 06:10:24 +00:00
|
|
|
p = process_blob((struct blob *)obj, p, NULL, name);
|
2005-06-29 18:30:24 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
die("unknown pending object %s (%s)", sha1_to_hex(obj->sha1), name);
|
|
|
|
}
|
2005-06-25 05:56:58 +00:00
|
|
|
while (objects) {
|
2006-02-22 09:27:02 +00:00
|
|
|
/* An object with name "foo\n0000000..." can be used to
|
|
|
|
* confuse downstream git-pack-objects very badly.
|
2005-10-03 00:29:21 +00:00
|
|
|
*/
|
|
|
|
const char *ep = strchr(objects->name, '\n');
|
|
|
|
if (ep) {
|
|
|
|
printf("%s %.*s\n", sha1_to_hex(objects->item->sha1),
|
|
|
|
(int) (ep - objects->name),
|
|
|
|
objects->name);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
printf("%s %s\n", sha1_to_hex(objects->item->sha1), objects->name);
|
2005-06-25 05:56:58 +00:00
|
|
|
objects = objects->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-18 05:54:50 +00:00
|
|
|
/*
|
|
|
|
* This is a truly stupid algorithm, but it's only
|
|
|
|
* used for bisection, and we just don't care enough.
|
|
|
|
*
|
|
|
|
* We care just barely enough to avoid recursing for
|
|
|
|
* non-merge entries.
|
|
|
|
*/
|
|
|
|
static int count_distance(struct commit_list *entry)
|
|
|
|
{
|
|
|
|
int nr = 0;
|
|
|
|
|
|
|
|
while (entry) {
|
|
|
|
struct commit *commit = entry->item;
|
|
|
|
struct commit_list *p;
|
|
|
|
|
|
|
|
if (commit->object.flags & (UNINTERESTING | COUNTED))
|
|
|
|
break;
|
2006-03-10 09:21:39 +00:00
|
|
|
if (!revs.prune_fn || (commit->object.flags & TREECHANGE))
|
2005-11-27 19:32:03 +00:00
|
|
|
nr++;
|
2005-06-18 05:54:50 +00:00
|
|
|
commit->object.flags |= COUNTED;
|
|
|
|
p = commit->parents;
|
|
|
|
entry = p;
|
|
|
|
if (p) {
|
|
|
|
p = p->next;
|
|
|
|
while (p) {
|
|
|
|
nr += count_distance(p);
|
|
|
|
p = p->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-11-27 19:32:03 +00:00
|
|
|
|
2005-06-18 05:54:50 +00:00
|
|
|
return nr;
|
|
|
|
}
|
|
|
|
|
2005-06-19 03:02:49 +00:00
|
|
|
static void clear_distance(struct commit_list *list)
|
2005-06-18 05:54:50 +00:00
|
|
|
{
|
|
|
|
while (list) {
|
|
|
|
struct commit *commit = list->item;
|
|
|
|
commit->object.flags &= ~COUNTED;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct commit_list *find_bisection(struct commit_list *list)
|
|
|
|
{
|
|
|
|
int nr, closest;
|
|
|
|
struct commit_list *p, *best;
|
|
|
|
|
|
|
|
nr = 0;
|
|
|
|
p = list;
|
|
|
|
while (p) {
|
2006-03-10 09:21:39 +00:00
|
|
|
if (!revs.prune_fn || (p->item->object.flags & TREECHANGE))
|
2005-11-27 19:32:03 +00:00
|
|
|
nr++;
|
2005-06-18 05:54:50 +00:00
|
|
|
p = p->next;
|
|
|
|
}
|
|
|
|
closest = 0;
|
|
|
|
best = list;
|
|
|
|
|
2005-11-27 19:32:03 +00:00
|
|
|
for (p = list; p; p = p->next) {
|
|
|
|
int distance;
|
|
|
|
|
2006-03-10 09:21:39 +00:00
|
|
|
if (revs.prune_fn && !(p->item->object.flags & TREECHANGE))
|
2005-11-27 19:32:03 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
distance = count_distance(p);
|
2005-06-18 05:54:50 +00:00
|
|
|
clear_distance(list);
|
|
|
|
if (nr - distance < distance)
|
|
|
|
distance = nr - distance;
|
|
|
|
if (distance > closest) {
|
|
|
|
best = p;
|
|
|
|
closest = distance;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (best)
|
|
|
|
best->next = NULL;
|
|
|
|
return best;
|
|
|
|
}
|
|
|
|
|
2006-02-19 11:32:31 +00:00
|
|
|
static void mark_edge_parents_uninteresting(struct commit *commit)
|
|
|
|
{
|
|
|
|
struct commit_list *parents;
|
|
|
|
|
|
|
|
for (parents = commit->parents; parents; parents = parents->next) {
|
|
|
|
struct commit *parent = parents->item;
|
|
|
|
if (!(parent->object.flags & UNINTERESTING))
|
|
|
|
continue;
|
|
|
|
mark_tree_uninteresting(parent->tree);
|
2006-02-26 00:19:46 +00:00
|
|
|
if (revs.edge_hint && !(parent->object.flags & SHOWN)) {
|
2006-02-24 07:44:15 +00:00
|
|
|
parent->object.flags |= SHOWN;
|
2006-02-19 11:32:31 +00:00
|
|
|
printf("-%s\n", sha1_to_hex(parent->object.sha1));
|
2006-02-24 07:44:15 +00:00
|
|
|
}
|
2006-02-19 11:32:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-15 22:14:29 +00:00
|
|
|
static void mark_edges_uninteresting(struct commit_list *list)
|
|
|
|
{
|
|
|
|
for ( ; list; list = list->next) {
|
2006-02-19 11:32:31 +00:00
|
|
|
struct commit *commit = list->item;
|
2005-09-15 22:14:29 +00:00
|
|
|
|
2006-02-19 11:32:31 +00:00
|
|
|
if (commit->object.flags & UNINTERESTING) {
|
|
|
|
mark_tree_uninteresting(commit->tree);
|
|
|
|
continue;
|
2005-09-15 22:14:29 +00:00
|
|
|
}
|
2006-02-19 11:32:31 +00:00
|
|
|
mark_edge_parents_uninteresting(commit);
|
2005-09-15 22:14:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-21 04:25:09 +00:00
|
|
|
int main(int argc, const char **argv)
|
2005-04-24 02:04:40 +00:00
|
|
|
{
|
2006-02-26 00:19:46 +00:00
|
|
|
struct commit_list *list;
|
2006-02-27 16:54:36 +00:00
|
|
|
int i;
|
2005-04-24 02:04:40 +00:00
|
|
|
|
2006-02-28 19:24:00 +00:00
|
|
|
argc = setup_revisions(argc, argv, &revs, NULL);
|
2006-02-26 00:19:46 +00:00
|
|
|
|
2005-05-06 08:00:11 +00:00
|
|
|
for (i = 1 ; i < argc; i++) {
|
2005-10-21 04:25:09 +00:00
|
|
|
const char *arg = argv[i];
|
2005-05-06 08:00:11 +00:00
|
|
|
|
2006-01-30 00:28:02 +00:00
|
|
|
/* accept -<digit>, like traditilnal "head" */
|
|
|
|
if ((*arg == '-') && isdigit(arg[1])) {
|
2006-02-26 00:19:46 +00:00
|
|
|
revs.max_count = atoi(arg + 1);
|
2006-01-30 00:28:02 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-01-30 00:26:40 +00:00
|
|
|
if (!strcmp(arg, "-n")) {
|
|
|
|
if (++i >= argc)
|
|
|
|
die("-n requires an argument");
|
2006-02-26 00:19:46 +00:00
|
|
|
revs.max_count = atoi(argv[i]);
|
2006-01-30 00:26:40 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strncmp(arg,"-n",2)) {
|
2006-02-26 00:19:46 +00:00
|
|
|
revs.max_count = atoi(arg + 2);
|
2005-05-26 01:29:09 +00:00
|
|
|
continue;
|
2005-05-06 08:00:11 +00:00
|
|
|
}
|
2005-05-26 01:29:09 +00:00
|
|
|
if (!strcmp(arg, "--header")) {
|
|
|
|
verbose_header = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-02-10 19:56:42 +00:00
|
|
|
if (!strcmp(arg, "--no-abbrev")) {
|
|
|
|
abbrev = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strncmp(arg, "--abbrev=", 9)) {
|
|
|
|
abbrev = strtoul(arg + 9, NULL, 10);
|
|
|
|
if (abbrev && abbrev < MINIMUM_ABBREV)
|
|
|
|
abbrev = MINIMUM_ABBREV;
|
|
|
|
else if (40 < abbrev)
|
|
|
|
abbrev = 40;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-05 16:02:03 +00:00
|
|
|
if (!strncmp(arg, "--pretty", 8)) {
|
|
|
|
commit_format = get_commit_format(arg+8);
|
2005-06-01 15:42:22 +00:00
|
|
|
verbose_header = 1;
|
|
|
|
hdr_termination = '\n';
|
2005-08-09 05:15:40 +00:00
|
|
|
if (commit_format == CMIT_FMT_ONELINE)
|
2005-08-24 21:58:42 +00:00
|
|
|
commit_prefix = "";
|
2005-08-09 05:15:40 +00:00
|
|
|
else
|
2005-08-24 21:58:42 +00:00
|
|
|
commit_prefix = "commit ";
|
2005-06-01 15:42:22 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-05-31 02:30:07 +00:00
|
|
|
if (!strcmp(arg, "--parents")) {
|
|
|
|
show_parents = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-18 05:54:50 +00:00
|
|
|
if (!strcmp(arg, "--bisect")) {
|
|
|
|
bisect_list = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-02-26 00:19:46 +00:00
|
|
|
usage(rev_list_usage);
|
2005-05-26 01:29:09 +00:00
|
|
|
|
2005-05-06 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
2006-02-26 00:19:46 +00:00
|
|
|
list = revs.commits;
|
|
|
|
|
2005-12-20 00:16:49 +00:00
|
|
|
if (!list &&
|
2006-02-26 00:19:46 +00:00
|
|
|
(!(revs.tag_objects||revs.tree_objects||revs.blob_objects) && !revs.pending_objects))
|
2005-10-25 22:24:55 +00:00
|
|
|
usage(rev_list_usage);
|
|
|
|
|
2006-02-28 19:24:00 +00:00
|
|
|
prepare_revision_walk(&revs);
|
|
|
|
if (revs.tree_objects)
|
|
|
|
mark_edges_uninteresting(revs.commits);
|
|
|
|
|
|
|
|
if (bisect_list)
|
|
|
|
revs.commits = find_bisection(revs.commits);
|
2005-10-25 22:24:55 +00:00
|
|
|
|
[PATCH] Avoid wasting memory in git-rev-list
As pointed out on the list, git-rev-list can use a lot of memory.
One low-hanging fruit is to free the commit buffer for commits that we
parse. By default, parse_commit() will save away the buffer, since a lot
of cases do want it, and re-reading it continually would be unnecessary.
However, in many cases the buffer isn't actually necessary and saving it
just wastes memory.
We could just free the buffer ourselves, but especially in git-rev-list,
we actually end up using the helper functions that automatically add
parent commits to the commit lists, so we don't actually control the
commit parsing directly.
Instead, just make this behaviour of "parse_commit()" a global flag.
Maybe this is a bit tasteless, but it's very simple, and it makes a
noticable difference in memory usage.
Before the change:
[torvalds@g5 linux]$ /usr/bin/time git-rev-list v2.6.12..HEAD > /dev/null
0.26user 0.02system 0:00.28elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+3714minor)pagefaults 0swaps
after the change:
[torvalds@g5 linux]$ /usr/bin/time git-rev-list v2.6.12..HEAD > /dev/null
0.26user 0.00system 0:00.27elapsed 100%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+2433minor)pagefaults 0swaps
note how the minor faults have decreased from 3714 pages to 2433 pages.
That's all due to the fewer anonymous pages allocated to hold the comment
buffers and their metadata.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-09-15 21:43:17 +00:00
|
|
|
save_commit_buffer = verbose_header;
|
2005-09-16 21:55:33 +00:00
|
|
|
track_object_refs = 0;
|
[PATCH] Avoid wasting memory in git-rev-list
As pointed out on the list, git-rev-list can use a lot of memory.
One low-hanging fruit is to free the commit buffer for commits that we
parse. By default, parse_commit() will save away the buffer, since a lot
of cases do want it, and re-reading it continually would be unnecessary.
However, in many cases the buffer isn't actually necessary and saving it
just wastes memory.
We could just free the buffer ourselves, but especially in git-rev-list,
we actually end up using the helper functions that automatically add
parent commits to the commit lists, so we don't actually control the
commit parsing directly.
Instead, just make this behaviour of "parse_commit()" a global flag.
Maybe this is a bit tasteless, but it's very simple, and it makes a
noticable difference in memory usage.
Before the change:
[torvalds@g5 linux]$ /usr/bin/time git-rev-list v2.6.12..HEAD > /dev/null
0.26user 0.02system 0:00.28elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+3714minor)pagefaults 0swaps
after the change:
[torvalds@g5 linux]$ /usr/bin/time git-rev-list v2.6.12..HEAD > /dev/null
0.26user 0.00system 0:00.27elapsed 100%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+2433minor)pagefaults 0swaps
note how the minor faults have decreased from 3714 pages to 2433 pages.
That's all due to the fewer anonymous pages allocated to hold the comment
buffers and their metadata.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-09-15 21:43:17 +00:00
|
|
|
|
2006-02-28 23:07:20 +00:00
|
|
|
show_commit_list(&revs);
|
2005-05-31 01:46:32 +00:00
|
|
|
|
2005-04-24 02:04:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|