</div>\r
<h2>DESCRIPTION</h2>\r
<div class="sectionbody">\r
-<p>The command takes various subcommands, and different options\r
-depending on the subcommand:</p>\r
+<p>The command takes various subcommands, and different options depending\r
+on the subcommand:</p>\r
<div class="literalblock">\r
<div class="content">\r
<pre><tt>git bisect start [<paths>...]\r
git bisect log\r
git bisect run <cmd>...</tt></pre>\r
</div></div>\r
-<p>This command uses <em>git-rev-list --bisect</em> option to help drive\r
-the binary search process to find which change introduced a bug,\r
-given an old "good" commit object name and a later "bad" commit\r
-object name.</p>\r
+<p>This command uses <em>git-rev-list --bisect</em> option to help drive the\r
+binary search process to find which change introduced a bug, given an\r
+old "good" commit object name and a later "bad" commit object name.</p>\r
+<h3>Basic bisect commands: start, bad, good</h3>\r
<p>The way you use it is:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git bisect start\r
-$ git bisect bad # Current version is bad\r
-$ git bisect good v2.6.13-rc2 # v2.6.13-rc2 was the last version\r
- # tested that was good</tt></pre>\r
+$ git bisect bad # Current version is bad\r
+$ git bisect good v2.6.13-rc2 # v2.6.13-rc2 was the last version\r
+ # tested that was good</tt></pre>\r
</div></div>\r
-<p>When you give at least one bad and one good versions, it will\r
-bisect the revision tree and say something like:</p>\r
+<p>When you give at least one bad and one good versions, it will bisect\r
+the revision tree and say something like:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>Bisecting: 675 revisions left to test after this</tt></pre>\r
</div></div>\r
-<p>and check out the state in the middle. Now, compile that kernel, and boot\r
-it. Now, let's say that this booted kernel works fine, then just do</p>\r
+<p>and check out the state in the middle. Now, compile that kernel, and\r
+boot it. Now, let's say that this booted kernel works fine, then just\r
+do</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git bisect good # this one is good</tt></pre>\r
<div class="content">\r
<pre><tt>Bisecting: 337 revisions left to test after this</tt></pre>\r
</div></div>\r
-<p>and you continue along, compiling that one, testing it, and depending on\r
-whether it is good or bad, you say "git bisect good" or "git bisect bad",\r
-and ask for the next bisection.</p>\r
-<p>Until you have no more left, and you'll have been left with the first bad\r
-kernel rev in "refs/bisect/bad".</p>\r
+<p>and you continue along, compiling that one, testing it, and depending\r
+on whether it is good or bad, you say "git bisect good" or "git bisect\r
+bad", and ask for the next bisection.</p>\r
+<p>Until you have no more left, and you'll have been left with the first\r
+bad kernel rev in "refs/bisect/bad".</p>\r
+<h3>Bisect reset</h3>\r
<p>Oh, and then after you want to reset to the original head, do a</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git bisect reset</tt></pre>\r
</div></div>\r
-<p>to get back to the master branch, instead of being in one of the bisection\r
-branches ("git bisect start" will do that for you too, actually: it will\r
-reset the bisection state, and before it does that it checks that you're\r
-not using some old bisection branch).</p>\r
+<p>to get back to the master branch, instead of being in one of the\r
+bisection branches ("git bisect start" will do that for you too,\r
+actually: it will reset the bisection state, and before it does that\r
+it checks that you're not using some old bisection branch).</p>\r
+<h3>Bisect visualize</h3>\r
<p>During the bisection process, you can say</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git bisect visualize</tt></pre>\r
</div></div>\r
<p>to see the currently remaining suspects in <tt>gitk</tt>.</p>\r
-<p>The good/bad input is logged, and <tt>git bisect\r
-log</tt> shows what you have done so far. You can truncate its\r
-output somewhere and save it in a file, and run</p>\r
+<h3>Bisect log and bisect replay</h3>\r
+<p>The good/bad input is logged, and</p>\r
+<div class="listingblock">\r
+<div class="content">\r
+<pre><tt>$ git bisect log</tt></pre>\r
+</div></div>\r
+<p>shows what you have done so far. You can truncate its output somewhere\r
+and save it in a file, and run</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git bisect replay that-file</tt></pre>\r
</div></div>\r
<p>if you find later you made a mistake telling good/bad about a\r
revision.</p>\r
-<p>If in a middle of bisect session, you know what the bisect\r
-suggested to try next is not a good one to test (e.g. the change\r
-the commit introduces is known not to work in your environment\r
-and you know it does not have anything to do with the bug you\r
-are chasing), you may want to find a near-by commit and try that\r
-instead. It goes something like this:</p>\r
+<h3>Avoiding to test a commit</h3>\r
+<p>If in a middle of bisect session, you know what the bisect suggested\r
+to try next is not a good one to test (e.g. the change the commit\r
+introduces is known not to work in your environment and you know it\r
+does not have anything to do with the bug you are chasing), you may\r
+want to find a near-by commit and try that instead.</p>\r
+<p>It goes something like this:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git bisect good/bad # previous round was good/bad.\r
$ git reset --hard HEAD~3 # try 3 revs before what\r
# was suggested</tt></pre>\r
</div></div>\r
-<p>Then compile and test the one you chose to try. After that,\r
-tell bisect what the result was as usual.</p>\r
-<p>You can further cut down the number of trials if you know what\r
-part of the tree is involved in the problem you are tracking\r
-down, by giving paths parameters when you say <tt>bisect start</tt>,\r
-like this:</p>\r
+<p>Then compile and test the one you chose to try. After that, tell\r
+bisect what the result was as usual.</p>\r
+<h3>Cutting down bisection by giving path parameter to bisect start</h3>\r
+<p>You can further cut down the number of trials if you know what part of\r
+the tree is involved in the problem you are tracking down, by giving\r
+paths parameters when you say <tt>bisect start</tt>, like this:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git bisect start arch/i386 include/asm-i386</tt></pre>\r
</div></div>\r
-<p>If you have a script that can tell if the current\r
-source code is good or bad, you can automatically bisect using:</p>\r
+<h3>Bisect run</h3>\r
+<p>If you have a script that can tell if the current source code is good\r
+or bad, you can automatically bisect using:</p>\r
<div class="listingblock">\r
<div class="content">\r
<pre><tt>$ git bisect run my_script</tt></pre>\r
</div></div>\r
-<p>Note that the "run" script (<tt>my_script</tt> in the above example)\r
-should exit with code 0 in\r
-case the current source code is good and with a code between 1 and 127\r
-(included) in case the current source code is bad.</p>\r
-<p>Any other exit code (a program that does "exit(-1)" leaves $? = 255,\r
-see exit(3) manual page, the value is chopped with "& 0377") will\r
-abort the automatic bisect process.</p>\r
+<p>Note that the "run" script (<tt>my_script</tt> in the above example) should\r
+exit with code 0 in case the current source code is good and with a\r
+code between 1 and 127 (included) in case the current source code is\r
+bad.</p>\r
+<p>Any other exit code will abort the automatic bisect process. (A\r
+program that does "exit(-1)" leaves $? = 255, see exit(3) manual page,\r
+the value is chopped with "& 0377".)</p>\r
<p>You may often find that during bisect you want to have near-constant\r
tweaks (e.g., s/#define DEBUG 0/#define DEBUG 1/ in a header file, or\r
"revision that does not have this commit needs this patch applied to\r
</div>\r
<div id="footer">\r
<div id="footer-text">\r
-Last updated 23-Mar-2007 10:46:02 UTC\r
+Last updated 24-Mar-2007 07:16:24 UTC\r
</div>\r
</div>\r
</body>\r
DESCRIPTION
-----------
-The command takes various subcommands, and different options
-depending on the subcommand:
+The command takes various subcommands, and different options depending
+on the subcommand:
git bisect start [<paths>...]
git bisect bad <rev>
git bisect log
git bisect run <cmd>...
-This command uses 'git-rev-list --bisect' option to help drive
-the binary search process to find which change introduced a bug,
-given an old "good" commit object name and a later "bad" commit
-object name.
+This command uses 'git-rev-list --bisect' option to help drive the
+binary search process to find which change introduced a bug, given an
+old "good" commit object name and a later "bad" commit object name.
+
+Basic bisect commands: start, bad, good
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The way you use it is:
------------------------------------------------
$ git bisect start
-$ git bisect bad # Current version is bad
-$ git bisect good v2.6.13-rc2 # v2.6.13-rc2 was the last version
- # tested that was good
+$ git bisect bad # Current version is bad
+$ git bisect good v2.6.13-rc2 # v2.6.13-rc2 was the last version
+ # tested that was good
------------------------------------------------
-When you give at least one bad and one good versions, it will
-bisect the revision tree and say something like:
+When you give at least one bad and one good versions, it will bisect
+the revision tree and say something like:
------------------------------------------------
Bisecting: 675 revisions left to test after this
------------------------------------------------
-and check out the state in the middle. Now, compile that kernel, and boot
-it. Now, let's say that this booted kernel works fine, then just do
+and check out the state in the middle. Now, compile that kernel, and
+boot it. Now, let's say that this booted kernel works fine, then just
+do
------------------------------------------------
$ git bisect good # this one is good
Bisecting: 337 revisions left to test after this
------------------------------------------------
-and you continue along, compiling that one, testing it, and depending on
-whether it is good or bad, you say "git bisect good" or "git bisect bad",
-and ask for the next bisection.
+and you continue along, compiling that one, testing it, and depending
+on whether it is good or bad, you say "git bisect good" or "git bisect
+bad", and ask for the next bisection.
+
+Until you have no more left, and you'll have been left with the first
+bad kernel rev in "refs/bisect/bad".
-Until you have no more left, and you'll have been left with the first bad
-kernel rev in "refs/bisect/bad".
+Bisect reset
+~~~~~~~~~~~~
Oh, and then after you want to reset to the original head, do a
$ git bisect reset
------------------------------------------------
-to get back to the master branch, instead of being in one of the bisection
-branches ("git bisect start" will do that for you too, actually: it will
-reset the bisection state, and before it does that it checks that you're
-not using some old bisection branch).
+to get back to the master branch, instead of being in one of the
+bisection branches ("git bisect start" will do that for you too,
+actually: it will reset the bisection state, and before it does that
+it checks that you're not using some old bisection branch).
+
+Bisect visualize
+~~~~~~~~~~~~~~~~
During the bisection process, you can say
to see the currently remaining suspects in `gitk`.
-The good/bad input is logged, and `git bisect
-log` shows what you have done so far. You can truncate its
-output somewhere and save it in a file, and run
+Bisect log and bisect replay
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The good/bad input is logged, and
+
+------------
+$ git bisect log
+------------
+
+shows what you have done so far. You can truncate its output somewhere
+and save it in a file, and run
------------
$ git bisect replay that-file
if you find later you made a mistake telling good/bad about a
revision.
-If in a middle of bisect session, you know what the bisect
-suggested to try next is not a good one to test (e.g. the change
-the commit introduces is known not to work in your environment
-and you know it does not have anything to do with the bug you
-are chasing), you may want to find a near-by commit and try that
-instead. It goes something like this:
+Avoiding to test a commit
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If in a middle of bisect session, you know what the bisect suggested
+to try next is not a good one to test (e.g. the change the commit
+introduces is known not to work in your environment and you know it
+does not have anything to do with the bug you are chasing), you may
+want to find a near-by commit and try that instead.
+
+It goes something like this:
------------
$ git bisect good/bad # previous round was good/bad.
# was suggested
------------
-Then compile and test the one you chose to try. After that,
-tell bisect what the result was as usual.
+Then compile and test the one you chose to try. After that, tell
+bisect what the result was as usual.
+
+Cutting down bisection by giving path parameter to bisect start
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-You can further cut down the number of trials if you know what
-part of the tree is involved in the problem you are tracking
-down, by giving paths parameters when you say `bisect start`,
-like this:
+You can further cut down the number of trials if you know what part of
+the tree is involved in the problem you are tracking down, by giving
+paths parameters when you say `bisect start`, like this:
------------
$ git bisect start arch/i386 include/asm-i386
------------
-If you have a script that can tell if the current
-source code is good or bad, you can automatically bisect using:
+Bisect run
+~~~~~~~~~~
+
+If you have a script that can tell if the current source code is good
+or bad, you can automatically bisect using:
------------
$ git bisect run my_script
------------
-Note that the "run" script (`my_script` in the above example)
-should exit with code 0 in
-case the current source code is good and with a code between 1 and 127
-(included) in case the current source code is bad.
+Note that the "run" script (`my_script` in the above example) should
+exit with code 0 in case the current source code is good and with a
+code between 1 and 127 (included) in case the current source code is
+bad.
-Any other exit code (a program that does "exit(-1)" leaves $? = 255,
-see exit(3) manual page, the value is chopped with "& 0377") will
-abort the automatic bisect process.
+Any other exit code will abort the automatic bisect process. (A
+program that does "exit(-1)" leaves $? = 255, see exit(3) manual page,
+the value is chopped with "& 0377".)
You may often find that during bisect you want to have near-constant
tweaks (e.g., s/#define DEBUG 0/#define DEBUG 1/ in a header file, or
projects / git.git / commitdiff