This is an archive of the discontinued Mercurial Phabricator instance.

copies-rust: track "overwrites" directly within CopySource
ClosedPublic

Authored by marmoute on Dec 21 2020, 5:28 PM.

Download Raw Diff

Details

Reviewers

pulkit
Alphare

Group Reviewers

hg-reviewers

Commits

rHG0d840b9d200d: copies-rust: track "overwrites" directly within CopySource
rHGf9cd66dc2b55: copies-rust: track "overwrites" directly within CopySource

Summary

Overwrite are "rare enough" that explicitly keeping track of them is going to be
"cheap", or at least much cheaper that issuing many is_ancestor calls.

Even a simple implementation using no specific optimisation (eg: using the
generic HashSet type) yield good result in most cases.

They are interesting optimization to can do on top of that. We will implement
them in later changesets.

We tried different approach to speed up the overwrite detection and this one
seems the most promising. Without further optimization, we already see sizable
speedup on various cases.

Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev

mozilla-try x00000_revs_x_added_0_copies 6a320851d377 1ebb79acd503 : 363753 revs, 5.138169 s, 4.482399 s, -0.655770 s, × 0.8724, 12 µs/rev
mozilla-try x00000_revs_x_added_x_copies 5173c4b6f97c 95d83ee7242d : 362229 revs, 5.127809 s, 4.480366 s, -0.647443 s, × 0.8737, 12 µs/rev
mozilla-try x00000_revs_x000_added_x_copies 9126823d0e9c ca82787bb23c : 359344 revs, 4.971136 s, 4.369070 s, -0.602066 s, × 0.8789, 12 µs/rev
mozilla-try x00000_revs_x0000_added_x0000_copies 8d3fafa80d4b eb884023b810 : 192665 revs, 1.741678 s, 1.592506 s, -0.149172 s, × 0.9144, 8 µs/rev

However, some of the case doing a lot of overwrite get significantly slower.
The one with a really problematic slowdown are the special "head reducing" merge
in mozilla-try so I am not too worried about them. In addition, further
changeset are going to improve the performance of all this.

Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev

mozilla-try x0000_revs_xx000_added_x000_copies 89294cd501d9 7ccb2fc7ccb5 : 97052 revs, 1.343373 s, 2.119204 s, +0.775831 s, × 1.5775, 21 µs/rev
mozilla-try x00000_revs_x00000_added_x0000_copies 1b661134e2ca 1ae03d022d6d : 228985 revs, 40.314822 s, 87.824489 s, +47.509667 s, × 2.1785, 383 µs/rev
mozilla-try x00000_revs_x00000_added_x000_copies 9b2a99adc05e 8e29777b48e6 : 382065 revs, 20.048029 s, 43.304637 s, +23.256608 s, × 2.1600, 113 µs/rev

Full benchmark below:

Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev

mercurial x_revs_x_added_0_copies mercurial x_revs_x_added_x_copies mercurial x000_revs_x000_added_x_copies pypy x_revs_x_added_0_copies pypy x_revs_x000_added_0_copies pypy x_revs_x_added_x_copies pypy x_revs_x00_added_x_copies pypy x_revs_x000_added_x000_copies pypy x000_revs_xx00_added_0_copies pypy x000_revs_x000_added_x_copies pypy x000_revs_x000_added_x000_copies pypy x0000_revs_x_added_0_copies pypy x0000_revs_xx000_added_0_copies pypy x0000_revs_xx000_added_x000_copies netbeans x_revs_x_added_0_copies netbeans x_revs_x000_added_0_copies netbeans x_revs_x_added_x_copies netbeans x_revs_x00_added_x_copies netbeans x000_revs_xx00_added_0_copies netbeans x000_revs_x000_added_x_copies netbeans x000_revs_x000_added_x000_copies netbeans x0000_revs_xx000_added_x000_copies mozilla-central x_revs_x_added_0_copies mozilla-central x_revs_x000_added_0_copies mozilla-central x_revs_x_added_x_copies mozilla-central x_revs_x00_added_x_copies mozilla-central x_revs_x000_added_x000_copies mozilla-central x_revs_x0000_added_x0000_copies mozilla-central x000_revs_xx00_added_0_copies mozilla-central x000_revs_x000_added_x_copies mozilla-central x000_revs_x000_added_x000_copies mozilla-central x0000_revs_xx000_added_0_copies mozilla-central x0000_revs_xx000_added_x000_copies mozilla-central x00000_revs_x0000_added_x0000_copies mozilla-central x00000_revs_x00000_added_x000_copies mozilla-try x_revs_x_added_0_copies mozilla-try x_revs_x000_added_0_copies mozilla-try x_revs_x_added_x_copies mozilla-try x_revs_x00_added_x_copies mozilla-try x_revs_x000_added_x000_copies mozilla-try x_revs_x0000_added_x0000_copies mozilla-try x000_revs_xx00_added_0_copies mozilla-try x000_revs_x000_added_x_copies mozilla-try x000_revs_x000_added_x000_copies mozilla-try x0000_revs_x_added_0_copies mozilla-try x0000_revs_x_added_x_copies mozilla-try x0000_revs_xx000_added_x_copies mozilla-try x0000_revs_xx000_added_0_copies mozilla-try x0000_revs_xx000_added_x000_copies mozilla-try x0000_revs_x0000_added_x0000_copies mozilla-try x00000_revs_x_added_0_copies mozilla-try x00000_revs_x00000_added_0_copies mozilla-try x00000_revs_x_added_x_copies mozilla-try x00000_revs_x000_added_x_copies mozilla-try x00000_revs_x0000_added_x0000_copies mozilla-try x00000_revs_x00000_added_x0000_copies mozilla-try x00000_revs_x00000_added_x000_copies private ad6b123de1c7 39cfcef4f463 : 1 revs, 0.000042 s, 0.000043 s, +0.000001 s, × 1.0238, 43 µs/rev
2b1c78674230 0c1d10351869 : 6 revs, 0.000110 s, 0.000114 s, +0.000004 s, × 1.0364, 19 µs/rev
81f8ff2a9bf2 dd3267698d84 : 1032 revs, 0.004945 s, 0.004937 s, -0.000008 s, × 0.9984, 4 µs/rev
aed021ee8ae8 099ed31b181b : 9 revs, 0.000192 s, 0.000339 s, +0.000147 s, × 1.7656, 37 µs/rev
4aa4e1f8e19a 359343b9ac0e : 1 revs, 0.000049 s, 0.000049 s, +0.000000 s, × 1.0000, 49 µs/rev
ac52eb7bbbb0 72e022663155 : 7 revs, 0.000112 s, 0.000202 s, +0.000090 s, × 1.8036, 28 µs/rev
c3b14617fbd7 ace7255d9a26 : 1 revs, 0.000323 s, 0.000409 s, +0.000086 s, × 1.2663, 409 µs/rev
df6f7a526b60 a83dc6a2d56f : 6 revs, 0.010042 s, 0.011984 s, +0.001942 s, × 1.1934, 1997 µs/rev
89a76aede314 2f22446ff07e : 4785 revs, 0.049813 s, 0.050820 s, +0.001007 s, × 1.0202, 10 µs/rev
8a3b5bfd266e 2c68e87c3efe : 6780 revs, 0.079937 s, 0.087953 s, +0.008016 s, × 1.1003, 12 µs/rev
89a76aede314 7b3dda341c84 : 5441 revs, 0.059412 s, 0.062902 s, +0.003490 s, × 1.0587, 11 µs/rev
d1defd0dc478 c9cb1334cc78 : 43645 revs, 0.533769 s, 0.679234 s, +0.145465 s, × 1.2725, 15 µs/rev
bf2c629d0071 4ffed77c095c : 2 revs, 0.013147 s, 0.013095 s, -0.000052 s, × 0.9960, 6547 µs/rev
08ea3258278e d9fa043f30c0 : 11316 revs, 0.110680 s, 0.120910 s, +0.010230 s, × 1.0924, 10 µs/rev
fb0955ffcbcd a01e9239f9e7 : 2 revs, 0.000085 s, 0.000087 s, +0.000002 s, × 1.0235, 43 µs/rev
6f360122949f 20eb231cc7d0 : 2 revs, 0.000107 s, 0.000107 s, +0.000000 s, × 1.0000, 53 µs/rev
1ada3faf6fb6 5a39d12eecf4 : 3 revs, 0.000175 s, 0.000186 s, +0.000011 s, × 1.0629, 62 µs/rev
35be93ba1e2c 9eec5e90c05f : 9 revs, 0.000720 s, 0.000754 s, +0.000034 s, × 1.0472, 83 µs/rev
eac3045b4fdd 51d4ae7f1290 : 1421 revs, 0.010019 s, 0.010443 s, +0.000424 s, × 1.0423, 7 µs/rev
e2063d266acd 6081d72689dc : 1533 revs, 0.015602 s, 0.015697 s, +0.000095 s, × 1.0061, 10 µs/rev
ff453e9fee32 411350406ec2 : 5750 revs, 0.058759 s, 0.063528 s, +0.004769 s, × 1.0812, 11 µs/rev
588c2d1ced70 1aad62e59ddd : 66949 revs, 0.491550 s, 0.545515 s, +0.053965 s, × 1.1098, 8 µs/rev
3697f962bb7b 7015fcdd43a2 : 2 revs, 0.000087 s, 0.000089 s, +0.000002 s, × 1.0230, 44 µs/rev
dd390860c6c9 40d0c5bed75d : 8 revs, 0.000268 s, 0.000265 s, -0.000003 s, × 0.9888, 33 µs/rev
8d198483ae3b 14207ffc2b2f : 9 revs, 0.000181 s, 0.000381 s, +0.000200 s, × 2.1050, 42 µs/rev
98cbc58cc6bc 446a150332c3 : 7 revs, 0.000661 s, 0.000672 s, +0.000011 s, × 1.0166, 96 µs/rev
3c684b4b8f68 0a5e72d1b479 : 3 revs, 0.003256 s, 0.003497 s, +0.000241 s, × 1.0740, 1165 µs/rev
effb563bb7e5 c07a39dc4e80 : 6 revs, 0.066749 s, 0.073204 s, +0.006455 s, × 1.0967, 12200 µs/rev
6100d773079a 04a55431795e : 1593 revs, 0.006462 s, 0.006482 s, +0.000020 s, × 1.0031, 4 µs/rev
9f17a6fc04f9 2d37b966abed : 41 revs, 0.004919 s, 0.005066 s, +0.000147 s, × 1.0299, 123 µs/rev
7c97034feb78 4407bd0c6330 : 7839 revs, 0.062421 s, 0.065707 s, +0.003286 s, × 1.0526, 8 µs/rev
9eec5917337d 67118cc6dcad : 615 revs, 0.026633 s, 0.026800 s, +0.000167 s, × 1.0063, 43 µs/rev
f78c615a656c 96a38b690156 : 30263 revs, 0.197792 s, 0.203856 s, +0.006064 s, × 1.0307, 6 µs/rev
6832ae71433c 4c222a1d9a00 : 153721 revs, 1.259970 s, 1.293394 s, +0.033424 s, × 1.0265, 8 µs/rev
76caed42cf7c 1daa622bbe42 : 204976 revs, 1.689184 s, 1.698239 s, +0.009055 s, × 1.0054, 8 µs/rev
aaf6dde0deb8 9790f499805a : 2 revs, 0.000865 s, 0.000875 s, +0.000010 s, × 1.0116, 437 µs/rev
d8d0222927b4 5bb8ce8c7450 : 2 revs, 0.000893 s, 0.000891 s, -0.000002 s, × 0.9978, 445 µs/rev
092fcca11bdb 936255a0384a : 4 revs, 0.000172 s, 0.000292 s, +0.000120 s, × 1.6977, 73 µs/rev
b53d2fadbdb5 017afae788ec : 2 revs, 0.001159 s, 0.003939 s, +0.002780 s, × 3.3986, 1969 µs/rev
20408ad61ce5 6f0ee96e21ad : 1 revs, 0.031621 s, 0.033027 s, +0.001406 s, × 1.0445, 33027 µs/rev
effb563bb7e5 c07a39dc4e80 : 6 revs, 0.068571 s, 0.073703 s, +0.005132 s, × 1.0748, 12283 µs/rev
6100d773079a 04a55431795e : 1593 revs, 0.006452 s, 0.006469 s, +0.000017 s, × 1.0026, 4 µs/rev
9f17a6fc04f9 2d37b966abed : 41 revs, 0.005443 s, 0.005278 s, -0.000165 s, × 0.9697, 128 µs/rev
1346fd0130e4 4c65cbdabc1f : 6657 revs, 0.063180 s, 0.064995 s, +0.001815 s, × 1.0287, 9 µs/rev
63519bfd42ee a36a2a865d92 : 40314 revs, 0.293564 s, 0.301041 s, +0.007477 s, × 1.0255, 7 µs/rev
9fe69ff0762d bcabf2a78927 : 38690 revs, 0.286595 s, 0.285575 s, -0.001020 s, × 0.9964, 7 µs/rev
156f6e2674f2 4d0f2c178e66 : 8598 revs, 0.083256 s, 0.085597 s, +0.002341 s, × 1.0281, 9 µs/rev
9eec5917337d 67118cc6dcad : 615 revs, 0.027282 s, 0.027118 s, -0.000164 s, × 0.9940, 44 µs/rev
89294cd501d9 7ccb2fc7ccb5 : 97052 revs, 1.343373 s, 2.119204 s, +0.775831 s, × 1.5775, 21 µs/rev
e928c65095ed e951f4ad123a : 52031 revs, 0.665737 s, 0.701479 s, +0.035742 s, × 1.0537, 13 µs/rev
6a320851d377 1ebb79acd503 : 363753 revs, 5.138169 s, 4.482399 s, -0.655770 s, × 0.8724, 12 µs/rev
dc8a3ca7010e d16fde900c9c : 34414 revs, 0.573276 s, 0.574082 s, +0.000806 s, × 1.0014, 16 µs/rev
5173c4b6f97c 95d83ee7242d : 362229 revs, 5.127809 s, 4.480366 s, -0.647443 s, × 0.8737, 12 µs/rev
9126823d0e9c ca82787bb23c : 359344 revs, 4.971136 s, 4.369070 s, -0.602066 s, × 0.8789, 12 µs/rev
8d3fafa80d4b eb884023b810 : 192665 revs, 1.741678 s, 1.592506 s, -0.149172 s, × 0.9144, 8 µs/rev
1b661134e2ca 1ae03d022d6d : 228985 revs, 40.314822 s, 87.824489 s, +47.509667 s, × 2.1785, 383 µs/rev
9b2a99adc05e 8e29777b48e6 : 382065 revs, 20.048029 s, 43.304637 s, +23.256608 s, × 2.1600, 113 µs/rev
: 459513 revs, 37.179470 s, 33.853687 s, -3.325783 s, × 0.9105, 73 µs/rev

Diff Detail

Repository

rHG Mercurial

Branch

default

Lint

No Linters Available

Unit

No Unit Test Coverage

Event Timeline

marmoute created this revision.Dec 21 2020, 5:28 PM

Herald added a reviewer: hg-reviewers. · View Herald TranscriptDec 21 2020, 5:28 PM

Herald added a subscriber: mercurial-patches. · View Herald Transcript

marmoute added a child revision: D9645: copies-rust: remove the ancestor Oracle logic.Dec 21 2020, 5:28 PM

pulkit added a subscriber: pulkit.Dec 22 2020, 9:13 AM

pulkit added inline comments.

rust/hg-core/src/copy_tracing.rs
26	needs some documentation love.
584	Unrelated change.

marmoute updated this revision to Diff 24483.Dec 22 2020, 9:11 PM

marmoute added inline comments.Dec 22 2020, 9:15 PM

rust/hg-core/src/copy_tracing.rs
26	done thanks for pointing it out.
584	moved in the right changesets, thanks.

✅ refresh by Heptapod after a successful CI run (🐙 💚)

pulkit accepted this revision.Dec 28 2020, 3:17 AM

This revision is now accepted and ready to land.Dec 28 2020, 3:17 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare accepted this revision.Jan 8 2021, 8:15 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

marmoute added a commit: rHGf9cd66dc2b55: copies-rust: track "overwrites" directly within CopySource.Feb 24 2021, 11:01 AM

Closed by commit rHGf9cd66dc2b55: copies-rust: track "overwrites" directly within CopySource (authored by marmoute). · Explain Why

This revision was automatically updated to reflect the committed changes.

marmoute added a commit: rHG0d840b9d200d: copies-rust: track "overwrites" directly within CopySource.Feb 24 2021, 12:11 PM

Revision Contents
Changeset List

			Path	Packages
M			rust/hg-core/src/copy_tracing.rs (39 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	24468		Dec 21 2020, 5:28 PM	★	★
Diff 2	24483		Dec 22 2020, 9:11 PM	★	★
Diff 3	24508		Dec 23 2020, 3:50 AM	★	★
Diff 4	24578		Jan 5 2021, 3:52 AM	★	★
Diff 5	24600		Jan 5 2021, 9:17 AM	★	★
Diff 6	24641		Jan 8 2021, 10:26 AM	★	★
Diff 7	25689		Feb 22 2021, 9:04 AM	★	★
Diff 8	25748		Feb 22 2021, 11:17 AM	★	★
Diff 9	25783		Feb 22 2021, 3:16 PM	★	★
Diff 10	25848	rHGf9cd66dc2b553fe741bc18d39b1382c82dd47d75	Dec 15 2020, 12:04 PM	★	★

Commit	Parents	Author	Summary	Date
10267138b08a	9cb70c8b768f	Pierre-Yves David		Dec 15 2020, 12:04 PM

Status	Author	Revision
Closed	marmoute	D9591 copies: rename value/other variable to minor/major for clarity
Closed	marmoute	D9590 copies: extract value comparison in the python copy tracing
Closed	marmoute	D9607 hghave: add some official category for known-bad and missing-good output
Closed	marmoute	D9608 copies: stop attempt to avoid extra dict copies around branching
Closed	marmoute	D9592 copies: deal with the "same revision" special case earlier
Closed	marmoute	D9589 copies-tests: update to null in test-copies-chain-merge.t
Closed	marmoute	D9588 copies-tests: add a summary of all cases created in test-copies-chain-merge.t
Closed	SimonSapin	D9686 copies-rust: send PyBytes values back be dropped ino the parent thread
Closed	SimonSapin	D9685 copies-rust: introduce PyBytesWithData to reduce GIL requirement
Closed	SimonSapin	D9684 copies-rust: move CPU-heavy Rust processing into a child thread
Closed	SimonSapin	D9683 copies-rust: split up combine_changeset_copies function into a struct
Closed	SimonSapin	D9682 copies-rust: extract generic map merge logic from merge_copies_dict
Closed	marmoute	D9656 copies-rust: use imrs::OrdSet instead of imrs::HashSet
Closed	marmoute	D9655 copies-rust: use simpler overwrite when value on both side are identical
Closed	marmoute	D9654 copies-rust: make more use of the new comparison property
Closed	marmoute	D9653 copies-rust: implement PartialEqual manually
Closed	marmoute	D9652 copies-rust: record "overwritten" information from both side on delete
Closed	marmoute	D9651 copies-rust: refactor the "deletion" case
Closed	marmoute	D9650 copies-rust: process copy information of both parent at the same time
Closed	marmoute	D9649 copies-rust: yield both p1 and p2 copies in `ChangedFiles.actions()`
Closed	marmoute	D9648 copies-rust: extract the processing of a single copy information
Closed	marmoute	D9647 copies-rust: use matching to select the final copies information
Closed	marmoute	D9646 copies-rust: get the parents' copies earlier
Closed	marmoute	D9645 copies-rust: remove the ancestor Oracle logic
Closed	marmoute	D9644 copies-rust: track "overwrites" directly within CopySource
Closed	marmoute	D9643 copies-rust: add methods to build and update CopySource
Closed	marmoute	D9657 copies-rust: fix reverted argument when merging tiny minor or major
Closed	marmoute	D9642 copies-rust: rename TimeStampedPathCopy to CopySource
Closed	marmoute	D9641 copies-rust: rename TimeStampedPathCopies to InternalPathCopies
Closed	marmoute	D9613 copies: detect case when a merge decision overwrite previous data
Closed	marmoute	D9612 copies: rearrange all value comparison conditional
Closed	marmoute	D10059 test-copies: introduce merge chains test for the P/Q merges
Closed	marmoute	D10058 test-copies: add a case involving the `b` and a new `r` branch
Closed	marmoute	D10057 test-copies: introduce case combining the `p` and `q` branch
Closed	marmoute	D10056 test-copies: add a `q` branch similar to the `e` but on the new files
Closed	marmoute	D10055 test-copies: add a `p` branch similar to the `a` but on the new files
Closed	marmoute	D10054 test-copies: move the new files in the `i` branch
Closed	marmoute	D10053 test-copies: add 3 new files with their own content
Closed	marmoute	D10052 test-copies: introduce merge chaing test for the A/E + change tests
Closed	marmoute	D10051 test-copies: add a "change during merge" variant to the A+E test
Closed	marmoute	D10050 test-copies: filter out the linkrev part of `debugindex`
Closed	marmoute	D10049 test-copies: use "case-id" instead of revision number when listing sidedata
Closed	marmoute	D10048 test-copies: remove revision number from log
Closed	marmoute	D9611 test-copies: add test chaining multiple merge
Closed	marmoute	D9610 test-copies: add test chaining multiple merges
Closed	marmoute	D9609 test-copies: add test chaining multiple merges
Closed	marmoute	D10047 test-copies: add subcase titles for various "conflicting" information variant
Closed	marmoute	D10046 test-copies: improve description of the B+F case
Closed	marmoute	D10045 test-copies: improve description of the C+H case
Closed	marmoute	D10044 test-copies: improve description of the B+C "revert/restore" case
Closed	marmoute	D10043 test-copies: improve description of the G+C case
Closed	marmoute	D10042 test-copies: improve description of the G+F case
Closed	marmoute	D10041 test-copies: improve description of the D+G case
Closed	marmoute	D10040 test-copies: improve description of the A+E case
Closed	marmoute	D10039 test-copies: improve description of the B+D case
Closed	marmoute	D10038 test-copies: improve description of the B+C case
Closed	marmoute	D10037 test-copies: improve description of the A+B case
Closed	marmoute	D10036 test-copies: use intermediate variable some commit descriptions
Closed	marmoute	D10035 test-copies: don't use empty file for "same content" cases
Closed	marmoute	D9587 test-copies: reinstall initial identical (empty) files for chained copied
Closed	marmoute	D9586 copies: explain the "arbitrary" copy source pick in case of conflict
Closed	marmoute	D9585 copies: properly match result during changeset centric copy tracing
Closed	marmoute	D9584 copies: avoid early return in _combine_changeset_copies
Closed	marmoute	D9499 copies-rust: record overwrite when merging
Closed	marmoute	D9498 copies-rust: make the comparison aware of the revision being current merged
Closed	marmoute	D9497 copies-rust: start recording overwrite as they happens
Closed	marmoute	D9496 copies-rust: rename Oracle.is_ancestor to Oracle.is_overwrite
Closed	marmoute	D9495 copies-rust: use the `entry` API for copy information too
Closed	marmoute	D9494 copies-rust: use the entry API to overwrite deleted entry
Closed	marmoute	D9493 copies-rust: tokenize all paths into integer
Closed	marmoute	D9492 copies-rust: pre-introduce a PathToken type and use it where applicable
Closed	marmoute	D9491 copies-rust: add smarter approach for merging small mapping with large mapping
Closed	marmoute	D9426 copies-rust: hide most of the comparison details inside a closure
Closed	marmoute	D9425 copies-rust: move the mapping merging into a else clause
Closed	marmoute	D9424 copies-rust: extract conflicting value comparison in its own function
Closed	marmoute	D9423 copies: no longer cache the ChangedFiles during copy tracing
Closed	marmoute	D9422 copies: iterate over children directly (instead of parents)
Closed	marmoute	D9581 copies: document the current algorithm step

Diff 24600

rust/hg-core/src/copy_tracing.rs

	use crate::utils::hg_path::HgPath;			use crate::utils::hg_path::HgPath;
	use crate::utils::hg_path::HgPathBuf;			use crate::utils::hg_path::HgPathBuf;
	use crate::Revision;			use crate::Revision;
	use crate::NULL_REVISION;			use crate::NULL_REVISION;

	use im_rc::ordmap::DiffItem;			use im_rc::ordmap::DiffItem;
	use im_rc::ordmap::Entry;			use im_rc::ordmap::Entry;
	use im_rc::ordmap::OrdMap;			use im_rc::ordmap::OrdMap;

	use std::cmp::Ordering;			use std::cmp::Ordering;
	use std::collections::HashMap;			use std::collections::HashMap;
				use std::collections::HashSet;
	use std::convert::TryInto;			use std::convert::TryInto;

	pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;			pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;

	type PathToken = usize;			type PathToken = usize;

	#[derive(Clone, Debug, PartialEq)]			#[derive(Clone, Debug, PartialEq)]
	struct CopySource {			struct CopySource {
	/// revision at which the copy information was added			/// revision at which the copy information was added
	rev: Revision,			rev: Revision,
	/// the copy source, (Set to None in case of deletion of the associated			/// the copy source, (Set to None in case of deletion of the associated
	/// key)			/// key)
	path: Option<PathToken>,			path: Option<PathToken>,
				/// a set of previous `CopySource.rev` value directly or indirectly
				pulkitUnsubmitted Not Done needs some documentation love. pulkit: needs some documentation love.
				marmouteAuthorUnsubmitted Done done thanks for pointing it out. marmoute: done thanks for pointing it out.
				/// overwritten by this one.
				overwritten: HashSet<Revision>,
	}			}

	impl CopySource {			impl CopySource {
	/// create a new CopySource			/// create a new CopySource
	///			///
	/// Use this when no previous copy source existed.			/// Use this when no previous copy source existed.
	fn new(rev: Revision, path: Option<PathToken>) -> Self {			fn new(rev: Revision, path: Option<PathToken>) -> Self {
	Self { rev, path }			Self {
				rev,
				path,
				overwritten: HashSet::new(),
				}
	}			}

	/// create a new CopySource from merging two others			/// create a new CopySource from merging two others
	///			///
	/// Use this when merging two InternalPathCopies requires active merging of			/// Use this when merging two InternalPathCopies requires active merging of
	/// some entries.			/// some entries.
	fn new_from_merge(rev: Revision, winner: &Self, loser: &Self) -> Self {			fn new_from_merge(rev: Revision, winner: &Self, loser: &Self) -> Self {
				let mut overwritten = HashSet::new();
				overwritten.extend(winner.overwritten.iter().copied());
				overwritten.extend(loser.overwritten.iter().copied());
				overwritten.insert(winner.rev);
				overwritten.insert(loser.rev);
	Self {			Self {
	rev,			rev,
	path: winner.path,			path: winner.path,
				overwritten: overwritten,
	}			}
	}			}

	/// Update the value of a pre-existing CopySource			/// Update the value of a pre-existing CopySource
	///			///
	/// Use this when recording copy information from parent → child edges			/// Use this when recording copy information from parent → child edges
	fn overwrite(&mut self, rev: Revision, path: Option<PathToken>) {			fn overwrite(&mut self, rev: Revision, path: Option<PathToken>) {
				self.overwritten.insert(self.rev);
	self.rev = rev;			self.rev = rev;
	self.path = path;			self.path = path;
	}			}

	/// Mark pre-existing copy information as "dropped" by a file deletion			/// Mark pre-existing copy information as "dropped" by a file deletion
	///			///
	/// Use this when recording copy information from parent → child edges			/// Use this when recording copy information from parent → child edges
	fn mark_delete(&mut self, rev: Revision) {			fn mark_delete(&mut self, rev: Revision) {
				self.overwritten.insert(self.rev);
	self.rev = rev;			self.rev = rev;
	self.path = None;			self.path = None;
	}			}

				fn is_overwritten_by(&self, other: &Self) -> bool {
				other.overwritten.contains(&self.rev)
				}
	}			}

	/// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)			/// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)
	type InternalPathCopies = OrdMap<PathToken, CopySource>;			type InternalPathCopies = OrdMap<PathToken, CopySource>;

	/// hold parent 1, parent 2 and relevant files actions.			/// hold parent 1, parent 2 and relevant files actions.
	pub type RevInfo<'a> = (Revision, Revision, ChangedFiles<'a>);			pub type RevInfo<'a> = (Revision, Revision, ChangedFiles<'a>);

	// the right decision when merging conflicting copy			// the right decision when merging conflicting copy
	// information. See merge_copies_dict for details.			// information. See merge_copies_dict for details.
	match copies.entry(dest) {			match copies.entry(dest) {
	Entry::Vacant(slot) => {			Entry::Vacant(slot) => {
	let ttpc = CopySource::new(current_rev, entry);			let ttpc = CopySource::new(current_rev, entry);
	slot.insert(ttpc);			slot.insert(ttpc);
	}			}
	Entry::Occupied(mut slot) => {			Entry::Occupied(mut slot) => {
	let ttpc = slot.get_mut();			let ttpc = slot.get_mut();
				pulkitUnsubmitted Not Done Unrelated change. pulkit: Unrelated change.
				marmouteAuthorUnsubmitted Done moved in the right changesets, thanks. marmoute: moved in the right changesets, thanks.
	oracle.record_overwrite(ttpc.rev, current_rev);			oracle.record_overwrite(ttpc.rev, current_rev);
	ttpc.overwrite(current_rev, entry);			ttpc.overwrite(current_rev, entry);
	}			}
	}			}
	}			}
	Action::Removed(deleted_path) => {			Action::Removed(deleted_path) => {
	// We must drop copy information for removed file.			// We must drop copy information for removed file.
	//			//
	src_minor: &CopySource,			src_minor: &CopySource,
	src_major: &CopySource,			src_major: &CopySource,
	) -> (MergePick, bool) {			) -> (MergePick, bool) {
	if src_major.rev == current_merge {			if src_major.rev == current_merge {
	if src_minor.rev == current_merge {			if src_minor.rev == current_merge {
	if src_major.path.is_none() {			if src_major.path.is_none() {
	// We cannot get different copy information for both p1 and p2			// We cannot get different copy information for both p1 and p2
	// from the same revision. Unless this was a			// from the same revision. Unless this was a
	// deletion			// deletion.
	(MergePick::Any, false)			//
				// However the deletion might come over different data on each
				// branch.
				let need_over = src_major.overwritten != src_minor.overwritten;
				(MergePick::Any, need_over)
	} else {			} else {
	unreachable!();			unreachable!();
	}			}
	} else {			} else {
	// The last value comes the current merge, this value -will- win			// The last value comes the current merge, this value -will- win
	// eventually.			// eventually.
	(MergePick::Major, true)			(MergePick::Major, true)
	}			}
	} else if src_minor.rev == current_merge {			} else if src_minor.rev == current_merge {
	// The last value comes the current merge, this value -will- win			// The last value comes the current merge, this value -will- win
	// eventually.			// eventually.
	(MergePick::Minor, true)			(MergePick::Minor, true)
	} else if src_major.path == src_minor.path {			} else if src_major.path == src_minor.path {
	// we have the same value, but from other source;			// we have the same value, but from other source;
	if src_major.rev == src_minor.rev {			if src_major.rev == src_minor.rev {
	// If the two entry are identical, they are both valid			// If the two entry are identical, they are both valid
				debug_assert!(src_minor.overwritten == src_minor.overwritten);
	(MergePick::Any, false)			(MergePick::Any, false)
	} else if oracle.is_overwrite(src_major.rev, src_minor.rev) {			} else if src_major.is_overwritten_by(src_minor) {
	(MergePick::Minor, false)			(MergePick::Minor, false)
	} else if oracle.is_overwrite(src_minor.rev, src_major.rev) {			} else if src_minor.is_overwritten_by(src_major) {
	(MergePick::Major, false)			(MergePick::Major, false)
	} else {			} else {
	(MergePick::Any, true)			(MergePick::Any, true)
	}			}
	} else if src_major.rev == src_minor.rev {			} else if src_major.rev == src_minor.rev {
	// We cannot get copy information for both p1 and p2 in the			// We cannot get copy information for both p1 and p2 in the
	// same rev. So this is the same value.			// same rev. So this is the same value.
	unreachable!(			unreachable!(
	} else if src_major.path.is_some()			} else if src_major.path.is_some()
	&& src_minor.path.is_none()			&& src_minor.path.is_none()
	&& action == MergeCase::Salvaged			&& action == MergeCase::Salvaged
	{			{
	// If the file is "deleted" in the minor side but was			// If the file is "deleted" in the minor side but was
	// salvaged by the merge, unconditionnaly preserve the			// salvaged by the merge, unconditionnaly preserve the
	// major side.			// major side.
	(MergePick::Major, true)			(MergePick::Major, true)
	} else if oracle.is_overwrite(src_minor.rev, src_major.rev) {			} else if src_minor.is_overwritten_by(src_major) {
	// The information from the minor version are strictly older than			// The information from the minor version are strictly older than
	// the major version			// the major version
	if action == MergeCase::Merged {			if action == MergeCase::Merged {
	// If the file was actively merged, its means some non-copy			// If the file was actively merged, its means some non-copy
	// activity happened on the other branch. It			// activity happened on the other branch. It
	// mean the older copy information are still relevant.			// mean the older copy information are still relevant.
	//			//
	// The major side wins such conflict.			// The major side wins such conflict.
	(MergePick::Major, true)			(MergePick::Major, true)
	} else {			} else {
	// No activity on the minor branch, pick the newer one.			// No activity on the minor branch, pick the newer one.
	(MergePick::Major, false)			(MergePick::Major, false)
	}			}
	} else if oracle.is_overwrite(src_major.rev, src_minor.rev) {			} else if src_major.is_overwritten_by(src_minor) {
	if action == MergeCase::Merged {			if action == MergeCase::Merged {
	// If the file was actively merged, its means some non-copy			// If the file was actively merged, its means some non-copy
	// activity happened on the other branch. It			// activity happened on the other branch. It
	// mean the older copy information are still relevant.			// mean the older copy information are still relevant.
	//			//
	// The major side wins such conflict.			// The major side wins such conflict.
	(MergePick::Major, true)			(MergePick::Major, true)
	} else {			} else {

This is an archive of the discontinued Mercurial Phabricator instance.

copies-rust: track "overwrites" directly within CopySourceClosedPublic

Details

Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev

Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev

Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 24600

rust/hg-core/src/copy_tracing.rs

copies-rust: track "overwrites" directly within CopySource
ClosedPublic

Revision Contents
Changeset List