| blob | 9fcc46b429f3373f4dd937fb319f232c911f6db5 |
4 <head>
8 /* Debug borders */
10 /*
11 border: 1px solid red;
12 */
13 }
15 body {
17 }
19 a {
22 }
25 }
27 em {
29 }
31 strong {
33 }
35 tt {
37 }
45 }
49 }
50 h2 {
52 }
53 h3 {
55 }
56 h3 + * {
58 }
63 }
65 hr {
67 }
69 p {
72 }
74 pre {
77 }
79 span#author {
84 }
85 span#email {
86 }
87 span#revision {
89 }
91 div#footer {
97 }
98 div#footer-text {
101 }
102 div#footer-badges {
105 }
107 div#preamble,
114 }
118 }
122 }
124 /* Block element titles. */
131 }
134 }
138 }
141 }
144 }
150 }
154 }
159 }
163 }
167 }
170 }
179 }
183 }
188 }
192 }
198 dl {
201 }
202 dt {
206 }
209 }
213 }
216 }
220 }
221 thead {
224 }
225 tfoot {
227 }
232 }
235 }
240 }
243 }
247 }
249 div#toctitle {
256 }
261 }
265 }
269 }
273 }
274 /* Workarounds for IE6's broken and incomplete CSS2. */
280 }
286 }
292 }
296 }
301 }
303 /* IE6 sets dynamically generated links as visited. */
305 </style>
307 </head>
308 <body>
312 <span id="email"><tt><<a href="mailto:chriscool@tuxfamily.org">chriscool@tuxfamily.org</a>></tt></span><br />
314 </div>
318 commit that introduced a regression. We show why it is important to
319 have good tools to fight regressions. We describe how "git bisect"
320 works from the outside and the algorithms it uses inside. Then we
321 explain how to take advantage of "git bisect" to improve current
322 practices. And we discuss how "git bisect" could improve in the
323 future.</p></div>
324 </div>
328 Torvalds and maintained by Junio Hamano.</p></div>
330 states of the data that is managed by the system are called
331 commits. And, as VCS are mostly used to manage software source code,
332 sometimes "interesting" changes of behavior in the software are
333 introduced in some commits.</p></div>
335 "bad" behavior, called a bug or a regression. They are interested in
336 these commits because a commit (hopefully) contains a very small set
337 of source code changes. And it's much easier to understand and
338 properly fix a problem when you only need to check a very small set of
339 changes, than when you don't know where look in the first place.</p></div>
341 "git bisect" set of commands was invented. And it follows of course
344 called "good" commits. And a commit that introduce the behavior we are
345 interested in is called a "first bad commit". Note that there could be
348 be as efficient as possible, it tries to perform a binary search.</p></div>
349 </div>
352 <h3 id="_regressions_a_big_problem">Regressions: a big problem</h3><div style="clear:left"></div>
354 difficult to put some real numbers behind that claim.</p></div>
360 they cost the U.S. economy an estimated $59.5 billion annually, or
361 about 0.6 percent of the gross domestic product, according to a newly
362 released study commissioned by the Department of Commerce's National
363 Institute of Standards and Technology (NIST). At the national level,
364 over half of the costs are borne by software users and the remainder
365 by software developers/vendors. The study also found that, although
366 all errors cannot be removed, more than a third of these costs, or an
367 estimated $22.2 billion, could be eliminated by an improved testing
368 infrastructure that enables earlier and more effective identification
369 and removal of software defects. These are the savings associated with
370 finding an increased percentage (but not 100 percent) of errors closer
371 to the development stages in which they are introduced. Currently,
372 over half of all errors are not found until "downstream" in the
373 development process or during post-sale software use.</p></div>
375 </div></div></div>
380 development costs on identifying and correcting defects, and yet few
381 products of any type other than software are shipped with such high
382 levels of errors.</p></div>
384 </div></div></div>
389 testing.</p></div>
391 </div></div></div>
398 bugs. However, studies and surveys over the years have indicated that
399 the majority, over 80%, of the maintenance effort is used for
400 non-corrective actions (Pigosky 1997). This perception is perpetuated
401 by users submitting problem reports that in reality are functionality
402 enhancements to the system.</p></div>
404 </div></div></div>
406 because you have to watch out for regressions. At least this would
407 make the above studies consistent among themselves.</p></div>
409 time without being improved on much, and then finally thrown away. In
410 this case, of course, regressions may not be a big problem. But on the
411 other hand, there is a lot of big software that is continually
412 developed and maintained during years or even tens of years by a lot
413 of people. And as there are often many people who depend (sometimes
414 critically) on such software, regressions are a really big problem.</p></div>
416 kernel, we can see that a lot of time and effort is spent to fight
417 regressions. The release cycle start with a 2 weeks long merge
418 window. Then the first release candidate (rc) version is tagged. And
420 week between each of them, before the final release.</p></div>
422 supposed to be used to test rc versions and fight bugs and especially
423 regressions. And this time is more than 80% of the release cycle
424 time. But this is not the end of the fight yet, as of course it
425 continues after the release.</p></div>
427 developer) says about his use of git bisect:</p></div>
431 get merged upstream and when the influx of bugs is the highest) - and
432 yes, there have been cases that i used it multiple times a day. My
433 average is roughly once a day.</p></div>
435 </div></div></div>
437 well known that bugs should be fixed as soon as possible, so as soon
438 as they are found. That's why it is interesting to have good tools for
439 this purpose.</p></div>
440 <h3 id="_other_tools_to_fight_regressions">Other tools to fight regressions</h3><div style="clear:left"></div>
442 same as those used to fight regular bugs. The only specific tools are
445 supposed to be used so that all the tests are checked after each
446 commit. This means that they are not very efficient, because many
447 tests are run for no interesting result, and they suffer from
448 combinational explosion.</p></div>
450 configuration options and that each test case should pass for each
451 configuration after each commit. So if you have for each release: N
452 configurations, M commits and T test cases, you should perform:</p></div>
456 </div></div>
458 <div class="para"><p>So very soon it will not be possible to completely test everything.</p></div>
460 to your test suite. But if you want to use your new improved test
461 suite to find where the bug slipped in, then you will either have to
462 emulate a bisection process or you will perhaps bluntly test each
463 commit backward starting from the "bad" commit you have which may be
464 very wasteful.</p></div>
465 </div>
470 start the search. Then bounds must be set to limit the commit
471 space. This is done usually by giving one "bad" and at least one
477 </div></div>
482 </div></div>
487 </div></div>
489 commit.</p></div>
491 user to test it, like this:</p></div>
497 </div></div>
499 will be looking for the first commit that has a version like
501 in the top level Makefile. This is a toy example because there are
502 better ways to find this commit with git than using "git bisect" (for
504 <h3 id="_driving_a_bisection_manually">Driving a bisection manually</h3><div style="clear:left"></div>
506 be driven manually by the user or it can be driven automatically by a
507 script or a command.</p></div>
511 that have been described above. For example:</p></div>
514 <pre><tt>$ git bisect bad
517 </div></div>
519 find a first bad commit:</p></div>
522 <pre><tt>$ git bisect bad
523 2ddcca36c8bcfa251724fe342c8327451988be0d is the first bad commit
524 commit 2ddcca36c8bcfa251724fe342c8327451988be0d
528 Linux 2.6.26-rc1
530 :100644 100644 5cf8258195331a4dbdddff08b8d68642638eea57 4492984efc09ab72ff6219a7bc21fb6a957c4cd5 M Makefile</tt></pre>
531 </div></div>
533 not already checked out) or tinker with it, for example:</p></div>
536 <pre><tt>$ git show HEAD
537 commit 2ddcca36c8bcfa251724fe342c8327451988be0d
541 Linux 2.6.26-rc1
543 diff --git a/Makefile b/Makefile
545 --- a/Makefile
546 +++ b/Makefile
548 VERSION = 2
549 PATCHLEVEL = 6
550 -SUBLEVEL = 25
551 -EXTRAVERSION =
552 +SUBLEVEL = 26
553 +EXTRAVERSION = -rc1
554 NAME = Funky Weasel is Jiggy wit it
556 # *DOCUMENTATION*</tt></pre>
557 </div></div>
559 the branch we were in before we started bisecting:</p></div>
562 <pre><tt>$ git bisect reset
565 Switched to branch 'master'</tt></pre>
566 </div></div>
567 <h3 id="_driving_a_bisection_automatically">Driving a bisection automatically</h3><div style="clear:left"></div>
569 to launch a script or command at each bisection step to know if the
577 $
578 $ git bisect run grep '^SUBLEVEL = 25' Makefile
579 running grep ^SUBLEVEL = 25 Makefile
582 running grep ^SUBLEVEL = 25 Makefile
583 SUBLEVEL = 25
586 ...
587 ...
588 running grep ^SUBLEVEL = 25 Makefile
591 running grep ^SUBLEVEL = 25 Makefile
592 2ddcca36c8bcfa251724fe342c8327451988be0d is the first bad commit
593 commit 2ddcca36c8bcfa251724fe342c8327451988be0d
597 Linux 2.6.26-rc1
599 :100644 100644 5cf8258195331a4dbdddff08b8d68642638eea57 4492984efc09ab72ff6219a7bc21fb6a957c4cd5 M Makefile
600 bisect run success</tt></pre>
601 </div></div>
603 parameter to "git bisect run". This means that at each step, the grep
604 command we passed will be launched. And if it exits with code 0 (that
605 means success) then git bisect will mark the current state as
607 included, except the special code 125), then the current state will be
610 make it stop immediately the bisection process. This is useful for
611 example if the command passed takes too long to complete, because you
612 can kill it with a signal and it will stop the bisection process.</p></div>
615 <h3 id="_avoiding_untestable_commits">Avoiding untestable commits</h3><div style="clear:left"></div>
617 example if it does not compile because there was a bug preventing it
618 at that time. This is what the special exit code 125 is for. It tells
619 "git bisect run" that the current commit should be marked as
620 untestable and that another one should be chosen and checked out.</p></div>
626 if the DISPLAY environment variable is not set) to help you find a
627 better bisection point.</p></div>
629 happen that the regression you are looking for has been introduced by
630 one of these untestable commits. In this case it's not possible to
631 tell for sure which commit introduced the regression.</p></div>
636 <pre><tt>There are only 'skip'ped commits left to test.
637 The first bad commit could be any of:
638 15722f2fa328eaba97022898a305ffc8172db6b1
639 78e86cf3e850bd755bb71831f42e200626fbd1e0
640 e15b73ad3db9b48d7d1ade32f8cd23a751fe0ace
641 070eab2303024706f2924822bfec8b9847e4ac1b
642 We cannot bisect more!</tt></pre>
643 </div></div>
644 <h3 id="_saving_a_log_and_replaying_it">Saving a log and replaying it</h3><div style="clear:left"></div>
646 log using for example:</p></div>
650 </div></div>
655 </div></div>
656 </div>
661 best bisection commit to test at each step is not so simple. Anyway
662 Linus found and implemented a "truly stupid" algorithm, later improved
663 by Junio Hamano, that works quite well.</p></div>
665 commit when there are no skipped commits is the following:</p></div>
669 <div class="para"><p>This means that we get rid of the uninteresting commits in the DAG.</p></div>
673 <pre><tt>G-Y-G-W-W-W-X-X-X-X
674 \ /
675 W-W-B
676 /
677 Y---G-W---W
678 \ / \
679 Y-Y X-X-X-X
682 </div></div>
684 are other commits, we will get the following graph after this first
685 step:</p></div>
688 <pre><tt>W-W-W
689 \
690 W-W-B
691 /
692 W---W</tt></pre>
693 </div></div>
695 have been removed by rules a) and b) respectively, and because commits
696 G are removed by rule b) too.</p></div>
698 given by:</p></div>
702 </div></div>
704 descendants of a "good" commit. So in the following example, commits W
705 and Z will be kept:</p></div>
708 <pre><tt>G-W-W-W-B
709 /
710 Z-Z</tt></pre>
711 </div></div>
713 commit the number of ancestors it has plus one</p></div>
718 <pre><tt>A-B-C
719 \
720 F-G-H
721 /
722 D---E</tt></pre>
723 </div></div>
728 A-B-C
729 \6 7 8
730 F-G-H
731 1 2/
732 D---E</tt></pre>
733 </div></div>
736 total number of commits in the graph.</p></div>
741 A-B-C
742 \2 1 0
743 F-G-H
744 1 2/
745 D---E</tt></pre>
746 </div></div>
748 number</p></div>
750 <div class="para"><p>5) note that some shortcuts are implemented to speed up the algorithm</p></div>
753 to a commit, then we know this is the best bisection point. So in this
754 case we can just stop processing any other commit and return the
755 current commit.</p></div>
756 <h3 id="_bisection_algorithm_debugging">Bisection algorithm debugging</h3><div style="clear:left"></div>
763 </div></div>
770 a1939d9a142de972094af4dde9a544e577ddef0e (dist=2)
772 a3864d4f32a3bf5ed177ddef598490a08760b70d (dist=1)
773 a41baa717dd74f1180abf55e9341bc7a0bb9d556 (dist=1)
775 </div></div>
776 <h3 id="_bisection_algorithm_discussed">Bisection algorithm discussed</h3><div style="clear:left"></div>
778 is a best bisection point or a best bisection commit if knowing its
782 following function is maximum:</p></div>
786 </div></div>
788 and information_if_bad(X) is the information we get if X is bad.</p></div>
790 means that all its descendants are "bad" and all the other commits are
791 "good". And we will suppose that all commits have an equal probability
792 of being good or bad, or of being the first bad commit, so knowing the
793 state of c commits gives always the same amount of information
794 wherever these c commits are on the graph and whatever c is. (So we
795 suppose that these commits being for example on a branch or near a
796 good or a bad commit does not give more or less information).</p></div>
798 1) in the bisection algorithm above. This means that we can measure
799 the information we get in terms of number of commit we can remove from
800 the graph..</p></div>
807 </div></div>
815 </div></div>
817 the bad commit. So we get more information when a commit is marked as
819 commit that are not ancestors of the new "bad" commit are not the
820 first bad commit. We don't know if they are good or bad, but we know
821 that they are not the first bad commit because they are not ancestor
824 commits in the graph except those that are ancestors of the new "bad"
825 commit. This means that:</p></div>
829 </div></div>
832 should maximize the function:</p></div>
836 </div></div>
842 <pre><tt> G-H-I-J
843 / \
844 A-B-C-D-E-F O
845 \ /
846 K-L-M-N</tt></pre>
847 </div></div>
852 </div></div>
857 G-H-I-J
859 A-B-C-D-E-F O
860 \ /
861 K-L-M-N
863 </div></div>
868 G-H-I-J
870 A-B-C-D-E-F O
871 \ /
872 K-L-M-N
874 </div></div>
876 than F. Because if for example L is bad, then we will know not only
877 that L, M and N are bad but also that G, H, I and J are not the first
878 bad commit (since we suppose that there is only one first bad commit
879 and it must be an ancestor of L).</p></div>
881 initially supposed.</p></div>
885 roughly the following steps:</p></div>
888 here</p></div>
889 <div class="para"><p>8) otherwise filter out all the skipped commits in the sorted list</p></div>
895 to get an index into this list</p></div>
899 commit has been skipped and return it if it is not the case. And in
900 fact that was the algorithm we used from when "git bisect skip" was
904 developer) both complained that sometimes the best bisection points
905 all happened to be in an area where all the commits are
906 untestable. And in this case the user was asked to test many
907 untestable commits, which could be very inefficient.</p></div>
909 introduced at one time, and that breakage was fixed only after many
910 other commits were introduced.</p></div>
912 we are trying to locate in the commit graph. But it prevents us to
915 probability of being untestable themselves. And the best bisection
916 commits are often found together too (due to the bisection algorithm).</p></div>
918 bisection commit when the first one has been skipped.</p></div>
920 information when they are tested. And the commits that will not on
921 average give a lot of information are the one near the good and bad
922 commits.</p></div>
924 bad commits looked like a good choice.</p></div>
926 commit that has an associated value near the one of the best bisection
927 commit, and that is on another branch, before using the PRNG. Because
928 if such a commit exists, then it is not very likely to be untestable
929 too, so it will probably give more information than a nearly randomly
930 chosen one.</p></div>
938 because the ancestors of the good commits are supposed to be
940 They cannot be on a branch that has no link with the branch of the
941 "bad" commit. But it is possible for a good commit to be related to a
942 bad commit and yet not be neither one of its ancestor nor one of its
943 descendants.</p></div>
949 \
951 </div></div>
953 because it's the best common ancestor for these branches for a merge.</p></div>
955 we apply the bisection algorithm like it has been previously
956 described.</p></div>
958 the ancestors of the good commits because they are supposed to be good
959 too.</p></div>
964 </div></div>
968 the first bad commit, when in fact it's B. So that would be wrong!</p></div>
970 are not aware that people working on another branch fixed a bug! It
971 could also happen that F fixed more than one bug or that it is a
972 revert of some big development effort that was not ready to be
973 released.</p></div>
975 a maintenance branch, and it would be quite easy for them if "git
976 bisect" just worked when they want to bisect a regression on the
977 development branch that is not on the maintenance branch. They should
978 be able to start bisecting using:</p></div>
982 </div></div>
984 and when some good commits are not ancestors of the bad commit, we
985 first compute the merge bases between the bad and the good commits and
986 we chose these merge bases as the first commits that will be checked
987 out and tested.</p></div>
989 is stopped with a message like:</p></div>
992 <pre><tt>The merge base BBBBBB is bad.
993 This means the bug has been fixed between BBBBBB and [GGGGGG,...].</tt></pre>
994 </div></div>
996 is a comma separated list of the sha1 of the good commits.</p></div>
998 continues, but the following message is printed for each skipped merge
999 base:</p></div>
1002 <pre><tt>Warning: the merge base between BBBBBB and [GGGGGG,...] must be skipped.
1003 So we cannot be sure the first bad commit is between MMMMMM and BBBBBB.
1004 We continue anyway.</tt></pre>
1005 </div></div>
1007 hash of the merge base that is skipped and [GGGGGG,…] is a comma
1008 separated list of the sha1 of the good commits.</p></div>
1010 usual after this step.</p></div>
1011 </div>
1014 <h3 id="_using_test_suites_and_git_bisect_together">Using test suites and git bisect together</h3><div style="clear:left"></div>
1016 important to check that all tests pass after each commit. Though of
1017 course it is probably a good idea to have some checks to avoid
1018 breaking too many things because it could make bisecting other bugs
1019 more difficult.</p></div>
1021 and beta releases) that all the T test cases pass for all the N
1022 configurations. And when some tests don't pass you can use "git
1027 </div></div>
1029 the ratio of bug per commit (hopefully a small constant too).</p></div>
1030 <div class="para"><p>So of course it's much better as it's O(N <strong> T) vs O(N </strong> T * M) if
1031 you would test everything after each commit.</p></div>
1033 committed and they are also quite good to tell you that you have some
1034 bugs. But they are not so good to tell you where some bugs have been
1035 introduced. To tell you that efficiently, git bisect is needed.</p></div>
1037 already know how to test for bad behavior. So you can use this
1038 knowledge to create a new test case for "git bisect" when it appears
1039 that there is a regression. So it will be easier to bisect the bug and
1040 fix it. And then you can add the test case you just created to your
1041 test suite.</p></div>
1043 subject to a virtuous circle:</p></div>
1044 <div class="para"><p>more tests => easier to create tests => easier to bisect => more tests</p></div>
1046 powerful and efficient when used together.</p></div>
1049 like:</p></div>
1052 <pre><tt>$ git bisect start BAD GOOD
1053 $ git bisect run make</tt></pre>
1054 </div></div>
1055 <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>
1060 </div></div>
1062 scripts to avoid too much typing.</p></div>
1063 <h3 id="_finding_performance_regressions">Finding performance regressions</h3><div style="clear:left"></div>
1067 introduced a performance regression:</p></div>
1070 <pre><tt>#!/bin/sh
1072 # Build errors are not what I am interested in.
1073 make my_app || exit 255
1075 # We are checking if it stops in a reasonable amount of time, so
1076 # let it run in the background...
1080 # ... and grab its process ID.
1081 pid=$!
1083 # ... and then wait for sufficiently long.
1084 sleep $NORMAL_TIME
1086 # ... and then see if the process is still there.
1087 if kill -0 $pid
1088 then
1089 # It is still running -- that is bad.
1090 kill $pid; sleep 1; kill $pid;
1091 exit 1
1092 else
1093 # It has already finished (the $pid process was no more),
1094 # and we are happy.
1095 exit 0
1096 fi</tt></pre>
1097 </div></div>
1098 <h3 id="_following_general_best_practices">Following general best practices</h3><div style="clear:left"></div>
1100 knowingly break things, even if some other commits later fix the
1101 breakage.</p></div>
1103 logical change in each commit.</p></div>
1106 first place, as small changes are easier to review even if they are
1107 only reviewed by the committer.</p></div>
1109 helpful to understand why some changes were made.</p></div>
1110 <div class="para"><p>These general best practices are very helpful if you bisect often.</p></div>
1111 <h3 id="_avoiding_bug_prone_merges">Avoiding bug prone merges</h3><div style="clear:left"></div>
1113 the merge needs no source code conflict resolution. This is because a
1114 semantic change can happen in one branch while the other branch is not
1115 aware of it.</p></div>
1117 other branch add more calls to the same function.</p></div>
1119 conflicts. That's why such merges are called "evil merges". They can
1120 make regressions very difficult to track down. It can even be
1121 misleading to know the first bad commit if it happens to be such a
1122 merge, because people might think that the bug comes from bad conflict
1123 resolution when it comes from a semantic change in one branch.</p></div>
1125 either to avoid merging in the first place. Or it can be used to
1126 bisect on a linear history instead of the non linear one, as this
1127 should give more information in case of a semantic change in one
1128 branch.</p></div>
1130 many topic branches instead of only long version related branches.</p></div>
1132 like linux-next for the linux kernel.</p></div>
1134 <div class="para"><p>A special work-flow to process regressions can give great results.</p></div>
1137 <li>
1138 <p>
1139 write, in the test suite, a test script that exposes the regression
1140 </p>
1141 </li>
1142 <li>
1143 <p>
1144 use "git bisect run" to find the commit that introduced it
1145 </p>
1146 </li>
1147 <li>
1148 <p>
1149 fix the bug that is often made obvious by the previous step
1150 </p>
1151 </li>
1152 <li>
1153 <p>
1154 commit both the fix and the test script (and if needed more tests)
1155 </p>
1156 </li>
1157 </ul></div>
1158 <div class="para"><p>And here is what Andreas said about this work-flow <a href="#5">[5]</a>:</p></div>
1162 cycle of 142.6 hours (according to our somewhat weird bug-tracker
1163 which just measures wall-clock time). Since we moved to git, we've
1164 lowered that to 16.2 hours. Primarily because we can stay on top of
1165 the bug fixing now, and because everyone's jockeying to get to fix
1166 bugs (we're quite proud of how lazy we are to let git find the bugs
1167 for us). Each new release results in ~40% fewer bugs (almost certainly
1168 due to how we now feel about writing tests).</p></div>
1170 </div></div></div>
1172 and "git bisect". In fact it makes it the standard procedure to deal
1173 with regression.</p></div>
1175 described above: small logical commits, topic branches, no evil
1176 merge,… These practices all improve the bisectability of the commit
1177 graph, by making it easier and more useful to bisect.</p></div>
1179 is making bisecting easier, more useful and standard.</p></div>
1180 <h3 id="_involving_qa_people_and_if_possible_end_users">Involving QA people and if possible end users</h3><div style="clear:left"></div>
1182 tool. It can effectively be used by QA people or even end users (if
1183 they have access to the source code or if they can get access to all
1184 the builds).</p></div>
1186 of whether it was ok to always ask end user to bisect, and very good
1187 points were made to support the point of view that it is ok.</p></div>
1192 principle" applies. When you have limited resources (here: developers)
1193 you don't push the bulk of the burden upon them. Instead you push
1194 things out to the resource you have a lot of, the end nodes (here:
1195 users), so that the situation actually scales.</p></div>
1197 </div></div></div>
1199 it.</p></div>
1201 QA people that reproduced a bug) have access to the environment where
1202 the bug happens. So they can often more easily reproduce a
1203 regression. And if they can bisect, then more information will be
1204 extracted from the environment where the bug happens, which means that
1205 it will be easier to understand and then fix the bug.</p></div>
1207 contributions from end users, and to introduce them to QA and
1208 development activities.</p></div>
1211 complex scripts to be able to fully automate bisecting.</p></div>
1216 "git-bisect run". I run the script, it builds and boots kernels fully
1217 automatically, and when the bootup fails (the script notices that via
1218 the serial log, which it continuously watches - or via a timeout, if
1220 the script raises my attention via a beep and i power cycle the test
1221 box. (yeah, i should make use of a managed power outlet to 100%
1222 automate it)</p></div>
1224 </div></div></div>
1225 <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>
1227 used together. It can be even more powerful if you can combine them
1228 with other systems.</p></div>
1230 some unusual (or even random) configurations. And if a regression is
1231 found by a test suite, then "git bisect" can be automatically
1232 launched, and its result can be emailed to the author of the first bad
1233 commit found by "git bisect", and perhaps other people too. And a new
1234 entry in the bug tracking system could be automatically created too.</p></div>
1235 </div>
1240 avoid areas in the commit graph where commits are untestable. The
1241 problem is that sometimes the first bad commit will be in an
1242 untestable area.</p></div>
1244 a simple string of commits and that it was created by a breakage
1245 introduced by one commit (let's call it BBC for bisect breaking
1246 commit) and later fixed by another one (let's call it BFC for bisect
1247 fixing commit).</p></div>
1252 </div></div>
1254 X6 are untestable.</p></div>
1256 a special branch that starts just before the BBC. The first commit in
1257 this branch should be the BBC with the BFC squashed into it. And the
1258 other commits in the branch should be the commits between BBC and BFC
1259 rebased on the first commit of the branch and then the commit after
1260 BFC also rebased on.</p></div>
1264 <pre><tt> (BBC+BFC)-X1'-X2'-X3'-X4'-X5'-X6'-Z'
1265 /
1266 ...-Y-BBC-X1-X2-X3-X4-X5-X6-BFC-Z-...</tt></pre>
1267 </div></div>
1269 <div class="para"><p>You can easily create such a branch with Git using interactive rebase.</p></div>
1274 </div></div>
1277 should eventually find the first bad commit.</p></div>
1282 </div></div>
1284 as above, and then start another "git bisect run" in the special
1285 branch. Or as the "git bisect" man page says, the script passed to
1286 "git bisect run" can apply a patch before it compiles and test the
1289 "git bisect" will be able to find the first bad commit. And the script
1290 should not forget to remove the patch once the testing is done before
1291 exiting from the script.</p></div>
1293 apply the fix, and in this case you should use "git reset —hard
1294 HEAD^" to revert the cherry-pick after testing and before returning
1295 from the script.)</p></div>
1297 clunky. Using special branches is nice because these branches can be
1298 shared by developers like usual branches, but the risk is that people
1299 will get many such branches. And it disrupts the normal "git bisect"
1300 work-flow. So, if you want to use "git bisect run" completely
1301 automatically, you have to add special code in your script to restart
1302 bisection in the special branches.</p></div>
1304 and Z commits should point to the same source code state (the same
1305 "tree" in git parlance). That's because Z' result from applying the
1306 same changes as Z just in a slightly different order.</p></div>
1308 not need to add anything to a script. It would just work for anyone in
1309 the project sharing the special branches and the replacements.</p></div>
1313 <pre><tt> (BBC+BFC)-X1'-X2'-X3'-X4'-X5'-X6'-Z'-...
1314 /
1315 ...-Y-BBC-X1-X2-X3-X4-X5-X6-BFC-Z</tt></pre>
1316 </div></div>
1320 (that are stored in "refs/tags"), and that means that they can
1321 automatically be shared like branches or tags among developers.</p></div>
1323 commits in already released history, for example to change the commit
1324 message or the author. And it can also be used instead of git "grafts"
1325 to link a repository with another old repository.</p></div>
1327 it is now in the "master" branch of git's git repository and it should
1330 replacements refs in "refs/replace/", but it would be perhaps better
1331 if the replacement refs that are useful only for bisecting would be in
1332 "refs/replace/bisect/". This way the replacement refs could be used
1333 only for bisecting, while other refs directly in "refs/replace/" would
1334 be used nearly all the time.</p></div>
1337 add some redundancy to the tests performed so that it would be more
1338 reliable when tracking sporadic bugs.</p></div>
1340 called sporadic bugs do not appear in all the kernel builds because
1341 they are very dependent on the compiler output.</p></div>
1343 user to test a commit that has already been found to be "good" or
1344 "bad" (because one of its descendants or one of its ancestors has been
1346 has been previously incorrectly classified then the bisection can be
1347 aborted early, hopefully before too many mistakes have been made. Then
1348 the user will have to look at what happened and then restart the
1349 bisection using a fixed bisect log.</p></div>
1351 on Github that does something like that using Bayesian Search Theory
1355 <div class="para"><p>BBChop is like <em>git bisect</em> (or equivalent), but works when your bug
1356 is intermittent. That is, it works in the presence of false negatives
1357 (when a version happens to work this time even though it contains the
1358 bug). It assumes that there are no false positives (in principle, the
1359 same approach would work, but adding it may be non-trivial).</p></div>
1361 </div></div></div>
1363 users to have something integrated in Git.</p></div>
1364 </div>
1368 bisect" has nice features that complement very well practices and
1369 other tools, especially test suites, that are generally used to fight
1370 regressions. But it might be needed to change some work-flows and
1371 (bad) habits to get the most out of it.</p></div>
1373 and some new features could help in some cases, but overall "git
1374 bisect" works already very well, is used a lot, and is already very
1375 useful. To back up that last claim, let's give the final word to Ingo
1376 Molnar when he was asked by the author how much time does he think
1382 queue. That was prior the Git (and even prior the BitKeeper) days. I
1383 literally days spent sorting out patches, creating what in essence
1384 were standalone commits that i guessed to be related to that bug.</p></div>
1389 manual help or when bisecting multiple, overlapping bugs, it's rarely
1390 more than an hour.</p></div>
1392 _try_ to debug if it wasn't for git bisect. In the past there were bug
1393 patterns that were immediately hopeless for me to debug - at best i
1394 could send the crash/bug signature to lkml and hope that someone else
1395 can think of something.</p></div>
1397 about the bug: that it's non-deterministic - timing or kernel image
1398 layout dependent.</p></div>
1400 ;-)</p></div>
1402 </div></div></div>
1403 </div>
1407 reviewing the patches I sent to the git mailing list, for discussing
1408 some ideas and helping me improve them, for improving "git bisect" a
1409 lot and for his awesome work in maintaining and developing Git.</p></div>
1411 appears in this paper, for commenting on this paper, for his
1413 on the linux kernel mailing lists.</p></div>
1417 another when I worked on git, especially to Andreas Ericsson, Johannes
1418 Schindelin, H. Peter Anvin, Daniel Barkalow, Bill Lear, John Hawley,
1419 Shawn O. Pierce, Jeff King, Sam Vilain, Jon Seymour.</p></div>
1421 author to given a talk and for publishing this paper.</p></div>
1422 </div>
1426 <li>
1427 <p>
1428 <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>
1429 </p>
1430 </li>
1431 <li>
1432 <p>
1433 <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>
1434 </p>
1435 </li>
1436 <li>
1437 <p>
1438 <a id="3"></a>[3] <a href="http://en.wikipedia.org/wiki/Software_maintenance"><em>Software maintenance</em>. Wikipedia.</a>
1439 </p>
1440 </li>
1441 <li>
1442 <p>
1443 <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>
1444 </p>
1445 </li>
1446 <li>
1447 <p>
1448 <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>
1449 </p>
1450 </li>
1451 <li>
1452 <p>
1453 <a id="6"></a>[6] <a href="http://lwn.net/Articles/277872/">Jonathan Corbet. <em>Bisection divides users and developers</em>. LWN.net.</a>
1454 </p>
1455 </li>
1456 <li>
1457 <p>
1458 <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>
1459 </p>
1460 </li>
1461 <li>
1462 <p>
1463 <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>
1464 </p>
1465 </li>
1466 <li>
1467 <p>
1468 <a id="9"></a>[9] <a href="http://github.com/Ealdwulf/bbchop">Ealdwulf. <em>bbchop</em>. GitHub.</a>
1469 </p>
1470 </li>
1471 </ul></div>
1472 </div>
1476 </div>
1477 </div>
1478 </body>
1479 </html>