| Message ID | cover.1539219248.git.jonathantanmy@google.com (mailing list archive) |
|---|---|
| Headers | show |
| Series | Per-commit filter proof of concept | expand |
On Thu, Oct 11 2018, Jonathan Tan wrote: > Using per-commit filters and restricting the bloom filter to a single > parent increases the relative power of the filter in omitting tree > inspections compared to the original (107/53096 vs 1183/66459), but the > lack of coverage w.r.t. the non-first parents had a more significant > effect than I thought (1.29s vs .24s). It might be best to have one > filter for each (commit, parent) pair (or, at least, the first two > parents of each commit - we probably don't need to care that much about > octopus merges) - this would take up more disk space than if we only > store filters for the first parent, but is still less than the original > example of storing information for all commits in one filter. > > There are more possibilities like dynamic filter sizing, different > hashing, and hashing to support wildcard matches, which I haven't looked > into. Another way to deal with that is to havet the filter store change since the merge base, from an E-Mail of mine back in May[1] when this was discussed: From: Ævar Arnfjörð Bjarmason <avarab@gmail.com> Date: Fri, 04 May 2018 22:36:07 +0200 Message-ID: <87h8nnxio8.fsf@evledraar.gmail.com> (raw) On Fri, May 04 2018, Jakub Narebski wrote: (Just off-the cuff here and I'm surely about to be corrected by Derrick...) > * What to do about merge commits, and octopus merges in particular? > Should Bloom filter be stored for each of the parents? How to ensure > fast access then (fixed-width records) - use large edge list? You could still store it fixed with, you'd just say that if you encounter a merge with N parents the filter wouldn't store files changed in that commit, but rather whether any of the N (including the merge) had changes to files as of the their common merge-base. Then if they did you'd need to walk all sides of the merge where each commit would also have the filter to figure out where the change(s) was/were, but if they didn't you could skip straight to the merge base and keep walking. [...] Ideas are cheap and I don't have any code to back that up, just thought I'd mention it if someone found it interesting. Thinking about this again I wonder if something like that could be generalized more, i.e. in the abstract the idea is really whether we can store a filter for N commits so we can skip across N in the walk as an optimization, doing this for merges is just an implementation detail. So what if the bloom filters were this sort of structure: <commit_the_filter_is_for> = [<bloom bitmap>, <next commit with filter>] So e.g. given a history like ("-> " = parent relationship) A -> B B -> C C -> D E -> F We could store: A -> B [<bloom bitmap for A..D>, D] B -> C C -> D D -> E [<bloom bitmap for D..F>, F] E -> F F -> G [<bloom bitmap for F..G>, G] Note how the bitmaps aren't evenly spaced. That's because some algorithm would have walked the graph and e.g. decided that from A..D we had few enough changes that the bitmap should apply for 4 commits, and then 3 for the next set etc. Whether some range was worth extending could just be a configurable implementation detail. 1. https://public-inbox.org/git/87h8nnxio8.fsf@evledraar.gmail.com/
I did my own experiments on top of what Szeder provided - the first patch is to have one fixed-size bloom filter per commit, and the second patch makes that bloom filter apply to only the first parent of each commit. The results are: Original (szeder's) $ GIT_USE_POC_BLOOM_FILTER=$((8*1024*1024*8)) time ./git commit-graph write 0:10.28 $ ls -l .git/objects/info/bloom 8388616 $ GIT_TRACE_BLOOM_FILTER=2 GIT_USE_POC_BLOOM_FILTER=y time ./git -c \ core.commitgraph=true rev-list --count --full-history HEAD -- \ t/valgrind/valgrind.sh 886 bloom filter total queries: 66459 definitely not: 65276 maybe: 1183 false positives: 297 fp ratio: 0.004469 0:00.24 With patch 1 $ GIT_USE_POC_BLOOM_FILTER=256 time ./git commit-graph write 0:16.22 $ ls -l .git/objects/info/bloom 1832620 $ GIT_TRACE_BLOOM_FILTER=2 GIT_USE_POC_BLOOM_FILTER=y time ./git -c \ core.commitgraph=true rev-list --count --full-history HEAD -- \ t/valgrind/valgrind.sh 886 bloom filter total queries: 66459 definitely not: 46637 maybe: 19822 false positives: 18936 fp ratio: 0.284928 0:01.53 With patch 2 $ GIT_USE_POC_BLOOM_FILTER=256 time ./git commit-graph write 0:06.70 $ ls -l .git/objects/info/bloom 1832620 $ GIT_TRACE_BLOOM_FILTER=2 GIT_USE_POC_BLOOM_FILTER=y time ./git -c \ core.commitgraph=true rev-list --count --full-history HEAD -- \ t/valgrind/valgrind.sh 886 bloom filter total queries: 53096 definitely not: 52989 maybe: 107 false positives: 89 fp ratio: 0.001676 0:01.29 For comparison, a non-GIT_USE_POC_BLOOM_FILTER rev-list takes 3.517 seconds. I haven't investigated why patch 1 takes longer than the original to create the bloom filter. Using per-commit filters and restricting the bloom filter to a single parent increases the relative power of the filter in omitting tree inspections compared to the original (107/53096 vs 1183/66459), but the lack of coverage w.r.t. the non-first parents had a more significant effect than I thought (1.29s vs .24s). It might be best to have one filter for each (commit, parent) pair (or, at least, the first two parents of each commit - we probably don't need to care that much about octopus merges) - this would take up more disk space than if we only store filters for the first parent, but is still less than the original example of storing information for all commits in one filter. There are more possibilities like dynamic filter sizing, different hashing, and hashing to support wildcard matches, which I haven't looked into. Jonathan Tan (2): One filter per commit Only make bloom filter for first parent bloom-filter.c | 31 ++++++++++++++++++------------- bloom-filter.h | 12 ++++-------- commit-graph.c | 30 ++++++++++++++---------------- revision.c | 29 +++++++++++++++-------------- 4 files changed, 51 insertions(+), 51 deletions(-)