| blob | 1cd54833acac7bd051559929471572e56b4d4a1b |
4 <head>
9 /* Debug borders */
11 /*
12 border: 1px solid red;
13 */
14 }
16 body {
18 }
20 a {
23 }
26 }
28 em {
31 }
33 strong {
36 }
38 tt {
40 }
48 }
52 }
53 h2 {
55 }
56 h3 {
58 }
59 h3 + * {
61 }
66 }
68 hr {
70 }
72 p {
75 }
79 }
81 pre {
84 }
86 span#author {
91 }
92 span#email {
93 }
96 }
98 div#footer {
104 }
105 div#footer-text {
108 }
109 div#footer-badges {
112 }
114 div#preamble {
117 }
123 }
127 }
131 }
133 /* Block element titles. */
141 }
144 }
148 }
151 }
154 }
160 }
166 }
171 }
175 }
180 }
183 }
187 }
188 /* DEPRECATED: Pre version 8.2.7 verse style literal block. */
191 }
200 }
204 }
209 }
215 dl {
218 }
219 dt {
224 }
227 }
231 }
234 }
237 }
240 }
243 }
246 }
253 }
257 }
258 thead {
261 }
262 tfoot {
264 }
267 }
270 }
271 /* Because the table frame attribute is overriden by CSS in most browsers. */
274 }
278 }
282 }
288 }
291 }
294 }
300 }
303 }
307 }
311 }
315 }
317 div#toctitle {
324 }
329 }
333 }
337 }
341 }
342 /* Workarounds for IE6's broken and incomplete CSS2. */
348 }
355 }
361 }
366 }
370 }
374 }
379 }
381 /* IE6 sets dynamically generated links as visited. */
383 </style>
384 </head>
385 <body>
389 <span id="email"><tt><<a href="mailto:chriscool@tuxfamily.org">chriscool@tuxfamily.org</a>></tt></span><br />
391 </div>
395 commit that introduced a regression. We show why it is important to
396 have good tools to fight regressions. We describe how "git bisect"
397 works from the outside and the algorithms it uses inside. Then we
398 explain how to take advantage of "git bisect" to improve current
399 practices. And we discuss how "git bisect" could improve in the
400 future.</p></div>
401 </div>
405 Torvalds and maintained by Junio Hamano.</p></div>
406 <div class="paragraph"><p>In Git like in many other Version Control Systems (VCS), the different
407 states of the data that is managed by the system are called
408 commits. And, as VCS are mostly used to manage software source code,
409 sometimes "interesting" changes of behavior in the software are
410 introduced in some commits.</p></div>
412 "bad" behavior, called a bug or a regression. They are interested in
413 these commits because a commit (hopefully) contains a very small set
414 of source code changes. And it’s much easier to understand and
415 properly fix a problem when you only need to check a very small set of
418 "git bisect" set of commands was invented. And it follows of course
421 called "good" commits. And a commit that introduce the behavior we are
422 interested in is called a "first bad commit". Note that there could be
425 be as efficient as possible, it tries to perform a binary search.</p></div>
426 </div>
429 <h3 id="_regressions_a_big_problem">Regressions: a big problem</h3><div style="clear:left"></div>
430 <div class="paragraph"><p>Regressions are a big problem in the software industry. But it’s
431 difficult to put some real numbers behind that claim.</p></div>
437 they cost the U.S. economy an estimated $59.5 billion annually, or
438 about 0.6 percent of the gross domestic product, according to a newly
439 released study commissioned by the Department of Commerce’s National
440 Institute of Standards and Technology (NIST). At the national level,
441 over half of the costs are borne by software users and the remainder
442 by software developers/vendors. The study also found that, although
443 all errors cannot be removed, more than a third of these costs, or an
444 estimated $22.2 billion, could be eliminated by an improved testing
445 infrastructure that enables earlier and more effective identification
446 and removal of software defects. These are the savings associated with
447 finding an increased percentage (but not 100 percent) of errors closer
448 to the development stages in which they are introduced. Currently,
449 over half of all errors are not found until "downstream" in the
450 development process or during post-sale software use.</p></div>
451 </div>
453 </div></div>
458 development costs on identifying and correcting defects, and yet few
459 products of any type other than software are shipped with such high
460 levels of errors.</p></div>
461 </div>
463 </div></div>
467 <div class="paragraph"><p>The path to higher software quality is significantly improved software
468 testing.</p></div>
469 </div>
471 </div></div>
478 bugs. However, studies and surveys over the years have indicated that
479 the majority, over 80%, of the maintenance effort is used for
480 non-corrective actions (Pigosky 1997). This perception is perpetuated
481 by users submitting problem reports that in reality are functionality
482 enhancements to the system.</p></div>
483 </div>
485 </div></div>
487 because you have to watch out for regressions. At least this would
488 make the above studies consistent among themselves.</p></div>
490 time without being improved on much, and then finally thrown away. In
491 this case, of course, regressions may not be a big problem. But on the
492 other hand, there is a lot of big software that is continually
493 developed and maintained during years or even tens of years by a lot
494 of people. And as there are often many people who depend (sometimes
495 critically) on such software, regressions are a really big problem.</p></div>
497 kernel, we can see that a lot of time and effort is spent to fight
498 regressions. The release cycle start with a 2 weeks long merge
499 window. Then the first release candidate (rc) version is tagged. And
501 week between each of them, before the final release.</p></div>
503 supposed to be used to test rc versions and fight bugs and especially
504 regressions. And this time is more than 80% of the release cycle
505 time. But this is not the end of the fight yet, as of course it
506 continues after the release.</p></div>
508 developer) says about his use of git bisect:</p></div>
512 get merged upstream and when the influx of bugs is the highest) - and
513 yes, there have been cases that i used it multiple times a day. My
514 average is roughly once a day.</p></div>
515 </div>
517 </div></div>
518 <div class="paragraph"><p>So regressions are fought all the time by developers, and indeed it is
519 well known that bugs should be fixed as soon as possible, so as soon
520 as they are found. That’s why it is interesting to have good tools for
521 this purpose.</p></div>
522 <h3 id="_other_tools_to_fight_regressions">Other tools to fight regressions</h3><div style="clear:left"></div>
524 same as those used to fight regular bugs. The only specific tools are
527 supposed to be used so that all the tests are checked after each
528 commit. This means that they are not very efficient, because many
529 tests are run for no interesting result, and they suffer from
530 combinational explosion.</p></div>
532 configuration options and that each test case should pass for each
533 configuration after each commit. So if you have for each release: N
534 configurations, M commits and T test cases, you should perform:</p></div>
538 </div></div>
539 <div class="paragraph"><p>where N, M and T are all growing with the size your software.</p></div>
540 <div class="paragraph"><p>So very soon it will not be possible to completely test everything.</p></div>
541 <div class="paragraph"><p>And if some bugs slip through your test suite, then you can add a test
542 to your test suite. But if you want to use your new improved test
543 suite to find where the bug slipped in, then you will either have to
544 emulate a bisection process or you will perhaps bluntly test each
545 commit backward starting from the "bad" commit you have which may be
546 very wasteful.</p></div>
547 </div>
552 start the search. Then bounds must be set to limit the commit
553 space. This is done usually by giving one "bad" and at least one
559 </div></div>
564 </div></div>
569 </div></div>
571 commit.</p></div>
573 user to test it, like this:</p></div>
579 </div></div>
581 will be looking for the first commit that has a version like
583 in the top level Makefile. This is a toy example because there are
584 better ways to find this commit with git than using "git bisect" (for
586 <h3 id="_driving_a_bisection_manually">Driving a bisection manually</h3><div style="clear:left"></div>
588 be driven manually by the user or it can be driven automatically by a
589 script or a command.</p></div>
593 that have been described above. For example:</p></div>
596 <pre><tt>$ git bisect bad
599 </div></div>
601 find a first bad commit:</p></div>
604 <pre><tt>$ git bisect bad
605 2ddcca36c8bcfa251724fe342c8327451988be0d is the first bad commit
606 commit 2ddcca36c8bcfa251724fe342c8327451988be0d
610 Linux 2.6.26-rc1
612 :100644 100644 5cf8258195331a4dbdddff08b8d68642638eea57 4492984efc09ab72ff6219a7bc21fb6a957c4cd5 M Makefile</tt></pre>
613 </div></div>
614 <div class="paragraph"><p>At this point we can see what the commit does, check it out (if it’s
615 not already checked out) or tinker with it, for example:</p></div>
618 <pre><tt>$ git show HEAD
619 commit 2ddcca36c8bcfa251724fe342c8327451988be0d
623 Linux 2.6.26-rc1
625 diff --git a/Makefile b/Makefile
627 --- a/Makefile
628 +++ b/Makefile
630 VERSION = 2
631 PATCHLEVEL = 6
632 -SUBLEVEL = 25
633 -EXTRAVERSION =
634 +SUBLEVEL = 26
635 +EXTRAVERSION = -rc1
636 NAME = Funky Weasel is Jiggy wit it
638 # *DOCUMENTATION*</tt></pre>
639 </div></div>
641 the branch we were in before we started bisecting:</p></div>
644 <pre><tt>$ git bisect reset
647 Switched to branch 'master'</tt></pre>
648 </div></div>
649 <h3 id="_driving_a_bisection_automatically">Driving a bisection automatically</h3><div style="clear:left"></div>
651 to launch a script or command at each bisection step to know if the
659 $
660 $ git bisect run grep '^SUBLEVEL = 25' Makefile
661 running grep ^SUBLEVEL = 25 Makefile
664 running grep ^SUBLEVEL = 25 Makefile
665 SUBLEVEL = 25
668 ...
669 ...
670 running grep ^SUBLEVEL = 25 Makefile
673 running grep ^SUBLEVEL = 25 Makefile
674 2ddcca36c8bcfa251724fe342c8327451988be0d is the first bad commit
675 commit 2ddcca36c8bcfa251724fe342c8327451988be0d
679 Linux 2.6.26-rc1
681 :100644 100644 5cf8258195331a4dbdddff08b8d68642638eea57 4492984efc09ab72ff6219a7bc21fb6a957c4cd5 M Makefile
682 bisect run success</tt></pre>
683 </div></div>
685 parameter to "git bisect run". This means that at each step, the grep
686 command we passed will be launched. And if it exits with code 0 (that
687 means success) then git bisect will mark the current state as
689 included, except the special code 125), then the current state will be
692 make it stop immediately the bisection process. This is useful for
693 example if the command passed takes too long to complete, because you
694 can kill it with a signal and it will stop the bisection process.</p></div>
697 <h3 id="_avoiding_untestable_commits">Avoiding untestable commits</h3><div style="clear:left"></div>
699 example if it does not compile because there was a bug preventing it
700 at that time. This is what the special exit code 125 is for. It tells
701 "git bisect run" that the current commit should be marked as
702 untestable and that another one should be chosen and checked out.</p></div>
708 if the DISPLAY environment variable is not set) to help you find a
709 better bisection point.</p></div>
711 happen that the regression you are looking for has been introduced by
712 one of these untestable commits. In this case it’s not possible to
713 tell for sure which commit introduced the regression.</p></div>
718 <pre><tt>There are only 'skip'ped commits left to test.
719 The first bad commit could be any of:
720 15722f2fa328eaba97022898a305ffc8172db6b1
721 78e86cf3e850bd755bb71831f42e200626fbd1e0
722 e15b73ad3db9b48d7d1ade32f8cd23a751fe0ace
723 070eab2303024706f2924822bfec8b9847e4ac1b
724 We cannot bisect more!</tt></pre>
725 </div></div>
726 <h3 id="_saving_a_log_and_replaying_it">Saving a log and replaying it</h3><div style="clear:left"></div>
727 <div class="paragraph"><p>If you want to show other people your bisection process, you can get a
728 log using for example:</p></div>
732 </div></div>
737 </div></div>
738 </div>
743 best bisection commit to test at each step is not so simple. Anyway
744 Linus found and implemented a "truly stupid" algorithm, later improved
745 by Junio Hamano, that works quite well.</p></div>
747 commit when there are no skipped commits is the following:</p></div>
749 <div class="paragraph"><p>a) are ancestor of the "bad" commit (including the "bad" commit itself),
751 <div class="paragraph"><p>This means that we get rid of the uninteresting commits in the DAG.</p></div>
755 <pre><tt>G-Y-G-W-W-W-X-X-X-X
756 \ /
757 W-W-B
758 /
759 Y---G-W---W
760 \ / \
761 Y-Y X-X-X-X
764 </div></div>
766 are other commits, we will get the following graph after this first
767 step:</p></div>
770 <pre><tt>W-W-W
771 \
772 W-W-B
773 /
774 W---W</tt></pre>
775 </div></div>
776 <div class="paragraph"><p>So only the W and B commits will be kept. Because commits X and Y will
777 have been removed by rules a) and b) respectively, and because commits
778 G are removed by rule b) too.</p></div>
780 given by:</p></div>
784 </div></div>
786 descendants of a "good" commit. So in the following example, commits W
787 and Z will be kept:</p></div>
790 <pre><tt>G-W-W-W-B
791 /
792 Z-Z</tt></pre>
793 </div></div>
795 commit the number of ancestors it has plus one</p></div>
796 <div class="paragraph"><p>For example with the following graph where H is the "bad" commit and A
800 <pre><tt>A-B-C
801 \
802 F-G-H
803 /
804 D---E</tt></pre>
805 </div></div>
810 A-B-C
811 \6 7 8
812 F-G-H
813 1 2/
814 D---E</tt></pre>
815 </div></div>
818 total number of commits in the graph.</p></div>
823 A-B-C
824 \2 1 0
825 F-G-H
826 1 2/
827 D---E</tt></pre>
828 </div></div>
830 number</p></div>
831 <div class="paragraph"><p>So in the above example the best bisection point is commit C.</p></div>
832 <div class="paragraph"><p>5) note that some shortcuts are implemented to speed up the algorithm</p></div>
833 <div class="paragraph"><p>As we know N from the beginning, we know that min(X, N - X) can’t be
835 to a commit, then we know this is the best bisection point. So in this
836 case we can just stop processing any other commit and return the
837 current commit.</p></div>
838 <h3 id="_bisection_algorithm_debugging">Bisection algorithm debugging</h3><div style="clear:left"></div>
845 </div></div>
852 a1939d9a142de972094af4dde9a544e577ddef0e (dist=2)
854 a3864d4f32a3bf5ed177ddef598490a08760b70d (dist=1)
855 a41baa717dd74f1180abf55e9341bc7a0bb9d556 (dist=1)
857 </div></div>
858 <h3 id="_bisection_algorithm_discussed">Bisection algorithm discussed</h3><div style="clear:left"></div>
859 <div class="paragraph"><p>First let’s define "best bisection point". We will say that a commit X
860 is a best bisection point or a best bisection commit if knowing its
864 following function is maximum:</p></div>
868 </div></div>
870 and information_if_bad(X) is the information we get if X is bad.</p></div>
872 means that all its descendants are "bad" and all the other commits are
873 "good". And we will suppose that all commits have an equal probability
874 of being good or bad, or of being the first bad commit, so knowing the
875 state of c commits gives always the same amount of information
876 wherever these c commits are on the graph and whatever c is. (So we
877 suppose that these commits being for example on a branch or near a
878 good or a bad commit does not give more or less information).</p></div>
879 <div class="paragraph"><p>Let’s also suppose that we have a cleaned up graph like one after step
880 1) in the bisection algorithm above. This means that we can measure
881 the information we get in terms of number of commit we can remove from
882 the graph..</p></div>
889 </div></div>
897 </div></div>
899 the bad commit. So we get more information when a commit is marked as
901 commit that are not ancestors of the new "bad" commit are not the
902 first bad commit. We don’t know if they are good or bad, but we know
903 that they are not the first bad commit because they are not ancestor
906 commits in the graph except those that are ancestors of the new "bad"
907 commit. This means that:</p></div>
911 </div></div>
914 should maximize the function:</p></div>
918 </div></div>
924 <pre><tt> G-H-I-J
925 / \
926 A-B-C-D-E-F O
927 \ /
928 K-L-M-N</tt></pre>
929 </div></div>
934 </div></div>
939 G-H-I-J
941 A-B-C-D-E-F O
942 \ /
943 K-L-M-N
945 </div></div>
950 G-H-I-J
952 A-B-C-D-E-F O
953 \ /
954 K-L-M-N
956 </div></div>
958 than F. Because if for example L is bad, then we will know not only
959 that L, M and N are bad but also that G, H, I and J are not the first
960 bad commit (since we suppose that there is only one first bad commit
961 and it must be an ancestor of L).</p></div>
963 initially supposed.</p></div>
967 roughly the following steps:</p></div>
969 <div class="paragraph"><p>7) if the first commit has not been skipped, we can return it and stop
970 here</p></div>
971 <div class="paragraph"><p>8) otherwise filter out all the skipped commits in the sorted list</p></div>
974 <div class="paragraph"><p>10) multiply this random number with its square root to bias it toward
977 to get an index into this list</p></div>
981 commit has been skipped and return it if it is not the case. And in
982 fact that was the algorithm we used from when "git bisect skip" was
986 developer) both complained that sometimes the best bisection points
987 all happened to be in an area where all the commits are
988 untestable. And in this case the user was asked to test many
989 untestable commits, which could be very inefficient.</p></div>
991 introduced at one time, and that breakage was fixed only after many
992 other commits were introduced.</p></div>
994 we are trying to locate in the commit graph. But it prevents us to
997 probability of being untestable themselves. And the best bisection
998 commits are often found together too (due to the bisection algorithm).</p></div>
1000 bisection commit when the first one has been skipped.</p></div>
1002 information when they are tested. And the commits that will not on
1003 average give a lot of information are the one near the good and bad
1004 commits.</p></div>
1006 bad commits looked like a good choice.</p></div>
1008 commit that has an associated value near the one of the best bisection
1009 commit, and that is on another branch, before using the PRNG. Because
1010 if such a commit exists, then it is not very likely to be untestable
1011 too, so it will probably give more information than a nearly randomly
1012 chosen one.</p></div>
1020 because the ancestors of the good commits are supposed to be
1022 They cannot be on a branch that has no link with the branch of the
1023 "bad" commit. But it is possible for a good commit to be related to a
1024 bad commit and yet not be neither one of its ancestor nor one of its
1025 descendants.</p></div>
1026 <div class="paragraph"><p>For example, there can be a "main" branch, and a "dev" branch that was
1031 \
1033 </div></div>
1036 <div class="paragraph"><p>Now let’s suppose that commit J is bad and commit G is good and that
1037 we apply the bisection algorithm like it has been previously
1038 described.</p></div>
1040 the ancestors of the good commits because they are supposed to be good
1041 too.</p></div>
1046 </div></div>
1052 are not aware that people working on another branch fixed a bug! It
1053 could also happen that F fixed more than one bug or that it is a
1054 revert of some big development effort that was not ready to be
1055 released.</p></div>
1056 <div class="paragraph"><p>In fact development teams often maintain both a development branch and
1057 a maintenance branch, and it would be quite easy for them if "git
1058 bisect" just worked when they want to bisect a regression on the
1059 development branch that is not on the maintenance branch. They should
1060 be able to start bisecting using:</p></div>
1064 </div></div>
1066 and when some good commits are not ancestors of the bad commit, we
1067 first compute the merge bases between the bad and the good commits and
1068 we chose these merge bases as the first commits that will be checked
1069 out and tested.</p></div>
1071 is stopped with a message like:</p></div>
1074 <pre><tt>The merge base BBBBBB is bad.
1075 This means the bug has been fixed between BBBBBB and [GGGGGG,...].</tt></pre>
1076 </div></div>
1077 <div class="paragraph"><p>where BBBBBB is the sha1 hash of the bad merge base and [GGGGGG,…]
1078 is a comma separated list of the sha1 of the good commits.</p></div>
1080 continues, but the following message is printed for each skipped merge
1081 base:</p></div>
1084 <pre><tt>Warning: the merge base between BBBBBB and [GGGGGG,...] must be skipped.
1085 So we cannot be sure the first bad commit is between MMMMMM and BBBBBB.
1086 We continue anyway.</tt></pre>
1087 </div></div>
1089 hash of the merge base that is skipped and [GGGGGG,…] is a comma
1090 separated list of the sha1 of the good commits.</p></div>
1092 usual after this step.</p></div>
1093 </div>
1096 <h3 id="_using_test_suites_and_git_bisect_together">Using test suites and git bisect together</h3><div style="clear:left"></div>
1097 <div class="paragraph"><p>If you both have a test suite and use git bisect, then it becomes less
1098 important to check that all tests pass after each commit. Though of
1099 course it is probably a good idea to have some checks to avoid
1100 breaking too many things because it could make bisecting other bugs
1101 more difficult.</p></div>
1103 and beta releases) that all the T test cases pass for all the N
1109 </div></div>
1110 <div class="paragraph"><p>where c is the number of rounds of test (so a small constant) and b is
1111 the ratio of bug per commit (hopefully a small constant too).</p></div>
1112 <div class="paragraph"><p>So of course it’s much better as it’s O(N * T) vs O(N * T * M) if
1113 you would test everything after each commit.</p></div>
1115 committed and they are also quite good to tell you that you have some
1116 bugs. But they are not so good to tell you where some bugs have been
1117 introduced. To tell you that efficiently, git bisect is needed.</p></div>
1118 <div class="paragraph"><p>The other nice thing with test suites, is that when you have one, you
1119 already know how to test for bad behavior. So you can use this
1120 knowledge to create a new test case for "git bisect" when it appears
1121 that there is a regression. So it will be easier to bisect the bug and
1122 fix it. And then you can add the test case you just created to your
1123 test suite.</p></div>
1124 <div class="paragraph"><p>So if you know how to create test cases and how to bisect, you will be
1125 subject to a virtuous circle:</p></div>
1126 <div class="paragraph"><p>more tests ⇒ easier to create tests ⇒ easier to bisect ⇒ more tests</p></div>
1127 <div class="paragraph"><p>So test suites and "git bisect" are complementary tools that are very
1128 powerful and efficient when used together.</p></div>
1130 <div class="paragraph"><p>You can very easily automatically bisect broken builds using something
1131 like:</p></div>
1134 <pre><tt>$ git bisect start BAD GOOD
1135 $ git bisect run make</tt></pre>
1136 </div></div>
1137 <h3 id="_passing_sh_c_some_commands_to_git_bisect_run">Passing sh -c "some commands" to "git bisect run"</h3><div style="clear:left"></div>
1142 </div></div>
1144 scripts to avoid too much typing.</p></div>
1145 <h3 id="_finding_performance_regressions">Finding performance regressions</h3><div style="clear:left"></div>
1148 <div class="paragraph"><p>This script can be passed to "git bisect run" to find the commit that
1149 introduced a performance regression:</p></div>
1152 <pre><tt>#!/bin/sh
1154 # Build errors are not what I am interested in.
1155 make my_app || exit 255
1157 # We are checking if it stops in a reasonable amount of time, so
1158 # let it run in the background...
1162 # ... and grab its process ID.
1163 pid=$!
1165 # ... and then wait for sufficiently long.
1166 sleep $NORMAL_TIME
1168 # ... and then see if the process is still there.
1169 if kill -0 $pid
1170 then
1171 # It is still running -- that is bad.
1172 kill $pid; sleep 1; kill $pid;
1173 exit 1
1174 else
1175 # It has already finished (the $pid process was no more),
1176 # and we are happy.
1177 exit 0
1178 fi</tt></pre>
1179 </div></div>
1180 <h3 id="_following_general_best_practices">Following general best practices</h3><div style="clear:left"></div>
1182 knowingly break things, even if some other commits later fix the
1183 breakage.</p></div>
1185 logical change in each commit.</p></div>
1188 first place, as small changes are easier to review even if they are
1189 only reviewed by the committer.</p></div>
1191 helpful to understand why some changes were made.</p></div>
1192 <div class="paragraph"><p>These general best practices are very helpful if you bisect often.</p></div>
1193 <h3 id="_avoiding_bug_prone_merges">Avoiding bug prone merges</h3><div style="clear:left"></div>
1195 the merge needs no source code conflict resolution. This is because a
1196 semantic change can happen in one branch while the other branch is not
1197 aware of it.</p></div>
1198 <div class="paragraph"><p>For example one branch can change the semantic of a function while the
1199 other branch add more calls to the same function.</p></div>
1202 make regressions very difficult to track down. It can even be
1203 misleading to know the first bad commit if it happens to be such a
1204 merge, because people might think that the bug comes from bad conflict
1205 resolution when it comes from a semantic change in one branch.</p></div>
1206 <div class="paragraph"><p>Anyway "git rebase" can be used to linearize history. This can be used
1207 either to avoid merging in the first place. Or it can be used to
1208 bisect on a linear history instead of the non linear one, as this
1209 should give more information in case of a semantic change in one
1210 branch.</p></div>
1211 <div class="paragraph"><p>Merges can be also made simpler by using smaller branches or by using
1212 many topic branches instead of only long version related branches.</p></div>
1214 like linux-next for the linux kernel.</p></div>
1216 <div class="paragraph"><p>A special work-flow to process regressions can give great results.</p></div>
1217 <div class="paragraph"><p>Here is an example of a work-flow used by Andreas Ericsson:</p></div>
1219 <li>
1220 <p>
1221 write, in the test suite, a test script that exposes the regression
1222 </p>
1223 </li>
1224 <li>
1225 <p>
1226 use "git bisect run" to find the commit that introduced it
1227 </p>
1228 </li>
1229 <li>
1230 <p>
1231 fix the bug that is often made obvious by the previous step
1232 </p>
1233 </li>
1234 <li>
1235 <p>
1236 commit both the fix and the test script (and if needed more tests)
1237 </p>
1238 </li>
1239 </ul></div>
1240 <div class="paragraph"><p>And here is what Andreas said about this work-flow <a href="#5">[5]</a>:</p></div>
1244 cycle of 142.6 hours (according to our somewhat weird bug-tracker
1245 which just measures wall-clock time). Since we moved to git, we’ve
1246 lowered that to 16.2 hours. Primarily because we can stay on top of
1247 the bug fixing now, and because everyone’s jockeying to get to fix
1248 bugs (we’re quite proud of how lazy we are to let git find the bugs
1249 for us). Each new release results in ~40% fewer bugs (almost certainly
1250 due to how we now feel about writing tests).</p></div>
1251 </div>
1253 </div></div>
1255 and "git bisect". In fact it makes it the standard procedure to deal
1256 with regression.</p></div>
1257 <div class="paragraph"><p>In other messages Andreas says that they also use the "best practices"
1258 described above: small logical commits, topic branches, no evil
1259 merge,… These practices all improve the bisectability of the commit
1260 graph, by making it easier and more useful to bisect.</p></div>
1262 is making bisecting easier, more useful and standard.</p></div>
1263 <h3 id="_involving_qa_people_and_if_possible_end_users">Involving QA people and if possible end users</h3><div style="clear:left"></div>
1265 tool. It can effectively be used by QA people or even end users (if
1266 they have access to the source code or if they can get access to all
1267 the builds).</p></div>
1269 of whether it was ok to always ask end user to bisect, and very good
1270 points were made to support the point of view that it is ok.</p></div>
1274 <div class="paragraph"><p>What people don’t get is that this is a situation where the "end node
1275 principle" applies. When you have limited resources (here: developers)
1276 you don’t push the bulk of the burden upon them. Instead you push
1277 things out to the resource you have a lot of, the end nodes (here:
1278 users), so that the situation actually scales.</p></div>
1279 </div>
1281 </div></div>
1282 <div class="paragraph"><p>This means that it is often "cheaper" if QA people or end users can do
1283 it.</p></div>
1284 <div class="paragraph"><p>What is interesting too is that end users that are reporting bugs (or
1285 QA people that reproduced a bug) have access to the environment where
1286 the bug happens. So they can often more easily reproduce a
1287 regression. And if they can bisect, then more information will be
1288 extracted from the environment where the bug happens, which means that
1289 it will be easier to understand and then fix the bug.</p></div>
1291 contributions from end users, and to introduce them to QA and
1292 development activities.</p></div>
1295 complex scripts to be able to fully automate bisecting.</p></div>
1296 <div class="paragraph"><p>Here is what Ingo Molnar says about that <a href="#7">[7]</a>:</p></div>
1299 <div class="paragraph"><p>i have a fully automated bootup-hang bisection script. It is based on
1300 "git-bisect run". I run the script, it builds and boots kernels fully
1301 automatically, and when the bootup fails (the script notices that via
1302 the serial log, which it continuously watches - or via a timeout, if
1304 the script raises my attention via a beep and i power cycle the test
1305 box. (yeah, i should make use of a managed power outlet to 100%
1306 automate it)</p></div>
1307 </div>
1309 </div></div>
1310 <h3 id="_combining_test_suites_git_bisect_and_other_systems_together">Combining test suites, git bisect and other systems together</h3><div style="clear:left"></div>
1312 used together. It can be even more powerful if you can combine them
1313 with other systems.</p></div>
1314 <div class="paragraph"><p>For example some test suites could be run automatically at night with
1315 some unusual (or even random) configurations. And if a regression is
1316 found by a test suite, then "git bisect" can be automatically
1317 launched, and its result can be emailed to the author of the first bad
1318 commit found by "git bisect", and perhaps other people too. And a new
1319 entry in the bug tracking system could be automatically created too.</p></div>
1320 </div>
1325 avoid areas in the commit graph where commits are untestable. The
1326 problem is that sometimes the first bad commit will be in an
1327 untestable area.</p></div>
1328 <div class="paragraph"><p>To simplify the discussion we will suppose that the untestable area is
1329 a simple string of commits and that it was created by a breakage
1330 introduced by one commit (let’s call it BBC for bisect breaking
1331 commit) and later fixed by another one (let’s call it BFC for bisect
1332 fixing commit).</p></div>
1337 </div></div>
1339 X6 are untestable.</p></div>
1340 <div class="paragraph"><p>In this case if you are bisecting manually, what you can do is create
1341 a special branch that starts just before the BBC. The first commit in
1342 this branch should be the BBC with the BFC squashed into it. And the
1343 other commits in the branch should be the commits between BBC and BFC
1344 rebased on the first commit of the branch and then the commit after
1345 BFC also rebased on.</p></div>
1349 <pre><tt> (BBC+BFC)-X1'-X2'-X3'-X4'-X5'-X6'-Z'
1350 /
1351 ...-Y-BBC-X1-X2-X3-X4-X5-X6-BFC-Z-...</tt></pre>
1352 </div></div>
1354 <div class="paragraph"><p>You can easily create such a branch with Git using interactive rebase.</p></div>
1359 </div></div>
1361 <div class="paragraph"><p>After that you can start bisecting as usual in the new branch and you
1362 should eventually find the first bad commit.</p></div>
1367 </div></div>
1368 <div class="paragraph"><p>If you are using "git bisect run", you can use the same manual fix up
1369 as above, and then start another "git bisect run" in the special
1370 branch. Or as the "git bisect" man page says, the script passed to
1371 "git bisect run" can apply a patch before it compiles and test the
1374 "git bisect" will be able to find the first bad commit. And the script
1375 should not forget to remove the patch once the testing is done before
1376 exiting from the script.</p></div>
1378 apply the fix, and in this case you should use "git reset --hard
1379 HEAD^" to revert the cherry-pick after testing and before returning
1380 from the script.)</p></div>
1382 clunky. Using special branches is nice because these branches can be
1383 shared by developers like usual branches, but the risk is that people
1384 will get many such branches. And it disrupts the normal "git bisect"
1385 work-flow. So, if you want to use "git bisect run" completely
1386 automatically, you have to add special code in your script to restart
1387 bisection in the special branches.</p></div>
1388 <div class="paragraph"><p>Anyway one can notice in the above special branch example that the Z'
1389 and Z commits should point to the same source code state (the same
1391 same changes as Z just in a slightly different order.</p></div>
1393 not need to add anything to a script. It would just work for anyone in
1394 the project sharing the special branches and the replacements.</p></div>
1398 <pre><tt> (BBC+BFC)-X1'-X2'-X3'-X4'-X5'-X6'-Z'-...
1399 /
1400 ...-Y-BBC-X1-X2-X3-X4-X5-X6-BFC-Z</tt></pre>
1401 </div></div>
1402 <div class="paragraph"><p>That’s why the "git replace" command was created. Technically it
1405 (that are stored in "refs/tags"), and that means that they can
1406 automatically be shared like branches or tags among developers.</p></div>
1408 commits in already released history, for example to change the commit
1409 message or the author. And it can also be used instead of git "grafts"
1410 to link a repository with another old repository.</p></div>
1411 <div class="paragraph"><p>In fact it’s this last feature that "sold" it to the git community, so
1415 replacements refs in "refs/replace/", but it would be perhaps better
1416 if the replacement refs that are useful only for bisecting would be in
1417 "refs/replace/bisect/". This way the replacement refs could be used
1418 only for bisecting, while other refs directly in "refs/replace/" would
1419 be used nearly all the time.</p></div>
1422 add some redundancy to the tests performed so that it would be more
1423 reliable when tracking sporadic bugs.</p></div>
1425 called sporadic bugs do not appear in all the kernel builds because
1426 they are very dependent on the compiler output.</p></div>
1427 <div class="paragraph"><p>The idea is that every 3 test for example, "git bisect" could ask the
1428 user to test a commit that has already been found to be "good" or
1429 "bad" (because one of its descendants or one of its ancestors has been
1431 has been previously incorrectly classified then the bisection can be
1432 aborted early, hopefully before too many mistakes have been made. Then
1433 the user will have to look at what happened and then restart the
1434 bisection using a fixed bisect log.</p></div>
1435 <div class="paragraph"><p>There is already a project called BBChop created by Ealdwulf Wuffinga
1436 on Github that does something like that using Bayesian Search Theory
1440 <div class="paragraph"><p>BBChop is like <em>git bisect</em> (or equivalent), but works when your bug
1441 is intermittent. That is, it works in the presence of false negatives
1442 (when a version happens to work this time even though it contains the
1443 bug). It assumes that there are no false positives (in principle, the
1444 same approach would work, but adding it may be non-trivial).</p></div>
1445 </div>
1447 </div></div>
1449 users to have something integrated in Git.</p></div>
1450 </div>
1453 <div class="paragraph"><p>We have seen that regressions are an important problem, and that "git
1454 bisect" has nice features that complement very well practices and
1455 other tools, especially test suites, that are generally used to fight
1456 regressions. But it might be needed to change some work-flows and
1457 (bad) habits to get the most out of it.</p></div>
1459 and some new features could help in some cases, but overall "git
1460 bisect" works already very well, is used a lot, and is already very
1461 useful. To back up that last claim, let’s give the final word to Ingo
1462 Molnar when he was asked by the author how much time does he think
1467 <div class="paragraph"><p>About ten years ago did i do my first <em>bisection</em> of a Linux patch
1468 queue. That was prior the Git (and even prior the BitKeeper) days. I
1469 literally days spent sorting out patches, creating what in essence
1470 were standalone commits that i guessed to be related to that bug.</p></div>
1471 <div class="paragraph"><p>It was a tool of absolute last resort. I’d rather spend days looking
1473 <div class="paragraph"><p>With Git bisect it’s a breeze: in the best case i can get a ~15 step
1475 manual help or when bisecting multiple, overlapping bugs, it’s rarely
1476 more than an hour.</p></div>
1477 <div class="paragraph"><p>In fact it’s invaluable because there are bugs i would never even
1479 patterns that were immediately hopeless for me to debug - at best i
1480 could send the crash/bug signature to lkml and hope that someone else
1481 can think of something.</p></div>
1483 about the bug: that it’s non-deterministic - timing or kernel image
1484 layout dependent.</p></div>
1485 <div class="paragraph"><p>So git bisect is unconditional goodness - and feel free to quote that
1486 ;-)</p></div>
1487 </div>
1489 </div></div>
1490 </div>
1493 <div class="paragraph"><p>Many thanks to Junio Hamano for his help in reviewing this paper, for
1494 reviewing the patches I sent to the git mailing list, for discussing
1495 some ideas and helping me improve them, for improving "git bisect" a
1496 lot and for his awesome work in maintaining and developing Git.</p></div>
1497 <div class="paragraph"><p>Many thanks to Ingo Molnar for giving me very useful information that
1498 appears in this paper, for commenting on this paper, for his
1500 on the linux kernel mailing lists.</p></div>
1504 another when I worked on git, especially to Andreas Ericsson, Johannes
1505 Schindelin, H. Peter Anvin, Daniel Barkalow, Bill Lear, John Hawley,
1506 Shawn O. Pierce, Jeff King, Sam Vilain, Jon Seymour.</p></div>
1508 author to given a talk and for publishing this paper.</p></div>
1509 </div>
1513 <li>
1514 <p>
1515 <a id="1"></a>[1] <a href="http://www.nist.gov/public_affairs/releases/n02-10.htm"><em>Software Errors Cost U.S. Economy $59.5 Billion Annually</em>. Nist News Release.</a>
1516 </p>
1517 </li>
1518 <li>
1519 <p>
1520 <a id="2"></a>[2] <a href="http://java.sun.com/docs/codeconv/html/CodeConventions.doc.html#16712"><em>Code Conventions for the Java Programming Language</em>. Sun Microsystems.</a>
1521 </p>
1522 </li>
1523 <li>
1524 <p>
1525 <a id="3"></a>[3] <a href="http://en.wikipedia.org/wiki/Software_maintenance"><em>Software maintenance</em>. Wikipedia.</a>
1526 </p>
1527 </li>
1528 <li>
1529 <p>
1530 <a id="4"></a>[4] <a href="http://article.gmane.org/gmane.comp.version-control.git/45195/">Junio C Hamano. <em>Automated bisect success story</em>. Gmane.</a>
1531 </p>
1532 </li>
1533 <li>
1534 <p>
1535 <a id="5"></a>[5] <a href="http://lwn.net/Articles/317154/">Christian Couder. <em>Fully automated bisecting with "git bisect run"</em>. LWN.net.</a>
1536 </p>
1537 </li>
1538 <li>
1539 <p>
1540 <a id="6"></a>[6] <a href="http://lwn.net/Articles/277872/">Jonathan Corbet. <em>Bisection divides users and developers</em>. LWN.net.</a>
1541 </p>
1542 </li>
1543 <li>
1544 <p>
1545 <a id="7"></a>[7] <a href="http://article.gmane.org/gmane.linux.scsi/36652/">Ingo Molnar. <em>Re: BUG 2.6.23-rc3 can’t see sd partitions on Alpha</em>. Gmane.</a>
1546 </p>
1547 </li>
1548 <li>
1549 <p>
1550 <a id="8"></a>[8] <a href="http://www.kernel.org/pub/software/scm/git/docs/git-bisect.html">Junio C Hamano and the git-list. <em>git-bisect(1) Manual Page</em>. Linux Kernel Archives.</a>
1551 </p>
1552 </li>
1553 <li>
1554 <p>
1555 <a id="9"></a>[9] <a href="http://github.com/Ealdwulf/bbchop">Ealdwulf. <em>bbchop</em>. GitHub.</a>
1556 </p>
1557 </li>
1558 </ul></div>
1559 </div>
1563 </div>
1564 </div>
1565 </body>
1566 </html>