* add churn metric
* add diff_count
* revert
* rename
* add churn cli flags
* fix integration test
* add unit tests
* try fix codeowners
* fix codeowners
* Optimize diff implementation
* delay conversion to String for filepaths to the last moment. That way, only the paths that
are displayed will be converted in an operation that isn't free.
* change diff implementation to decode parents only once, instead of three times in the commmon case.
* setup an object cache in the `Repository` for faster traversals and much faster diffs.
* Don't fail on missing parent as we want to work in shallow repos, too
* Increase performance by decoding the commit only once
Previously, each time we would query commit information, the commit would
lazily be decoded until the point of interest under the hood.
Now we decode everything once, which is faster than what happened before.
Note that diffs are still causing the parents to be decoded even we *could*
pass them in, but it's not worth the complexity for just 100 commits
(the default value for churn).
* track changes on executable files
* remove for_each method
* use horizontal ellipsis
* review
* use MAIN_SEPERATOR when building path
* revert
* run expensive diffs in parallel and abort them once we run out of time.
That way, we could even use higher amounts of diffs if we wanted to, or could
warn if there was not enough time to reach the desired amount of diffs.
* Always calculate at least one diff for 'churn'
That way, there is always some data to work with.
This is important in case the repo is very small and the thread needs some time
to start-up and finish.
* improved readability + churn_pool_size CLI flag
The churn_pool_size allow the user to force onefetch to be deterministic
in the number of commits used to create the churn summary
* fix test
* halt if the churn pool size is bigger than the total number of commits
* improve readability
* add unit test
* refactor
* simplify `should_break()`
* update to latest `gix` version
* Avoid exhaustive memory consumption by sending the commit-id instead of its buffer.
The delta-processing happens by referring to a commit, and previously we could
send the whole commit buffer (which is expensive) as the overall amount of buffers
in flight would be bounded.
Now that the bound was removed, it's necessary to limit the costs of the commit,
and we do this by referring to it by id instead.
That way, on the linux kernel, we get these values for memory consumption:
* bounded: 960MB
* unbounded buffer: 2156
* unbounded id: 1033
---------
Co-authored-by: Sebastian Thiel <sebastian.thiel@icloud.com>
Ossama Hjaji
1955153a9f