stablesort: extract a '_revsfrom' method Walking from the revision is usually simple unless the revision is a merge. Having this walking logic isolated will help us refine it.

stablerange: use the new cache object in the 'mergepoint' version Every improvement to the cache should reflect on the stable range from there. Since we no longer use the basic sort function, we can simplify the inheritance by dropping one layer.

stablesort: introduce a cache object The object is not caching anything yet, but the API are getting into place.

stablesort: start implementing more advanced version of headstart sorting Now that we can validate the sort with a basic implementation, we can start implementing a version that will support caching and other goodies.

stablerange: make use of the limit argument in 'mergepoint' This will eventually avoid doing full iteration on ancestors of the head when retrieving the range content.

stablerange: introduce a smarte version of stablerange for 'mergepoint' This implementation will using caching and smarter algorithm based on these cache. For now it inherit most of it code from the dummy version for convenience. The inheritance to the dummy version should be dropped eventually.

stablerange: introduce an intermediary abstract class for caching The 'branchpoint' and 'mergepoint' based stablerange class will need similar cache, we introduce an abstract class to take care of that first.

stablerange: introduce a basic-mergepoint method This method use the new 'mergepoint' based stable sorting. It is expected to be eventually better than branch point to stable range: more stable, easier to cache, etc. Having a basic implementation will allow use to validate more advanced implementation.

stablesort: add a new test to check for fully independant branches Apparently, this was not covered.

stablesort: add a --limit argument This will be useful when using stable sort within stable range.

stablesort: introduce a mergepoint based method focused on head The things we needs for stable range is head centric. So we simplify the issue by focussing on head.

stablesort: introduce a "mergepoint" method The mergepoint method decide order from merge. This allow to directly reuse a the full sort of one of the parent, and should simplify caching.

stablerange: fallback to a more naive approach to find subrange As suspected, using "bheads" was bit good enough in some case and we have to fall back to the approach used in "basic". On the evolve repo (about 3K changeset) this approach is about 60% slower than the previous (wrong) code.

stablebranch: avoid overlap between subrange Subrange overlap make things more complicated and less efficient. We fix the computation done in the "cached" version of the stablerange cache. This bring things in line with the result produced by the basic version. Since we already bumped the format version since the last release, I don't things we need to do anything else.