This is an archive of the discontinued Mercurial Phabricator instance.

copies-rust: tokenize all paths into integer
ClosedPublic

Authored by marmoute on Dec 2 2020, 11:02 AM.

Download Raw Diff

Details

Reviewers

Alphare
pulkit

Group Reviewers

hg-reviewers

Commits

rHGc6bc77f7e593: copies-rust: tokenize all paths into integer

Summary

Copy information for each changesets tend to affect a small new number of path.
However, each of these path might be handled a large number of time. Handling
HgPathBuf (aka Vec<u8>) is expensive. Handling integer is cheap.

With this patch we:

turn any input path into an integer "token" early,
do all the internal logic using such "token",
turn "token" back into path right before returning a result.

This gives use a quite significant performance boost in our slower cases.

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

pypy x000_revs_x000_added_x_copies 8a3b5bfd266e 2c68e87c3efe : 6780 revs, 0.092828 s, 0.081225 s, -0.011603 s, × 0.8750, 11 µs/rev
pypy x0000_revs_x_added_0_copies d1defd0dc478 c9cb1334cc78 : 43645 revs, 0.711975 s, 0.586011 s, -0.125964 s, × 0.8231, 13 µs/rev
pypy x0000_revs_xx000_added_x000_copies 08ea3258278e d9fa043f30c0 : 11316 revs, 0.124505 s, 0.114173 s, -0.010332 s, × 0.9170, 10 µs/rev
netbeans x000_revs_x000_added_x000_copies ff453e9fee32 411350406ec2 : 5750 revs, 0.072072 s, 0.061004 s, -0.011068 s, × 0.8464, 10 µs/rev
netbeans x0000_revs_xx000_added_x000_copies 588c2d1ced70 1aad62e59ddd : 66949 revs, 0.682732 s, 0.535874 s, -0.146858 s, × 0.7849, 8 µs/rev
mozilla-central x00000_revs_x0000_added_x0000_copies 6832ae71433c 4c222a1d9a00 : 153721 revs, 1.935918 s, 1.781383 s, -0.154535 s, × 0.9202, 11 µs/rev
mozilla-central x00000_revs_x00000_added_x000_copies 76caed42cf7c 1daa622bbe42 : 204976 revs, 2.827320 s, 2.603867 s, -0.223453 s, × 0.9210, 12 µs/rev
mozilla-try x0000_revs_xx000_added_x000_copies 89294cd501d9 7ccb2fc7ccb5 : 97052 revs, 3.243010 s, 1.529120 s, -1.713890 s, × 0.4715, 15 µs/rev
mozilla-try x00000_revs_x_added_0_copies 6a320851d377 1ebb79acd503 : 363753 revs, 5.693818 s, 4.842699 s, -0.851119 s, × 0.8505, 13 µs/rev
mozilla-try x00000_revs_x_added_x_copies 5173c4b6f97c 95d83ee7242d : 362229 revs, 5.677655 s, 4.761732 s, -0.915923 s, × 0.8387, 13 µs/rev
mozilla-try x00000_revs_x000_added_x_copies 9126823d0e9c ca82787bb23c : 359344 revs, 5.563370 s, 4.733912 s, -0.829458 s, × 0.8509, 13 µs/rev
mozilla-try x00000_revs_x0000_added_x0000_copies 8d3fafa80d4b eb884023b810 : 192665 revs, 2.864099 s, 2.593410 s, -0.270689 s, × 0.9055, 13 µs/rev
mozilla-try x00000_revs_x00000_added_x0000_copies 1b661134e2ca 1ae03d022d6d : 228985 revs, 113.297287 s, 41.041198 s, -72.256089 s, × 0.3622, 179 µs/rev
mozilla-try x00000_revs_x00000_added_x000_copies 9b2a99adc05e 8e29777b48e6 : 382065 revs, 59.498652 s, 27.915689 s, -31.582963 s, × 0.4692, 73 µs/rev

Full timing comparison between this revision and the previous one:

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 ad6b123de1c7 39cfcef4f463 : 1 revs, 0.000042 s, 0.000042 s, +0.000000 s, × 1.0000, 42 µs/rev
2b1c78674230 0c1d10351869 : 6 revs, 0.000104 s, 0.000110 s, +0.000006 s, × 1.0577, 18 µs/rev
81f8ff2a9bf2 dd3267698d84 : 1032 revs, 0.004913 s, 0.004918 s, +0.000005 s, × 1.0010, 4 µs/rev
aed021ee8ae8 099ed31b181b : 9 revs, 0.000191 s, 0.000195 s, +0.000004 s, × 1.0209, 21 µs/rev
4aa4e1f8e19a 359343b9ac0e : 1 revs, 0.000050 s, 0.000049 s, -0.000001 s, × 0.9800, 49 µs/rev
ac52eb7bbbb0 72e022663155 : 7 revs, 0.000112 s, 0.000112 s, +0.000000 s, × 1.0000, 16 µs/rev
c3b14617fbd7 ace7255d9a26 : 1 revs, 0.000288 s, 0.000324 s, +0.000036 s, × 1.1250, 324 µs/rev
df6f7a526b60 a83dc6a2d56f : 6 revs, 0.010411 s, 0.010611 s, +0.000200 s, × 1.0192, 1768 µs/rev
89a76aede314 2f22446ff07e : 4785 revs, 0.052852 s, 0.050835 s, -0.002017 s, × 0.9618, 10 µs/rev
8a3b5bfd266e 2c68e87c3efe : 6780 revs, 0.092828 s, 0.081225 s, -0.011603 s, × 0.8750, 11 µs/rev
89a76aede314 7b3dda341c84 : 5441 revs, 0.063269 s, 0.061291 s, -0.001978 s, × 0.9687, 11 µs/rev
d1defd0dc478 c9cb1334cc78 : 43645 revs, 0.711975 s, 0.586011 s, -0.125964 s, × 0.8231, 13 µs/rev
bf2c629d0071 4ffed77c095c : 2 revs, 0.012771 s, 0.012824 s, +0.000053 s, × 1.0042, 6412 µs/rev
08ea3258278e d9fa043f30c0 : 11316 revs, 0.124505 s, 0.114173 s, -0.010332 s, × 0.9170, 10 µs/rev
fb0955ffcbcd a01e9239f9e7 : 2 revs, 0.000082 s, 0.000085 s, +0.000003 s, × 1.0366, 42 µs/rev
6f360122949f 20eb231cc7d0 : 2 revs, 0.000111 s, 0.000108 s, -0.000003 s, × 0.9730, 54 µs/rev
1ada3faf6fb6 5a39d12eecf4 : 3 revs, 0.000171 s, 0.000175 s, +0.000004 s, × 1.0234, 58 µs/rev
35be93ba1e2c 9eec5e90c05f : 9 revs, 0.000708 s, 0.000719 s, +0.000011 s, × 1.0155, 79 µs/rev
eac3045b4fdd 51d4ae7f1290 : 1421 revs, 0.010608 s, 0.010175 s, -0.000433 s, × 0.9592, 7 µs/rev
e2063d266acd 6081d72689dc : 1533 revs, 0.015635 s, 0.015569 s, -0.000066 s, × 0.9958, 10 µs/rev
ff453e9fee32 411350406ec2 : 5750 revs, 0.072072 s, 0.061004 s, -0.011068 s, × 0.8464, 10 µs/rev
588c2d1ced70 1aad62e59ddd : 66949 revs, 0.682732 s, 0.535874 s, -0.146858 s, × 0.7849, 8 µs/rev
3697f962bb7b 7015fcdd43a2 : 2 revs, 0.000090 s, 0.000090 s, +0.000000 s, × 1.0000, 45 µs/rev
dd390860c6c9 40d0c5bed75d : 8 revs, 0.000210 s, 0.000281 s, +0.000071 s, × 1.3381, 35 µs/rev
8d198483ae3b 14207ffc2b2f : 9 revs, 0.000182 s, 0.000187 s, +0.000005 s, × 1.0275, 20 µs/rev
98cbc58cc6bc 446a150332c3 : 7 revs, 0.000594 s, 0.000660 s, +0.000066 s, × 1.1111, 94 µs/rev
3c684b4b8f68 0a5e72d1b479 : 3 revs, 0.003102 s, 0.003385 s, +0.000283 s, × 1.0912, 1128 µs/rev
effb563bb7e5 c07a39dc4e80 : 6 revs, 0.060234 s, 0.069812 s, +0.009578 s, × 1.1590, 11635 µs/rev
6100d773079a 04a55431795e : 1593 revs, 0.006300 s, 0.006503 s, +0.000203 s, × 1.0322, 4 µs/rev
9f17a6fc04f9 2d37b966abed : 41 revs, 0.004817 s, 0.004988 s, +0.000171 s, × 1.0355, 121 µs/rev
7c97034feb78 4407bd0c6330 : 7839 revs, 0.065451 s, 0.063963 s, -0.001488 s, × 0.9773, 8 µs/rev
9eec5917337d 67118cc6dcad : 615 revs, 0.026282 s, 0.026225 s, -0.000057 s, × 0.9978, 42 µs/rev
f78c615a656c 96a38b690156 : 30263 revs, 0.206873 s, 0.201377 s, -0.005496 s, × 0.9734, 6 µs/rev
6832ae71433c 4c222a1d9a00 : 153721 revs, 1.935918 s, 1.781383 s, -0.154535 s, × 0.9202, 11 µs/rev
76caed42cf7c 1daa622bbe42 : 204976 revs, 2.827320 s, 2.603867 s, -0.223453 s, × 0.9210, 12 µs/rev
aaf6dde0deb8 9790f499805a : 2 revs, 0.000842 s, 0.000845 s, +0.000003 s, × 1.0036, 422 µs/rev
d8d0222927b4 5bb8ce8c7450 : 2 revs, 0.000870 s, 0.000862 s, -0.000008 s, × 0.9908, 431 µs/rev
092fcca11bdb 936255a0384a : 4 revs, 0.000165 s, 0.000161 s, -0.000004 s, × 0.9758, 40 µs/rev
b53d2fadbdb5 017afae788ec : 2 revs, 0.001145 s, 0.001163 s, +0.000018 s, × 1.0157, 581 µs/rev
20408ad61ce5 6f0ee96e21ad : 1 revs, 0.026500 s, 0.032414 s, +0.005914 s, × 1.2232, 32414 µs/rev
effb563bb7e5 c07a39dc4e80 : 6 revs, 0.059407 s, 0.070149 s, +0.010742 s, × 1.1808, 11691 µs/rev
6100d773079a 04a55431795e : 1593 revs, 0.006325 s, 0.006526 s, +0.000201 s, × 1.0318, 4 µs/rev
9f17a6fc04f9 2d37b966abed : 41 revs, 0.005171 s, 0.005187 s, +0.000016 s, × 1.0031, 126 µs/rev
1346fd0130e4 4c65cbdabc1f : 6657 revs, 0.066837 s, 0.065047 s, -0.001790 s, × 0.9732, 9 µs/rev
63519bfd42ee a36a2a865d92 : 40314 revs, 0.314252 s, 0.301129 s, -0.013123 s, × 0.9582, 7 µs/rev
9fe69ff0762d bcabf2a78927 : 38690 revs, 0.304160 s, 0.280683 s, -0.023477 s, × 0.9228, 7 µs/rev
156f6e2674f2 4d0f2c178e66 : 8598 revs, 0.089223 s, 0.084897 s, -0.004326 s, × 0.9515, 9 µs/rev
9eec5917337d 67118cc6dcad : 615 revs, 0.026711 s, 0.026620 s, -0.000091 s, × 0.9966, 43 µs/rev
89294cd501d9 7ccb2fc7ccb5 : 97052 revs, 3.243010 s, 1.529120 s, -1.713890 s, × 0.4715, 15 µs/rev
e928c65095ed e951f4ad123a : 52031 revs, 0.756500 s, 0.738709 s, -0.017791 s, × 0.9765, 14 µs/rev
6a320851d377 1ebb79acd503 : 363753 revs, 5.693818 s, 4.842699 s, -0.851119 s, × 0.8505, 13 µs/rev
dc8a3ca7010e d16fde900c9c : 34414 revs, 0.590904 s, 0.596946 s, +0.006042 s, × 1.0102, 17 µs/rev
5173c4b6f97c 95d83ee7242d : 362229 revs, 5.677655 s, 4.761732 s, -0.915923 s, × 0.8387, 13 µs/rev
9126823d0e9c ca82787bb23c : 359344 revs, 5.563370 s, 4.733912 s, -0.829458 s, × 0.8509, 13 µs/rev
8d3fafa80d4b eb884023b810 : 192665 revs, 2.864099 s, 2.593410 s, -0.270689 s, × 0.9055, 13 µs/rev
1b661134e2ca 1ae03d022d6d : 228985 revs, 113.297287 s, 41.041198 s, -72.256089 s, × 0.3622, 179 µs/rev
9b2a99adc05e 8e29777b48e6 : 382065 revs, 59.498652 s, 27.915689 s, -31.582963 s, × 0.4692, 73 µs/rev

Full timing comparison between this revision and the filelog copy tracing.

Repo Case Source-Rev Dest-Rev # of revisions filelog sidedata Difference Factor time per rev

mercurial x_revs_x_added_0_copies ad6b123de1c7 39cfcef4f463 : 1 revs, 0.000903 s, 0.000042 s, -0.000861 s, × 0.0465, 41 µs/rev
mercurial x_revs_x_added_x_copies 2b1c78674230 0c1d10351869 : 6 revs, 0.001861 s, 0.000110 s, -0.001751 s, × 0.0591, 18 µs/rev
mercurial x000_revs_x000_added_x_copies 81f8ff2a9bf2 dd3267698d84 : 1032 revs, 0.018577 s, 0.004918 s, -0.013659 s, × 0.2647, 4 µs/rev
pypy x_revs_x_added_0_copies aed021ee8ae8 099ed31b181b : 9 revs, 0.001519 s, 0.000195 s, -0.001324 s, × 0.1283, 21 µs/rev
pypy x_revs_x000_added_0_copies 4aa4e1f8e19a 359343b9ac0e : 1 revs, 0.213855 s, 0.000049 s, -0.350d73 s, × 0.0002, 48 µs/rev
pypy x_revs_x_added_x_copies ac52eb7bbbb0 72e022663155 : 7 revs, 0.017022 s, 0.000112 s, -0.016910 s, × 0.0065, 15 µs/rev
pypy x_revs_x00_added_x_copies c3b14617fbd7 ace7255d9a26 : 1 revs, 0.019398 s, 0.000324 s, -0.019074 s, × 0.0167, 323 µs/rev
pypy x_revs_x000_added_x000_copies df6f7a526b60 a83dc6a2d56f : 6 revs, 0.769467 s, 0.010611 s, -0.758856 s, × 0.0137, 1768 µs/rev
pypy x000_revs_xx00_added_0_copies 89a76aede314 2f22446ff07e : 4785 revs, 1.221952 s, 0.050835 s, -1.171117 s, × 0.0416, 10 µs/rev
pypy x000_revs_x000_added_x_copies 8a3b5bfd266e 2c68e87c3efe : 6780 revs, 1.304007 s, 0.081225 s, -1.222782 s, × 0.0622, 11 µs/rev
pypy x000_revs_x000_added_x000_copies 89a76aede314 7b3dda341c84 : 5441 revs, 1.686610 s, 0.061291 s, -1.625319 s, × 0.0363, 11 µs/rev
pypy x0000_revs_x_added_0_copies d1defd0dc478 c9cb1334cc78 : 43645 revs, 0.001107 s, 0.586011 s, +0.584904 s, × 529.36, 13 µs/rev
pypy x0000_revs_xx000_added_0_copies bf2c629d0071 4ffed77c095c : 2 revs, 1.100760 s, 0.012824 s, -1.087936 s, × 0.0116, 6408 µs/rev
pypy x0000_revs_xx000_added_x000_copies 08ea3258278e d9fa043f30c0 : 11316 revs, 1.350547 s, 0.114173 s, -1.236374 s, × 0.0845, 10 µs/rev
netbeans x_revs_x_added_0_copies fb0955ffcbcd a01e9239f9e7 : 2 revs, 0.027864 s, 0.000085 s, -0.027779 s, × 0.0030, 42 µs/rev
netbeans x_revs_x000_added_0_copies 6f360122949f 20eb231cc7d0 : 2 revs, 0.132479 s, 0.000108 s, -0.132371 s, × 0.0008, 53 µs/rev
netbeans x_revs_x_added_x_copies 1ada3faf6fb6 5a39d12eecf4 : 3 revs, 0.025405 s, 0.000175 s, -0.025230 s, × 0.0068, 58 µs/rev
netbeans x_revs_x00_added_x_copies 35be93ba1e2c 9eec5e90c05f : 9 revs, 0.053244 s, 0.000719 s, -0.052525 s, × 0.0135, 79 µs/rev
netbeans x000_revs_xx00_added_0_copies eac3045b4fdd 51d4ae7f1290 : 1421 revs, 0.038017 s, 0.010175 s, -0.027842 s, × 0.2676, 7 µs/rev
netbeans x000_revs_x000_added_x_copies e2063d266acd 6081d72689dc : 1533 revs, 0.198308 s, 0.015569 s, -0.182739 s, × 0.0785, 10 µs/rev
netbeans x000_revs_x000_added_x000_copies ff453e9fee32 411350406ec2 : 5750 revs, 0.949749 s, 0.061004 s, -0.888745 s, × 0.0642, 10 µs/rev
netbeans x0000_revs_xx000_added_x000_copies 588c2d1ced70 1aad62e59ddd : 66949 revs, 3.932262 s, 0.535874 s, -3.396388 s, × 0.1362, 8 µs/rev
mozilla-central x_revs_x_added_0_copies 3697f962bb7b 7015fcdd43a2 : 2 revs, 0.024490 s, 0.000090 s, -0.024400 s, × 0.0036, 44 µs/rev
mozilla-central x_revs_x000_added_0_copies dd390860c6c9 40d0c5bed75d : 8 revs, 0.143885 s, 0.000281 s, -0.143604 s, × 0.0019, 35 µs/rev
mozilla-central x_revs_x_added_x_copies 8d198483ae3b 14207ffc2b2f : 9 revs, 0.025471 s, 0.000187 s, -0.025284 s, × 0.0073, 20 µs/rev
mozilla-central x_revs_x00_added_x_copies 98cbc58cc6bc 446a150332c3 : 7 revs, 0.086013 s, 0.000660 s, -0.085353 s, × 0.0076, 94 µs/rev
mozilla-central x_revs_x000_added_x000_copies 3c684b4b8f68 0a5e72d1b479 : 3 revs, 0.200726 s, 0.003385 s, -0.197341 s, × 0.0168, 1127 µs/rev
mozilla-central x_revs_x0000_added_x0000_copies effb563bb7e5 c07a39dc4e80 : 6 revs, 2.224171 s, 0.069812 s, -2.154359 s, × 0.0313, 11633 µs/rev
mozilla-central x000_revs_xx00_added_0_copies 6100d773079a 04a55431795e : 1593 revs, 0.090780 s, 0.006503 s, -0.084277 s, × 0.0716, 4 µs/rev
mozilla-central x000_revs_x000_added_x_copies 9f17a6fc04f9 2d37b966abed : 41 revs, 0.764805 s, 0.004988 s, -0.759817 s, × 0.0065, 121 µs/rev
mozilla-central x000_revs_x000_added_x000_copies 7c97034feb78 4407bd0c6330 : 7839 revs, 1.161405 s, 0.063963 s, -1.097442 s, × 0.0550, 8 µs/rev
mozilla-central x0000_revs_xx000_added_0_copies 9eec5917337d 67118cc6dcad : 615 revs, 6.816186 s, 0.026225 s, -6.789961 s, × 0.0038, 42 µs/rev
mozilla-central x0000_revs_xx000_added_x000_copies f78c615a656c 96a38b690156 : 30263 revs, 3.374819 s, 0.201377 s, -3.173442 s, × 0.0596, 6 µs/rev
mozilla-central x00000_revs_x0000_added_x0000_copies 6832ae71433c 4c222a1d9a00 : 153721 revs, 16.285469 s, 1.781383 s, -14.504086 s, × 0.1093, 11 µs/rev
mozilla-central x00000_revs_x00000_added_x000_copies 76caed42cf7c 1daa622bbe42 : 204976 revs, 21.207733 s, 2.603867 s, -18.603866 s, × 0.1227, 12 µs/rev
mozilla-try x_revs_x_added_0_copies aaf6dde0deb8 9790f499805a : 2 revs, 0.080843 s, 0.000845 s, -0.079998 s, × 0.0104, 422 µs/rev
mozilla-try x_revs_x000_added_0_copies d8d0222927b4 5bb8ce8c7450 : 2 revs, 0.511068 s, 0.000862 s, -0.510206 s, × 0.0016, 430 µs/rev
mozilla-try x_revs_x_added_x_copies 092fcca11bdb 936255a0384a : 4 revs, 0.021573 s, 0.000161 s, -0.021412 s, × 0.0074, 40 µs/rev
mozilla-try x_revs_x00_added_x_copies b53d2fadbdb5 017afae788ec : 2 revs, 0.227726 s, 0.001163 s, -0.226563 s, × 0.0051, 581 µs/rev
mozilla-try x_revs_x000_added_x000_copies 20408ad61ce5 6f0ee96e21ad : 1 revs, 1.120448 s, 0.032414 s, -1.088034 s, × 0.0289, 32381 µs/rev
mozilla-try x_revs_x0000_added_x0000_copies effb563bb7e5 c07a39dc4e80 : 6 revs, 2.241713 s, 0.070149 s, -2.171564 s, × 0.0312, 11689 µs/rev
mozilla-try x000_revs_xx00_added_0_copies 6100d773079a 04a55431795e : 1593 revs, 0.090633 s, 0.006526 s, -0.084107 s, × 0.0720, 4 µs/rev
mozilla-try x000_revs_x000_added_x_copies 9f17a6fc04f9 2d37b966abed : 41 revs, 0.770403 s, 0.005187 s, -0.765216 s, × 0.0067, 126 µs/rev
mozilla-try x000_revs_x000_added_x000_copies 1346fd0130e4 4c65cbdabc1f : 6657 revs, 1.184557 s, 0.065047 s, -1.119510 s, × 0.0549, 9 µs/rev
mozilla-try x0000_revs_x_added_0_copies 63519bfd42ee a36a2a865d92 : 40314 revs, 0.085790 s, 0.301129 s, +0.215339 s, × 3.5100, 7 µs/rev
mozilla-try x0000_revs_x_added_x_copies 9fe69ff0762d bcabf2a78927 : 38690 revs, 0.080616 s, 0.280683 s, +0.200067 s, × 3.4817, 7 µs/rev
mozilla-try x0000_revs_xx000_added_x_copies 156f6e2674f2 4d0f2c178e66 : 8598 revs, 7.712554 s, 0.084897 s, -7.627657 s, × 0.0110, 9 µs/rev
mozilla-try x0000_revs_xx000_added_0_copies 9eec5917337d 67118cc6dcad : 615 revs, 6.937294 s, 0.026620 s, -6.910674 s, × 0.0038, 43 µs/rev
mozilla-try x0000_revs_xx000_added_x000_copies 89294cd501d9 7ccb2fc7ccb5 : 97052 revs, 7.712313 s, 1.529120 s, -6.183193 s, × 0.1982, 15 µs/rev
mozilla-try x0000_revs_x0000_added_x0000_copies e928c65095ed e951f4ad123a : 52031 revs, 9.966910 s, 0.738709 s, -9.228201 s, × 0.0741, 14 µs/rev
mozilla-try x00000_revs_x_added_0_copies 6a320851d377 1ebb79acd503 : 363753 revs, 0.090397 s, 4.842699 s, +4.752302 s, × 53.571, 13 µs/rev
mozilla-try x00000_revs_x00000_added_0_copies dc8a3ca7010e d16fde900c9c : 34414 revs, 27.817167 s, 0.596946 s, -27.220221 s, × 0.0214, 17 µs/rev
mozilla-try x00000_revs_x_added_x_copies 5173c4b6f97c 95d83ee7242d : 362229 revs, 0.091305 s, 4.761732 s, +4.670427 s, × 52.151, 13 µs/rev
mozilla-try x00000_revs_x000_added_x_copies 9126823d0e9c ca82787bb23c : 359344 revs, 0.231183 s, 4.733912 s, +4.502729 s, × 20.476, 13 µs/rev
mozilla-try x00000_revs_x0000_added_x0000_copies 8d3fafa80d4b eb884023b810 : 192665 revs, 19.830617 s, 2.593410 s, -17.237207 s, × 0.1307, 13 µs/rev
mozilla-try x00000_revs_x00000_added_x0000_copies 1b661134e2ca 1ae03d022d6d : 228985 revs, 21.743873 s, 41.041198 s, +19.297325 s, × 1.8874, 179 µs/rev
mozilla-try x00000_revs_x00000_added_x000_copies 9b2a99adc05e 8e29777b48e6 : 382065 revs, 25.935037 s, 27.915689 s, +1.980652 s, × 1.0763, 73 µs/rev

Diff Detail

Repository

rHG Mercurial

Lint

Automatic diff as part of commit; lint not applicable.

Unit

Automatic diff as part of commit; unit tests not applicable.

Event Timeline

marmoute created this revision.Dec 2 2020, 11:02 AM

Herald added a reviewer: hg-reviewers. · View Herald TranscriptDec 2 2020, 11:02 AM

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

marmoute added a child revision: D9494: copies-rust: use the entry API to overwrite deleted entry.Dec 2 2020, 11:02 AM

SimonSapin added a subscriber: SimonSapin.Dec 2 2020, 11:15 AM

SimonSapin added inline comments.

rust/hg-core/src/copy_tracing.rs
320	This `HashMap` has sequential integer keys. Could it be a `Vec<HgPathBuf>` instead?

marmoute added inline comments.Dec 2 2020, 12:08 PM

rust/hg-core/src/copy_tracing.rs
320	This is embarrassingly true :-)

baymax updated this revision to Diff 23964.Dec 2 2020, 1:21 PM

SimonSapin added inline comments.Dec 2 2020, 1:46 PM

rust/hg-core/src/copy_tracing.rs
338	Nit: Although it doesn’t matter much since that expression is only evaluated in an error path that should never happen, `format!` here is unnecessary since `assert!` already supports string formatting by passing additional arguments. And, I don’t mind if you prefer keeping it but I’d have omitted this `assert!` entirely since vec indexing contains an equivalent one already. The more specific error message is not very valuable since the it should never happen, and if it does the stack trace would be enough to find where the panic comes from.

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

Alphare added a subscriber: Alphare.Dec 14 2020, 4:44 AM

Alphare added inline comments.

rust/hg-core/src/copy_tracing.rs
318	It would be helpful to add a small docstring explaining the optimization (since I'm assuming this lives for at least another few commits)

marmoute updated this revision to Diff 24216.Dec 14 2020, 6:17 AM

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

Alphare accepted this revision.Dec 14 2020, 8:05 AM

pulkit accepted this revision.Dec 17 2020, 6:12 AM

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

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

marmoute added a commit: rHGc6bc77f7e593: copies-rust: tokenize all paths into integer.Dec 18 2020, 3:05 PM

Closed by commit rHGc6bc77f7e593: copies-rust: tokenize all paths into integer (authored by marmoute). · Explain Why

This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

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

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	23941		Dec 2 2020, 11:02 AM	★	★
Diff 2	23964		Dec 2 2020, 1:21 PM	★	★
Diff 3	24122		Dec 8 2020, 6:25 AM	★	★
Diff 4	24135		Dec 8 2020, 10:11 PM	★	★
Diff 5	24216		Dec 14 2020, 6:16 AM	★	★
Diff 6	24245		Dec 14 2020, 7:59 AM	★	★
Diff 7	24354		Dec 17 2020, 3:36 PM	★	★
Diff 8	24382		Dec 18 2020, 8:15 AM	★	★
Diff 9	24424	rHGc6bc77f7e593a882d026264d9b28be783f1e0d42	Apr 25 2020, 6:37 AM	★	★

Status	Author	Revision
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	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	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 24424

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::OrdMap;			use im_rc::ordmap::OrdMap;

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

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

	type PathToken = HgPathBuf;			type PathToken = usize;

	#[derive(Clone, Debug, PartialEq)]			#[derive(Clone, Debug, PartialEq, Copy)]
	struct TimeStampedPathCopy {			struct TimeStampedPathCopy {
	/// 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>,
	}			}

	#[derive(Copy, Clone, Debug)]			#[derive(Copy, Clone, Debug)]
	enum Parent {			enum Parent {
	/// The `p1(x) → x` edge			/// The `p1(x) → x` edge
	FirstParent,			FirstParent,
	/// The `p2(x) → x` edge			/// The `p2(x) → x` edge
	SecondParent,			SecondParent,
	}			}

				/// A small "tokenizer" responsible of turning full HgPath into lighter
				/// PathToken
				AlphareUnsubmitted Not Done It would be helpful to add a small docstring explaining the optimization (since I'm assuming this lives for at least another few commits) Alphare: It would be helpful to add a small docstring explaining the optimization (since I'm assuming…
				///
				/// Dealing with small object, like integer is much faster, so HgPath input are
				SimonSapinUnsubmitted Not Done This `HashMap` has sequential integer keys. Could it be a `Vec<HgPathBuf>` instead? SimonSapin: This `HashMap` has sequential integer keys. Could it be a `Vec<HgPathBuf>` instead?
				marmouteAuthorUnsubmitted Done This is embarrassingly true :-) marmoute: This is embarrassingly true :-)
				/// turned into integer "PathToken" and converted back in the end.
				#[derive(Clone, Debug, Default)]
				struct TwoWayPathMap {
				token: HashMap<HgPathBuf, PathToken>,
				path: Vec<HgPathBuf>,
				}

				impl TwoWayPathMap {
				fn tokenize(&mut self, path: &HgPath) -> PathToken {
				match self.token.get(path) {
				Some(a) => *a,
				None => {
				let a = self.token.len();
				let buf = path.to_owned();
				self.path.push(buf.clone());
				self.token.insert(buf, a);
				a
				}
				SimonSapinUnsubmitted Not Done Nit: Although it doesn’t matter much since that expression is only evaluated in an error path that should never happen, `format!` here is unnecessary since `assert!` already supports string formatting by passing additional arguments. And, I don’t mind if you prefer keeping it but I’d have omitted this `assert!` entirely since vec indexing contains an equivalent one already. The more specific error message is not very valuable since the it should never happen, and if it does the stack trace would be enough to find where the panic comes from. SimonSapin: Nit: Although it doesn’t matter much since that expression is only evaluated in an error path…
				}
				}

				fn untokenize(&self, token: PathToken) -> &HgPathBuf {
				assert!(token < self.path.len(), format!("Unknown token: {}", token));
				&self.path[token]
				}
				}

	/// Same as mercurial.copies._combine_changeset_copies, but in Rust.			/// Same as mercurial.copies._combine_changeset_copies, but in Rust.
	///			///
	/// Arguments are:			/// Arguments are:
	///			///
	/// revs: all revisions to be considered			/// revs: all revisions to be considered
	/// children: a {parent ? [childrens]} mapping			/// children: a {parent ? [childrens]} mapping
	/// target_rev: the final revision we are combining copies to			/// target_rev: the final revision we are combining copies to
	/// rev_info(rev): callback to get revision information:			/// rev_info(rev): callback to get revision information:
	/// * first parent			/// * first parent
	/// * second parent			/// * second parent
	/// * ChangedFiles			/// * ChangedFiles
	/// isancestors(low_rev, high_rev): callback to check if a revision is an			/// isancestors(low_rev, high_rev): callback to check if a revision is an
	/// ancestor of another			/// ancestor of another
	pub fn combine_changeset_copies<A: Fn(Revision, Revision) -> bool, D>(			pub fn combine_changeset_copies<A: Fn(Revision, Revision) -> bool, D>(
	revs: Vec<Revision>,			revs: Vec<Revision>,
	mut children_count: HashMap<Revision, usize>,			mut children_count: HashMap<Revision, usize>,
	target_rev: Revision,			target_rev: Revision,
	rev_info: RevInfoMaker<D>,			rev_info: RevInfoMaker<D>,
	is_ancestor: &A,			is_ancestor: &A,
	) -> PathCopies {			) -> PathCopies {
	let mut all_copies = HashMap::new();			let mut all_copies = HashMap::new();
	let mut oracle = AncestorOracle::new(is_ancestor);			let mut oracle = AncestorOracle::new(is_ancestor);

				let mut path_map = TwoWayPathMap::default();

	for rev in revs {			for rev in revs {
	let mut d: DataHolder<D> = DataHolder { data: None };			let mut d: DataHolder<D> = DataHolder { data: None };
	let (p1, p2, changes) = rev_info(rev, &mut d);			let (p1, p2, changes) = rev_info(rev, &mut d);

	// We will chain the copies information accumulated for the parent with			// We will chain the copies information accumulated for the parent with
	// the individual copies information the curent revision. Creating a			// the individual copies information the curent revision. Creating a
	// new TimeStampedPath for each `rev` → `children` vertex.			// new TimeStampedPath for each `rev` → `children` vertex.
	let mut copies: Option<TimeStampedPathCopies> = None;			let mut copies: Option<TimeStampedPathCopies> = None;
	if p1 != NULL_REVISION {			if p1 != NULL_REVISION {
	// Retrieve data computed in a previous iteration			// Retrieve data computed in a previous iteration
	let parent_copies = get_and_clean_parent_copies(			let parent_copies = get_and_clean_parent_copies(
	&mut all_copies,			&mut all_copies,
	&mut children_count,			&mut children_count,
	p1,			p1,
	);			);
	if let Some(parent_copies) = parent_copies {			if let Some(parent_copies) = parent_copies {
	// combine it with data for that revision			// combine it with data for that revision
	let vertex_copies = add_from_changes(			let vertex_copies = add_from_changes(
				&mut path_map,
	&parent_copies,			&parent_copies,
	&changes,			&changes,
	Parent::FirstParent,			Parent::FirstParent,
	rev,			rev,
	);			);
	// keep that data around for potential later combination			// keep that data around for potential later combination
	copies = Some(vertex_copies);			copies = Some(vertex_copies);
	}			}
	}			}
	if p2 != NULL_REVISION {			if p2 != NULL_REVISION {
	// Retrieve data computed in a previous iteration			// Retrieve data computed in a previous iteration
	let parent_copies = get_and_clean_parent_copies(			let parent_copies = get_and_clean_parent_copies(
	&mut all_copies,			&mut all_copies,
	&mut children_count,			&mut children_count,
	p2,			p2,
	);			);
	if let Some(parent_copies) = parent_copies {			if let Some(parent_copies) = parent_copies {
	// combine it with data for that revision			// combine it with data for that revision
	let vertex_copies = add_from_changes(			let vertex_copies = add_from_changes(
				&mut path_map,
	&parent_copies,			&parent_copies,
	&changes,			&changes,
	Parent::SecondParent,			Parent::SecondParent,
	rev,			rev,
	);			);

	copies = match copies {			copies = match copies {
	None => Some(vertex_copies),			None => Some(vertex_copies),
	// Merge has two parents needs to combines their copy			// Merge has two parents needs to combines their copy
	// information.			// information.
	//			//
	// If we got data from both parents, We need to combine			// If we got data from both parents, We need to combine
	// them.			// them.
	Some(copies) => Some(merge_copies_dict(			Some(copies) => Some(merge_copies_dict(
				&path_map,
	vertex_copies,			vertex_copies,
	copies,			copies,
	&changes,			&changes,
	&mut oracle,			&mut oracle,
	)),			)),
	};			};
	}			}
	}			}
	match copies {			match copies {
	Some(copies) => {			Some(copies) => {
	all_copies.insert(rev, copies);			all_copies.insert(rev, copies);
	}			}
	_ => {}			_ => {}
	}			}
	}			}

	// Drop internal information (like the timestamp) and return the final			// Drop internal information (like the timestamp) and return the final
	// mapping.			// mapping.
	let tt_result = all_copies			let tt_result = all_copies
	.remove(&target_rev)			.remove(&target_rev)
	.expect("target revision was not processed");			.expect("target revision was not processed");
	let mut result = PathCopies::default();			let mut result = PathCopies::default();
	for (dest, tt_source) in tt_result {			for (dest, tt_source) in tt_result {
	if let Some(path) = tt_source.path {			if let Some(path) = tt_source.path {
	result.insert(dest, path);			let path_dest = path_map.untokenize(dest).to_owned();
				let path_path = path_map.untokenize(path).to_owned();
				result.insert(path_dest, path_path);
	}			}
	}			}
	result			result
	}			}

	/// fetch previous computed information			/// fetch previous computed information
	///			///
	/// If no other children are expected to need this information, we drop it from			/// If no other children are expected to need this information, we drop it from
	None => Some(TimeStampedPathCopies::default()),			None => Some(TimeStampedPathCopies::default()),
	}			}
	}			}
	}			}

	/// Combine ChangedFiles with some existing PathCopies information and return			/// Combine ChangedFiles with some existing PathCopies information and return
	/// the result			/// the result
	fn add_from_changes(			fn add_from_changes(
				path_map: &mut TwoWayPathMap,
	base_copies: &TimeStampedPathCopies,			base_copies: &TimeStampedPathCopies,
	changes: &ChangedFiles,			changes: &ChangedFiles,
	parent: Parent,			parent: Parent,
	current_rev: Revision,			current_rev: Revision,
	) -> TimeStampedPathCopies {			) -> TimeStampedPathCopies {
	let mut copies = base_copies.clone();			let mut copies = base_copies.clone();
	for action in changes.iter_actions(parent) {			for action in changes.iter_actions(parent) {
	match action {			match action {
	Action::Copied(dest, source) => {			Action::Copied(path_dest, path_source) => {
				let dest = path_map.tokenize(path_dest);
				let source = path_map.tokenize(path_source);
	let entry;			let entry;
	if let Some(v) = base_copies.get(source) {			if let Some(v) = base_copies.get(&source) {
	entry = match &v.path {			entry = match &v.path {
	Some(path) => Some((*(path)).to_owned()),			Some(path) => Some((*(path)).to_owned()),
	None => Some(source.to_owned()),			None => Some(source.to_owned()),
	}			}
	} else {			} else {
	entry = Some(source.to_owned());			entry = Some(source.to_owned());
	}			}
	// Each new entry is introduced by the children, we			// Each new entry is introduced by the children, we
	// record this information as we will need it to take			// record this information as we will need it to take
	// 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.
	let ttpc = TimeStampedPathCopy {			let ttpc = TimeStampedPathCopy {
	rev: current_rev,			rev: current_rev,
	path: entry,			path: entry,
	};			};
	copies.insert(dest.to_owned(), ttpc);			copies.insert(dest.to_owned(), ttpc);
	}			}
	Action::Removed(f) => {			Action::Removed(deleted_path) => {
	// We must drop copy information for removed file.			// We must drop copy information for removed file.
	//			//
	// We need to explicitly record them as dropped to			// We need to explicitly record them as dropped to
	// propagate this information when merging two			// propagate this information when merging two
	// TimeStampedPathCopies object.			// TimeStampedPathCopies object.
	if copies.contains_key(f.as_ref()) {			let deleted = path_map.tokenize(deleted_path);
				if copies.contains_key(&deleted) {
	let ttpc = TimeStampedPathCopy {			let ttpc = TimeStampedPathCopy {
	rev: current_rev,			rev: current_rev,
	path: None,			path: None,
	};			};
	copies.insert(f.to_owned(), ttpc);			copies.insert(deleted, ttpc);
	}			}
	}			}
	}			}
	}			}
	copies			copies
	}			}

	/// merge two copies-mapping together, minor and major			/// merge two copies-mapping together, minor and major
	///			///
	/// In case of conflict, value from "major" will be picked, unless in some			/// In case of conflict, value from "major" will be picked, unless in some
	/// cases. See inline documentation for details.			/// cases. See inline documentation for details.
	fn merge_copies_dict<A: Fn(Revision, Revision) -> bool>(			fn merge_copies_dict<A: Fn(Revision, Revision) -> bool>(
				path_map: &TwoWayPathMap,
	mut minor: TimeStampedPathCopies,			mut minor: TimeStampedPathCopies,
	mut major: TimeStampedPathCopies,			mut major: TimeStampedPathCopies,
	changes: &ChangedFiles,			changes: &ChangedFiles,
	oracle: &mut AncestorOracle<A>,			oracle: &mut AncestorOracle<A>,
	) -> TimeStampedPathCopies {			) -> TimeStampedPathCopies {
	// This closure exist as temporary help while multiple developper are			// This closure exist as temporary help while multiple developper are
	// actively working on this code. Feel free to re-inline it once this			// actively working on this code. Feel free to re-inline it once this
	// code is more settled.			// code is more settled.
	let mut cmp_value =			let mut cmp_value =
	\|dest: &PathToken,			\|dest: &PathToken,
	src_minor: &TimeStampedPathCopy,			src_minor: &TimeStampedPathCopy,
	src_major: &TimeStampedPathCopy\| {			src_major: &TimeStampedPathCopy\| {
	compare_value(changes, oracle, dest, src_minor, src_major)			compare_value(
				path_map, changes, oracle, dest, src_minor, src_major,
				)
	};			};
	if minor.is_empty() {			if minor.is_empty() {
	major			major
	} else if major.is_empty() {			} else if major.is_empty() {
	minor			minor
	} else if minor.len() * 2 < major.len() {			} else if minor.len() * 2 < major.len() {
	// Lets says we are merging two TimeStampedPathCopies instance A and B.			// Lets says we are merging two TimeStampedPathCopies instance A and B.
	//			//
	Minor,			Minor,
	/// Any side could be used (because they are the same)			/// Any side could be used (because they are the same)
	Any,			Any,
	}			}

	/// decide which side prevails in case of conflicting values			/// decide which side prevails in case of conflicting values
	#[allow(clippy::if_same_then_else)]			#[allow(clippy::if_same_then_else)]
	fn compare_value<A: Fn(Revision, Revision) -> bool>(			fn compare_value<A: Fn(Revision, Revision) -> bool>(
				path_map: &TwoWayPathMap,
	changes: &ChangedFiles,			changes: &ChangedFiles,
	oracle: &mut AncestorOracle<A>,			oracle: &mut AncestorOracle<A>,
	dest: &PathToken,			dest: &PathToken,
	src_minor: &TimeStampedPathCopy,			src_minor: &TimeStampedPathCopy,
	src_major: &TimeStampedPathCopy,			src_major: &TimeStampedPathCopy,
	) -> MergePick {			) -> MergePick {
	if src_major.path == src_minor.path {			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
	MergePick::Any			MergePick::Any
	} else if oracle.is_ancestor(src_major.rev, src_minor.rev) {			} else if oracle.is_ancestor(src_major.rev, src_minor.rev) {
	MergePick::Minor			MergePick::Minor
	} else {			} else {
	MergePick::Major			MergePick::Major
	}			}
	} 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!(
	"conflict information from p1 and p2 in the same revision"			"conflict information from p1 and p2 in the same revision"
	);			);
	} else {			} else {
	let action = changes.get_merge_case(&dest);			let dest_path = path_map.untokenize(*dest);
				let action = changes.get_merge_case(dest_path);
	if src_major.path.is_none() && action == MergeCase::Salvaged {			if src_major.path.is_none() && action == MergeCase::Salvaged {
	// If the file is "deleted" in the major side but was			// If the file is "deleted" in the major side but was
	// salvaged by the merge, we keep the minor side alive			// salvaged by the merge, we keep the minor side alive
	MergePick::Minor			MergePick::Minor
	} else if src_minor.path.is_none() && action == MergeCase::Salvaged {			} else if src_minor.path.is_none() && 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.

This is an archive of the discontinued Mercurial Phabricator instance.

copies-rust: tokenize all paths into integerClosedPublic

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 filelog sidedata Difference Factor time per rev

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 24424

rust/hg-core/src/copy_tracing.rs

copies-rust: tokenize all paths into integer
ClosedPublic

Revision Contents
Changeset List