rev-list: implement --bisect-all

This is Junio's patch with some stuff to make --bisect-all
compatible with --bisect-vars.

This option makes it possible to see all the potential
bisection points. The best ones are displayed first.

Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>

diff --git a/builtin-rev-list.c b/builtin-rev-list.c
index 33726b8d8426b4878ed63184dc280957ba4434e0..44393320e8ec27a35ccc1da550852ce3333a25a8 100644 (file)
--- a/builtin-rev-list.c
+++ b/builtin-rev-list.c
@@ -9,6 +9,7 @@
 #include "revision.h"
 #include "list-objects.h"
 #include "builtin.h"
 #include "revision.h"
 #include "list-objects.h"
 #include "builtin.h"

+#include "log-tree.h"

 
 /* bits #0-15 in revision.h */
 
 
 /* bits #0-15 in revision.h */
 


@@ -38,7 +39,8 @@ static const char rev_list_usage[] =
 "    --left-right\n"
 "  special purpose:\n"
 "    --bisect\n"
 "    --left-right\n"
 "  special purpose:\n"
 "    --bisect\n"

-"    --bisect-vars"
+"    --bisect-vars\n"
+"    --bisect-all"

 ;
 
 static struct rev_info revs;
 ;
 
 static struct rev_info revs;


@@ -74,6 +76,7 @@ static void show_commit(struct commit *commit)
                        parents = parents->next;
                }
        }
                        parents = parents->next;
                }
        }

+       show_decorations(commit);

        if (revs.commit_format == CMIT_FMT_ONELINE)
                putchar(' ');
        else
        if (revs.commit_format == CMIT_FMT_ONELINE)
                putchar(' ');
        else


@@ -278,6 +281,57 @@ static struct commit_list *best_bisection(struct commit_list *list, int nr)
        return best;
 }
 
        return best;
 }
 

+struct commit_dist {
+       struct commit *commit;
+       int distance;
+};
+
+static int compare_commit_dist(const void *a_, const void *b_)
+{
+       struct commit_dist *a, *b;
+
+       a = (struct commit_dist *)a_;
+       b = (struct commit_dist *)b_;
+       if (a->distance != b->distance)
+               return b->distance - a->distance; /* desc sort */
+       return hashcmp(a->commit->object.sha1, b->commit->object.sha1);
+}
+
+static struct commit_list *best_bisection_sorted(struct commit_list *list, int nr)
+{
+       struct commit_list *p;
+       struct commit_dist *array = xcalloc(nr, sizeof(*array));
+       int cnt, i;
+
+       for (p = list, cnt = 0; p; p = p->next) {
+               int distance;
+               unsigned flags = p->item->object.flags;
+
+               if (revs.prune_fn && !(flags & TREECHANGE))
+                       continue;
+               distance = weight(p);
+               if (nr - distance < distance)
+                       distance = nr - distance;
+               array[cnt].commit = p->item;
+               array[cnt].distance = distance;
+               cnt++;
+       }
+       qsort(array, cnt, sizeof(*array), compare_commit_dist);
+       for (p = list, i = 0; i < cnt; i++) {
+               struct name_decoration *r = xmalloc(sizeof(*r) + 100);
+               struct object *obj = &(array[i].commit->object);
+
+               sprintf(r->name, "dist=%d", array[i].distance);
+               r->next = add_decoration(&name_decoration, obj, r);
+               p->item = array[i].commit;
+               p = p->next;
+       }
+       if (p)
+               p->next = NULL;
+       free(array);
+       return list;
+}
+

 /*
  * zero or positive weight is the number of interesting commits it can
  * reach, including itself.  Especially, weight = 0 means it does not
 /*
  * zero or positive weight is the number of interesting commits it can
  * reach, including itself.  Especially, weight = 0 means it does not


@@ -292,7 +346,8 @@ static struct commit_list *best_bisection(struct commit_list *list, int nr)
  * or positive distance.
  */
 static struct commit_list *do_find_bisection(struct commit_list *list,
  * or positive distance.
  */
 static struct commit_list *do_find_bisection(struct commit_list *list,

-                                            int nr, int *weights)
+                                            int nr, int *weights,
+                                            int find_all)

 {
        int n, counted;
        struct commit_list *p;
 {
        int n, counted;
        struct commit_list *p;


@@ -351,7 +406,7 @@ static struct commit_list *do_find_bisection(struct commit_list *list,
                clear_distance(list);
 
                /* Does it happen to be at exactly half-way? */
                clear_distance(list);
 
                /* Does it happen to be at exactly half-way? */

-               if (halfway(p, nr))
+               if (!find_all && halfway(p, nr))

                        return p;
                counted++;
        }
                        return p;
                counted++;
        }


@@ -389,19 +444,22 @@ static struct commit_list *do_find_bisection(struct commit_list *list,
                                weight_set(p, weight(q));
 
                        /* Does it happen to be at exactly half-way? */
                                weight_set(p, weight(q));
 
                        /* Does it happen to be at exactly half-way? */

-                       if (halfway(p, nr))
+                       if (!find_all && halfway(p, nr))

                                return p;
                }
        }
 
        show_list("bisection 2 counted all", counted, nr, list);
 
                                return p;
                }
        }
 
        show_list("bisection 2 counted all", counted, nr, list);
 

-       /* Then find the best one */
-       return best_bisection(list, nr);
+       if (!find_all)
+               return best_bisection(list, nr);
+       else
+               return best_bisection_sorted(list, nr);

 }
 
 static struct commit_list *find_bisection(struct commit_list *list,
 }
 
 static struct commit_list *find_bisection(struct commit_list *list,

-                                         int *reaches, int *all)
+                                         int *reaches, int *all,
+                                         int find_all)

 {
        int nr, on_list;
        struct commit_list *p, *best, *next, *last;
 {
        int nr, on_list;
        struct commit_list *p, *best, *next, *last;


@@ -434,14 +492,13 @@ static struct commit_list *find_bisection(struct commit_list *list,
        weights = xcalloc(on_list, sizeof(*weights));
 
        /* Do the real work of finding bisection commit. */
        weights = xcalloc(on_list, sizeof(*weights));
 
        /* Do the real work of finding bisection commit. */

-       best = do_find_bisection(list, nr, weights);
-
+       best = do_find_bisection(list, nr, weights, find_all);

        if (best) {
        if (best) {

-               best->next = NULL;
+               if (!find_all)
+                       best->next = NULL;

                *reaches = weight(best);
        }
        free(weights);
                *reaches = weight(best);
        }
        free(weights);

-

        return best;
 }
 
        return best;
 }
 


@@ -468,6 +525,7 @@ int cmd_rev_list(int argc, const char **argv, const char *prefix)
        int i;
        int read_from_stdin = 0;
        int bisect_show_vars = 0;
        int i;
        int read_from_stdin = 0;
        int bisect_show_vars = 0;

+       int bisect_find_all = 0;

 
        git_config(git_default_config);
        init_revisions(&revs, prefix);
 
        git_config(git_default_config);
        init_revisions(&revs, prefix);


@@ -490,6 +548,11 @@ int cmd_rev_list(int argc, const char **argv, const char *prefix)
                        bisect_list = 1;
                        continue;
                }
                        bisect_list = 1;
                        continue;
                }

+               if (!strcmp(arg, "--bisect-all")) {
+                       bisect_list = 1;
+                       bisect_find_all = 1;
+                       continue;
+               }

                if (!strcmp(arg, "--bisect-vars")) {
                        bisect_list = 1;
                        bisect_show_vars = 1;
                if (!strcmp(arg, "--bisect-vars")) {
                        bisect_list = 1;
                        bisect_show_vars = 1;


@@ -536,9 +599,11 @@ int cmd_rev_list(int argc, const char **argv, const char *prefix)
        if (bisect_list) {
                int reaches = reaches, all = all;
 
        if (bisect_list) {
                int reaches = reaches, all = all;
 

-               revs.commits = find_bisection(revs.commits, &reaches, &all);
+               revs.commits = find_bisection(revs.commits, &reaches, &all,
+                                             bisect_find_all);

                if (bisect_show_vars) {
                        int cnt;
                if (bisect_show_vars) {
                        int cnt;

+                       char hex[41];

                        if (!revs.commits)
                                return 1;
                        /*
                        if (!revs.commits)
                                return 1;
                        /*


@@ -550,15 +615,22 @@ int cmd_rev_list(int argc, const char **argv, const char *prefix)
                         * A bisect set of size N has (N-1) commits further
                         * to test, as we already know one bad one.
                         */
                         * A bisect set of size N has (N-1) commits further
                         * to test, as we already know one bad one.
                         */

-                       cnt = all-reaches;
+                       cnt = all - reaches;

                        if (cnt < reaches)
                                cnt = reaches;
                        if (cnt < reaches)
                                cnt = reaches;

+                       strcpy(hex, sha1_to_hex(revs.commits->item->object.sha1));
+
+                       if (bisect_find_all) {
+                               traverse_commit_list(&revs, show_commit, show_object);
+                               printf("------\n");
+                       }
+

                        printf("bisect_rev=%s\n"
                               "bisect_nr=%d\n"
                               "bisect_good=%d\n"
                               "bisect_bad=%d\n"
                               "bisect_all=%d\n",
                        printf("bisect_rev=%s\n"
                               "bisect_nr=%d\n"
                               "bisect_good=%d\n"
                               "bisect_bad=%d\n"
                               "bisect_all=%d\n",

-                              sha1_to_hex(revs.commits->item->object.sha1),
+                              hex,

                               cnt - 1,
                               all - reaches - 1,
                               reaches - 1,
                               cnt - 1,
                               all - reaches - 1,
                               reaches - 1,

diff --git a/log-tree.c b/log-tree.c
index 62edd344558049f05c33888de9d2fc2a854b51e9..3763ce94fcb5c96f366f84e755c8abd725b00b00 100644 (file)
--- a/log-tree.c
+++ b/log-tree.c
@@ -15,7 +15,7 @@ static void show_parents(struct commit *commit, int abbrev)
        }
 }
 
        }
 }
 

-static void show_decorations(struct commit *commit)
+void show_decorations(struct commit *commit)

 {
        const char *prefix;
        struct name_decoration *decoration;
 {
        const char *prefix;
        struct name_decoration *decoration;

diff --git a/log-tree.h b/log-tree.h
index e82b56a20d3cfad318a4af6ea78fbe098653211d..b33f7cd7ac2ef6a2587109c4ee618d63ccedae96 100644 (file)
--- a/log-tree.h
+++ b/log-tree.h
@@ -12,5 +12,6 @@ int log_tree_diff_flush(struct rev_info *);
 int log_tree_commit(struct rev_info *, struct commit *);
 int log_tree_opt_parse(struct rev_info *, const char **, int);
 void show_log(struct rev_info *opt, const char *sep);
 int log_tree_commit(struct rev_info *, struct commit *);
 int log_tree_opt_parse(struct rev_info *, const char **, int);
 void show_log(struct rev_info *opt, const char *sep);

+void show_decorations(struct commit *commit);

 
 #endif
 
 #endif