obshashrange: have an half descent wireprotocol command The previous implementation was extremely hacky. The new version is based on the other discovery function and work!

obshashrange: improve message issued during discovery This is a minor new message that help to understand what is going on.

obshashrange: introduce basic sqlite caching Same as for stablerange, this is far from perfect but already a win. The cache is currently extremely volatile, but that will still be a win when doing multiple consecutive request during discovery. Better cache invalidation will happens "in the future".

stablerange: warm cache before using it server side We make sure the cache is fully up to date before starting to use it. Updating all value is more efficient and this give us a single point where we update and write on disk. Hopefully the cache have been kept up to date as we go anyway.

stablerange: warm cache before using it in findrangemissing We make sure the cache is fully up to date before starting to use it. Updating all value is more efficient and this give us a single point where we update and write on disk. Hopefully the cache have been kept up to date as we go anyway.

stablerange: warm cache on transaction (if obshashrange is enabled) If we plan to use it (obshashrange is enabled) we better keep it up to date. If a transaction adds node, we update the cache (this should also update the on disk version).

stablerange: introduce ondisk caching through sqlite There is many short cut and limitation with this first version of a cache but this allow use to envision some actual usage of the stablerange thingy so let us got for it.

stablerange: drop the cache on 'destroyed' if the repository have been strip, the cache is not usable as is. We could be smarter in the invalidation but that is a prototype anyway. G: changed hgext3rd/evolve/stablerange.py

stablerange: support loading the cache iteratively We record how far we loaded so that we can resume from this point.

stablerange: add some basic documentation about the cache

stablerange: warmup all upto a revision Let us start doing more systemic warming of the cache before we start writing things out. This prepare on disk caching.

debugstablerange: add a --verify flag to the command This should help us finding bugs.

stablerange: add a proper debugstablerange commands This commands allows to inspect the standard stable range of a range. That should come handy.

debugobshashrange: add a --subranges option We stop displaying -everything- by default, since is is usually very large. This will help getting better timing when measuring cache effect too, since we won't need to dig out deep cache value that real life usage would not touch.

debug: rename 'debugstablerange' to 'debugobshashrange' The command is more about the 'obshashrange' computation.

debugstablerange: improve output spacing On repo with a descent amount of changeset the number where overflowing in all directions. We give use more room now.

subranges: add a utility function to set the cache This is preparing on disk persistence for the value in this cache.

subranges: add a utility function to access the cache This is preparing on disk persistence for the value in this cache.

depth: add a utility function to set the cache This is preparing on disk persistence for the value in this cache.

depth: add a utility function to access the cache This is preparing on disk persistence for the value in this cache.

stablerange: add warming of the subrange Note that this means we build standard stable subrange for all changesets in the repository this is significantly more than what we were computing before and result is significantly more ranges being computed.

stablerange: fix merge slicing when range has multiple roots The first element in the bottom set is not necessarly the one with the lowest revision. We now properly compute and use the minimum value.

stablerange: small style fix

merge-slicing: introduce and use "inheritance point" for merge The first part of the stable sorted list of revision of a merge will shared with the one of others. This means we can reuse subranges computed from that point to compute some of the subranges from the merge. That point is latest point in the stable sorted list where the depth of the revisions match its index (that means all revision earlier in the stable sorted list are its ancestors, no dangling unrelated branches exists). This is a bit expensive to find since we have to walk all the revision, but being able to reuse subranges in all case (not just regular changesets) provide a massive speedup so the cost is worth it.

stablerange: rearrange the code picking subrange to warm Same logic, as the previous changesets, we prepare the code before adding merge support.

stablerange: rearrange the reusing logic to prepare to merge We'll soon be able to reuse some lower range when dealing with merge too. So we prepare the code for this in advance for clarity.

merge-slicing: explain an alternative implementation in a comments It has a better time complexity so a C implementation would likely out perform the current implementation

merge-slicing: use reachable roots to filter the various branches Reachable roots does what we want and have a quite fast C implementation.

merge-slicing: simplify various aspect of the code Especially the case were the bottom have single heads is not more efficiently handled.

stablerange: soon it will not provide any benefit and it gets in the way This was a bit strange and memory consuming anyway.

revsfromrange: reuse information from the stablesort We collaborate with the stablesort to store the order that led to a merge. That way, when we needs to retrieve revision from that merge we can reuse that order. We might need to filter to only retains ancestors of the merge we care about but skipping the stablesort safe a large amount of time.

stablesort: allow a callback to be triggered on merge Storing some information as we sort is going to be useful to avoid performing multiple sort while computing the stablerange.

minor simplification around rangelength

more explicite name in revsfromrange

stablerange: cache parents We happens to be doing and awful amount of parent call. We cache them locally for efficiency.

merge-slicing: avoid doing the same work twice We have already computed the list of revision in that bottom slice as 'hrevs' so we do not need to compute it a second time.

stablerange: fix a bug when a top slice ended on a merge Our "smart" detection of merge was buggy if the top slice ended on a merge. This is not fixed and tested.

slicesrangeat: stop double setting the revsinranges cache The cache should have already been filled by the logic warming the cache for the parent.

subranges: remove the recursivity of the call to isubranges(parentrange) We add some logic to ensure we'll have hot cache for the parent ranges when that matters, the cache is filled from ancestors to descendant to ensure this. The range are still 'created from descendant to ancestors to fill the revsfromrange cache since it important.

subranges: detach cache logic from computation logic Having both the logic around cache checking and setting makes is a bit harder to follow. In addition, this allow to gather the computation logic next to the other related function.

findmissingrange: properly queue new subrange for slicing The previous code was buggy and used the wrong variable leading to no extra slicing being performed to file the sample at the requested size.

findmissingrange: fix reversed value in debug output "oops"

stablecache: warmup on unfiltered repository We only looks at ancestors revision so filtering will not have any effect. This reduce overhead from the filtering.

stablerange: rename the class This is much more than just a cache now.

stablerange: do not inherit from dict This seems like and old cargo cult that when unnoticed.

stablerange: move a utility function around It make more sense to have this small function earlier in the series

stablerange: remove the now unused individual range class That class is now longer necessary, we dropped its usage for performance reason.

stablerange: directly use tuple to refer to a stable range Now that all advance logic lives in the unified class we no longer needs the individual class. Creating and operating on this cache introduce a significant overhead that we can not stop having. From now on, a range a is pair tuple '(headrev, index)'. Long live the tuple.

obshash: properly cache obshash value The code was buggy and only cached non-nullid/non-inherited value. This was previous hidden because we were using a 'propertycache' to cache the value on the range object. This fixes it and restore a lot of performance.

stablerange: directly use 'self' when possible Code movement introduced multiple silly case were we where accessing 'self' though 'repo.stablerange' for no good reasons.

revsfromrange: set the cache for the multiple bottom ranges in merge slicing We no longer rely on the object magic here.

revsfromrange: set the cache for the single bottom range in merge slicing We no longer rely on the object magic here.

revsfromrange: set the cache for the top range in merge slicing We no longer rely on the object magic here.

revsfromrange: remove reference to '_revs' in merge slicing Given '_revs' is a property from the cache, we use the official method of the object we are on instead. That method should be using the same cache than the property if available.

revsfromcache: update cache for the top slice if possible Same logic, we update the cache if have the data.

revsfromrange: skip setting the cache for length-1 top entry The content of the range is trivial to compute.

revsfromrange: update cache for parentrange directly in the code We update it where it matters if we detect that we have the data.

revsfromramge: hard code the single changeset range case That case is trivial and triggering and full stable sort for it seems a bit silly.

stablerange: introduce caching for the full revision in a set Such cache proved handy in the "per-range" class so we carry it along to the unified class. cf documentation for details.

stablerange: add a cache for stablesort ordering This will be very handy for merge, cf inline documentation for details.

stablerange: move revs computation within the main class We still need to compute the revision withing a range when we slice a merge. This is the last large logic that remains in the individual class and we migrate is on the main class.

stablerange: minor method reorders on the main class We put the public method first for clarify.

stablerange: drop "key" and "id" logic form the class We can restrict to the bare minimun for equality and hashing now.

stablerange: drop length from the class There is not remaining user.