RE: git bisect and the merge from hell

On Fri, 3 Feb 2006, Luck, Tony wrote:

Note that this _can_ be a problem with huge octopus merges.

If some bug only appears as a result of the interaction of two branches, doing a 12-way merge will make it harder to debug. Doing a "git bisect" will (correctly) pinpoint the merge as being the problem, but after that you're on your own as to how to debug it.

So _if_ it had been a merge error, there's two issues with that:

 - debugging merges is usually a bit less straightforward than debugging a 
   single well-defined changeset anyway.

 - especially an octopus-merge will cause "git-bisect" to be less 
   efficient, since it cannot be bisected, so if the bug is in the merge 
   itself, it will ask you to test _every_ _single_ top-of-branch before 
   the merge.

(Normally, testing 12 kernels would zoom in on a bug from 10.000 feet, and you'd have bisected a massive four-thousand commits. So having to test 12 branch heads just to pinpoint a _single_ commit is "unusually expensive" by any standard for git bisection).

Anyway, had it been a merge bug, you should then have done:

 - check if it's simply a mis-merge. Do "git-diff-tree --cc" to see if 
   there were any conflicts, and check them out more closely to see 
   if maybe they were incorrectly fixed up.

   Normally, an octopus merge will never have any actual _manual_ 
   conflicts (the standard git tools shouldn't allow it), but there can 
   still be several branches that touch the same area and that could have 
   merged strangely.

If that doesn't get you anywhere, you'll literally have to go to the next step:

 - re-do the merges one by one, until the bug appears, or, if it's not 
   there once you've re-done them all, check what the differences are 
   (there _should_ be none, but see above on doing mis-merging) with the 
   final octopus one.

Anyway, for "normal" bugs (like this one apparently is), git-bisect shouldn't ever pinpoint a merge, since the bug hopefully was introduced somewhere _during_ the branch development, and not when it was merged back. Hopefully.

Anyway. The message you should take home from this is that "git bisect" handles merges perfectly well, and that at worst it might be less efficient and harder to debug - especially for octopus merges - but that both of those problems are likely (a) rare and (b) not insurmountable.

		Linus