Mercurial > hg4j

annotate test/org/tmatesoft/hg/test/MapTagsToFileRevisions.java @ 436:9265f7f4b49b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Updated sample to map changeset and file revisions
author Artem Tikhomirov <tikhomirov.artem@gmail.com>
date Tue, 17 Apr 2012 22:29:25 +0200
parents be697c3e951e
children 0d128e09d70f
rev   line source
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
1 package org.tmatesoft.hg.test;
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
2
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
3 import static org.tmatesoft.hg.repo.HgRepository.TIP;
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
4
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
5 import java.io.File;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
6 import java.util.ArrayList;
256
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
7 import java.util.Arrays;
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
8 import java.util.HashMap;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
9 import java.util.LinkedList;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
10 import java.util.List;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
11 import java.util.Map;
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
12
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
13 import org.junit.Assert;
423
9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 368
diff changeset
14 import org.tmatesoft.hg.core.HgCallbackTargetException;
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
15 import org.tmatesoft.hg.core.HgChangeset;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
16 import org.tmatesoft.hg.core.HgChangesetHandler;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
17 import org.tmatesoft.hg.core.HgException;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
18 import org.tmatesoft.hg.core.HgLogCommand;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
19 import org.tmatesoft.hg.core.Nodeid;
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
20 import org.tmatesoft.hg.internal.IntMap;
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
21 import org.tmatesoft.hg.repo.HgChangelog;
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
22 import org.tmatesoft.hg.repo.HgChangelog.RawChangeset;
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
23 import org.tmatesoft.hg.repo.HgDataFile;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
24 import org.tmatesoft.hg.repo.HgLookup;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
25 import org.tmatesoft.hg.repo.HgManifest;
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
26 import org.tmatesoft.hg.repo.HgManifest.Flags;
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
27 import org.tmatesoft.hg.repo.HgRepository;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
28 import org.tmatesoft.hg.repo.HgTags;
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
29 import org.tmatesoft.hg.repo.HgTags.TagInfo;
433
be697c3e951e Revlog.RevisionMap helper class got promoted as TLC, renamed to HgRevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
30 import org.tmatesoft.hg.repo.HgRevisionMap;
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
31 import org.tmatesoft.hg.util.CancelledException;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
32 import org.tmatesoft.hg.util.Path;
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
33
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
34 /**
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
35 * @author Marc Strapetz
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
36 */
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
37 public class MapTagsToFileRevisions {
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
38
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
39 // Static =================================================================
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
40
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
41 public static void main(String[] args) throws Exception {
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
42 MapTagsToFileRevisions m = new MapTagsToFileRevisions();
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
43 System.out.printf("Free mem: %,d\n", Runtime.getRuntime().freeMemory());
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
44 // m.measurePatchAffectsArbitraryRevisionRead();
329
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
45 // m.collectTagsPerFile();
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
46 // m.manifestWalk();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
47 // m.changelogWalk();
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
48 // m.revisionMap();
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
49 m.buildFile2ChangelogRevisionMap(".hgtags", "README", "configure.in", "Misc/NEWS");
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
50 m = null;
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
51 System.gc();
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
52 System.out.printf("Free mem: %,d\n", Runtime.getRuntime().freeMemory());
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
53 }
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
54
329
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
55
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
56 // revision == 2406 - 5 ms per run (baseRevision == 2406)
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
57 // revision == 2405 - 69 ms per run (baseRevision == 1403)
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
58 private void measurePatchAffectsArbitraryRevisionRead() throws Exception {
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
59 final HgRepository repository = new HgLookup().detect(new File("/temp/hg/cpython"));
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
60 final DoNothingManifestInspector insp = new DoNothingManifestInspector();
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
61 final int revision = 2405;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
62 // warm-up.
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
63 repository.getManifest().walk(revision, revision, insp);
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
64 final int runs = 10;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
65 final long start = System.nanoTime();
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
66 for (int i = 0; i < runs; i++) {
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
67 repository.getManifest().walk(revision, revision, insp);
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
68 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
69 final long end = System.nanoTime();
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
70 System.out.printf("%d ms per run\n", (end - start)/ (runs*1000000));
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
71 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
72
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
73 /*
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
74 * .hgtags, 261 revisions
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
75 * Approach 1: total 83, init: 0, iteration: 82
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
76 * Approach 2: total 225, init: 206, iteration: 19
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
77 * README, 465 revisions
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
78 * Approach 1: total 162, init: 0, iteration: 161
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
79 * Approach 2: total 231, init: 198, iteration: 32
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
80 * configure.in, 1109 revisions
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
81 * Approach 1: total 409, init: 1, iteration: 407
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
82 * Approach 2: total 277, init: 203, iteration: 74
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
83 */
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
84 /* New data, 0.9.0v (another CPU!)
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
85 *.hgtags, 306 revisions
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
86 * Approach 0: total 136
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
87 * Approach 1: total 53, init: 1, iteration: 52
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
88 * Approach 2: total 95, init: 78, iteration: 17
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
89 * Approach 3: total 17
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
90 *
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
91 * README, 499 revisions
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
92 * Approach 0: total 149
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
93 * Approach 1: total 43, init: 0, iteration: 43
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
94 * Approach 2: total 102, init: 86, iteration: 16
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
95 * Approach 3: total 18
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
96 *
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
97 * configure.in, 1170 revisions
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
98 * Approach 0: total 321
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
99 * Approach 1: total 116, init: 0, iteration: 115
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
100 * Approach 2: total 140, init: 79, iteration: 60
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
101 * Approach 3: total 30
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
102 *
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
103 * Misc/NEWS, 10863 revisions
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
104 * Approach 0: total 4946
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
105 * Approach 1: total 309, init: 6, iteration: 302
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
106 * Approach 2: total 213, init: 63, iteration: 150
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
107 * Approach 3: total 140
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
108 */
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
109 private void buildFile2ChangelogRevisionMap(String... fileNames) throws Exception {
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
110 final HgRepository repository = new HgLookup().detect(new File("/home/artem/hg/cpython"));
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
111 final HgChangelog clog = repository.getChangelog();
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
112 // warm-up
433
be697c3e951e Revlog.RevisionMap helper class got promoted as TLC, renamed to HgRevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
113 HgRevisionMap<HgChangelog> clogMap = new HgRevisionMap<HgChangelog>(clog).init();
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
114
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
115 for (String fname : fileNames) {
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
116 HgDataFile fileNode = repository.getFileNode(fname);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
117 // warm-up
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
118 HgRevisionMap<HgDataFile> fileMap = new HgRevisionMap<HgDataFile>(fileNode).init();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
119 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
120 final int latestRevision = fileNode.getLastRevision();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
121 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
122 final long start_0 = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
123 final Map<Nodeid, Nodeid> changesetToNodeid_0 = new HashMap<Nodeid, Nodeid>();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
124 for (int fileRevisionIndex = 0; fileRevisionIndex <= latestRevision; fileRevisionIndex++) {
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
125 Nodeid fileRevision = fileNode.getRevision(fileRevisionIndex);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
126 Nodeid changesetRevision = fileNode.getChangesetRevision(fileRevision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
127 changesetToNodeid_0.put(changesetRevision, fileRevision);
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
128 }
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
129 final long end_0 = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
130 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
131 final long start_1 = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
132 fileMap = new HgRevisionMap<HgDataFile>(fileNode).init();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
133 final long start_1a = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
134 final Map<Nodeid, Nodeid> changesetToNodeid_1 = new HashMap<Nodeid, Nodeid>();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
135 for (int revision = 0; revision <= latestRevision; revision++) {
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
136 final Nodeid nodeId = fileMap.revision(revision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
137 int localCset = fileNode.getChangesetRevisionIndex(revision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
138 final Nodeid changesetId = clog.getRevision(localCset);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
139 // final Nodeid changesetId = fileNode.getChangesetRevision(nodeId);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
140 changesetToNodeid_1.put(changesetId, nodeId);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
141 }
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
142 final long end_1 = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
143 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
144 final long start_2 = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
145 clogMap = new HgRevisionMap<HgChangelog>(clog).init();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
146 fileMap = new HgRevisionMap<HgDataFile>(fileNode).init();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
147 final Map<Nodeid, Nodeid> changesetToNodeid_2 = new HashMap<Nodeid, Nodeid>();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
148 final long start_2a = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
149 for (int revision = 0; revision <= latestRevision; revision++) {
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
150 Nodeid nidFile = fileMap.revision(revision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
151 int localCset = fileNode.getChangesetRevisionIndex(revision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
152 Nodeid nidCset = clogMap.revision(localCset);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
153 changesetToNodeid_2.put(nidCset, nidFile);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
154 }
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
155 final long end_2 = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
156 Assert.assertEquals(changesetToNodeid_1, changesetToNodeid_2);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
157 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
158 final long start_3 = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
159 final Map<Nodeid, Nodeid> changesetToNodeid_3 = new HashMap<Nodeid, Nodeid>();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
160 fileNode.indexWalk(0, TIP, new HgDataFile.RevisionInspector() {
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
161
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
162 public void next(int fileRevisionIndex, Nodeid revision, int linkedRevisionIndex) {
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
163 changesetToNodeid_3.put(clog.getRevision(linkedRevisionIndex), revision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
164 }
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
165 });
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
166 final long end_3 = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
167 Assert.assertEquals(changesetToNodeid_1, changesetToNodeid_3);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
168 System.out.printf("%s, %d revisions\n", fname, 1+latestRevision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
169 System.out.printf("Approach 0: total %d\n", (end_0 - start_0)/1000000);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
170 System.out.printf("Approach 1: total %d, init: %d, iteration: %d\n", (end_1 - start_1)/1000000, (start_1a - start_1)/1000000, (end_1 - start_1a)/1000000);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
171 System.out.printf("Approach 2: total %d, init: %d, iteration: %d\n", (end_2 - start_2)/1000000, (start_2a - start_2)/1000000, (end_2 - start_2a)/1000000);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
172 System.out.printf("Approach 3: total %d\n", (end_3 - start_3)/1000000);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
173 }
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
174 }
263
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
175
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
176 /*
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
177 * Each 5000 revisions from cpython, total 15 revisions
367
2fadf8695f8a Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 366
diff changeset
178 * Direct clog.getRevisionIndex: ~260 ms
2fadf8695f8a Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 366
diff changeset
179 * RevisionMap.revisionIndex: ~265 ms (almost 100% in #init())
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
180 * each 1000'th revision, total 71 revision: 1 230 vs 270
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
181 * each 2000'th revision, total 36 revision: 620 vs 270
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
182 * each 3000'th revision, total 24 revision: 410 vs 275
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
183 */
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
184 private void revisionMap() throws Exception {
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
185 final HgRepository repository = new HgLookup().detect(new File("/temp/hg/cpython"));
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
186 final HgChangelog clog = repository.getChangelog();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
187 ArrayList<Nodeid> revisions = new ArrayList<Nodeid>();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
188 final int step = 5000;
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
189 for (int i = 0, top = clog.getLastRevision(); i < top; i += step) {
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
190 revisions.add(clog.getRevision(i));
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
191 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
192 final long s1 = System.nanoTime();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
193 for (Nodeid n : revisions) {
367
2fadf8695f8a Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 366
diff changeset
194 int r = clog.getRevisionIndex(n);
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
195 if (r % step != 0) {
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
196 throw new IllegalStateException(Integer.toString(r));
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
197 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
198 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
199 System.out.printf("Direct lookup of %d revisions took %,d ns\n", revisions.size(), System.nanoTime() - s1);
433
be697c3e951e Revlog.RevisionMap helper class got promoted as TLC, renamed to HgRevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
200 HgRevisionMap<HgChangelog> rmap = new HgRevisionMap<HgChangelog>(clog);
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
201 final long s2 = System.nanoTime();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
202 rmap.init();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
203 final long s3 = System.nanoTime();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
204 for (Nodeid n : revisions) {
367
2fadf8695f8a Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 366
diff changeset
205 int r = rmap.revisionIndex(n);
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
206 if (r % step != 0) {
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
207 throw new IllegalStateException(Integer.toString(r));
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
208 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
209 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
210 System.out.printf("RevisionMap time: %d ms, of that init() %,d ns\n", (System.nanoTime() - s2) / 1000000, s3 - s2);
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
211 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
212
263
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
213 private void changelogWalk() throws Exception {
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
214 final HgRepository repository = new HgLookup().detect(new File("/temp/hg/cpython"));
263
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
215 final long start = System.currentTimeMillis();
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
216 repository.getChangelog().all(new HgChangelog.Inspector() {
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
217 public int xx = 0;
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
218
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
219 public void next(int revisionNumber, Nodeid nodeid, RawChangeset cset) {
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
220 if (xx+revisionNumber < 0) {
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
221 System.out.println(xx);
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
222 System.out.println(revisionNumber);
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
223 }
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
224 xx += revisionNumber;
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
225 }
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
226 });
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
227 // cpython: 17 seconds, mem 132,9 -> 129,0 -> 131,7
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
228 // cpyhton: 13 seconds. Of that, cumulative Patch.apply takes 8.8 seconds, RevlogStream.Inspector.next - 1.8
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
229 System.out.printf("Total time: %d ms\n", System.currentTimeMillis() - start);
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
230 System.out.printf("Free mem: %,d\n", Runtime.getRuntime().freeMemory());
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
231 }
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
232
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
233 private void manifestWalk() throws Exception {
268
c5980f287cc4 Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 263
diff changeset
234 System.out.println(System.getProperty("java.version"));
263
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
235 final long start = System.currentTimeMillis();
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
236 final HgRepository repository = new HgLookup().detect(new File("/temp/hg/cpython"));
329
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
237 repository.getManifest().walk(0, 10000, new DoNothingManifestInspector());
263
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
238 // cpython: 1,1 sec for 0..1000, 43 sec for 0..10000, 115 sec for 0..20000 (Pool with HashMap)
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
239 // 2,4 sec for 1000..2000
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
240 // cpython -r 1000: 484 files, -r 2000: 1015 files. Iteration 1000..2000; fnamePool.size:1019 nodeidPool.size:2989
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
241 // nodeidPool for two subsequent revisions only: 840. 37 sec for 0..10000. 99 sec for 0..20k
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
242 // 0..10000 fnamePool: hits:15989152, misses:3020
268
c5980f287cc4 Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 263
diff changeset
243 //
c5980f287cc4 Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 263
diff changeset
244 // With Pool<StringProxy> for fname and flags, Nodeid's ascii2bin through local array, overall byte[] iteration,
c5980f287cc4 Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 263
diff changeset
245 // 0..10k is 34 seconds now
304
85b8efde5586 Use memory-friendly set implementation to canonicalize filenames and nodeids
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 285
diff changeset
246 // Another run, 23 seconds now, seems nothing has been changed. Switched to Pool2 with DirectHashSet: 22,5 seconds
263
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
247 System.out.printf("Total time: %d ms\n", System.currentTimeMillis() - start);
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
248 System.out.printf("Free mem: %,d\n", Runtime.getRuntime().freeMemory());
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
249 }
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
250
433
be697c3e951e Revlog.RevisionMap helper class got promoted as TLC, renamed to HgRevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
251 private int[] collectLocalTagRevisions(HgRevisionMap<HgChangelog> clogrmap, TagInfo[] allTags, IntMap<List<TagInfo>> tagLocalRev2TagInfo) {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
252 int[] tagLocalRevs = new int[allTags.length];
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
253 int x = 0;
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
254 for (int i = 0; i < allTags.length; i++) {
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
255 final Nodeid tagRevision = allTags[i].revision();
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
256 final int tagRevisionIndex = clogrmap.revisionIndex(tagRevision);
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
257 if (tagRevisionIndex != HgRepository.BAD_REVISION) {
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
258 tagLocalRevs[x++] = tagRevisionIndex;
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
259 List<TagInfo> tagsAssociatedWithRevision = tagLocalRev2TagInfo.get(tagRevisionIndex);
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
260 if (tagsAssociatedWithRevision == null) {
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
261 tagLocalRev2TagInfo.put(tagRevisionIndex, tagsAssociatedWithRevision = new LinkedList<TagInfo>());
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
262 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
263 tagsAssociatedWithRevision.add(allTags[i]);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
264 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
265 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
266 if (x != allTags.length) {
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
267 // some tags were removed (recorded Nodeid.NULL tagname)
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
268 int[] copy = new int[x];
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
269 System.arraycopy(tagLocalRevs, 0, copy, 0, x);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
270 tagLocalRevs = copy;
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
271 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
272 return tagLocalRevs;
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
273 }
263
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
274
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
275 private void collectTagsPerFile() throws HgException, CancelledException {
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
276 final long start = System.currentTimeMillis();
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
277 final HgRepository repository = new HgLookup().detect(new File("/temp/hg/cpython"));
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
278 final HgTags tags = repository.getTags();
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
279 //
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
280 // build cache
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
281 //
423
9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 368
diff changeset
282 final TagInfo[] allTags = new TagInfo[tags.getAllTags().size()];
9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 368
diff changeset
283 tags.getAllTags().values().toArray(allTags);
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
284 // effective translation of changeset revisions to their local indexes
433
be697c3e951e Revlog.RevisionMap helper class got promoted as TLC, renamed to HgRevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
285 final HgRevisionMap<HgChangelog> clogrmap = new HgRevisionMap<HgChangelog>(repository.getChangelog()).init();
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
286 // map to look up tag by changeset local number
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
287 final IntMap<List<TagInfo>> tagLocalRev2TagInfo = new IntMap<List<TagInfo>>(allTags.length);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
288 System.out.printf("Collecting manifests for %d tags\n", allTags.length);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
289 final int[] tagLocalRevs = collectLocalTagRevisions(clogrmap, allTags, tagLocalRev2TagInfo);
329
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
290 System.out.printf("Prepared %d tag revisions to analyze: %d ms\n", tagLocalRevs.length, System.currentTimeMillis() - start);
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
291
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
292 final Path targetPath = Path.create("README");
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
293 //
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
294 collectTagsPerFile_Approach_1(clogrmap, tagLocalRevs, allTags, targetPath);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
295 System.out.printf("Total time: %d ms\n", System.currentTimeMillis() - start);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
296
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
297 System.out.println("\nApproach 2");
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
298 collectTagsPerFile_Approach_2(repository, tagLocalRevs, tagLocalRev2TagInfo, allTags, targetPath);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
299 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
300
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
301 // Approach 1. Build map with all files, their revisions and corresponding tags
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
302 //
433
be697c3e951e Revlog.RevisionMap helper class got promoted as TLC, renamed to HgRevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
303 private void collectTagsPerFile_Approach_1(final HgRevisionMap clogrmap, final int[] tagLocalRevs, final TagInfo[] allTags, Path targetPath) throws HgException {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
304 HgRepository repository = clogrmap.getRepo();
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
305 final long start = System.currentTimeMillis();
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
306 // file2rev2tag value is array of revisions, always of allTags.length. Revision index in the array
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
307 // is index of corresponding TagInfo in allTags;
285
6dbbc53fc46d Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 268
diff changeset
308 final Map<Path, Nodeid[]> file2rev2tag = new HashMap<Path, Nodeid[]>();
424
6437d261048a Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 423
diff changeset
309 repository.getManifest().walk(new HgManifest.Inspector() {
256
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
310 private int[] tagIndexAtRev = new int[4]; // it's unlikely there would be a lot of tags associated with a given cset
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
311
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
312 public boolean begin(int mainfestRevision, Nodeid nid, int changelogRevision) {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
313 // may do better here using tagLocalRev2TagInfo, but need to change a lot, too lazy now
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
314 Nodeid cset = clogrmap.revision(changelogRevision);
256
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
315 Arrays.fill(tagIndexAtRev, -1);
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
316 for (int i = 0, x = 0; i < allTags.length; i++) {
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
317 if (cset.equals(allTags[i].revision())) {
256
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
318 tagIndexAtRev[x++] = i;
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
319 if (x == tagIndexAtRev.length) {
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
320 // expand twice as much
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
321 int[] expanded = new int[x << 1];
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
322 System.arraycopy(tagIndexAtRev, 0, expanded, 0, x);
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
323 expanded[x] = -1; // just in case there'd be no more tags associated with this cset
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
324 tagIndexAtRev = expanded;
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
325 }
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
326 }
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
327 }
256
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
328 if (tagIndexAtRev[0] == -1) {
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
329 System.out.println("Can't happen, provided we iterate over revisions with tags only");
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
330 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
331 return true;
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
332 }
285
6dbbc53fc46d Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 268
diff changeset
333
6dbbc53fc46d Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 268
diff changeset
334 public boolean next(Nodeid nid, Path fname, HgManifest.Flags flags) {
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
335 Nodeid[] m = file2rev2tag.get(fname);
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
336 if (m == null) {
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
337 file2rev2tag.put(fname, m = new Nodeid[allTags.length]);
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
338 }
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
339 for (int tagIndex : tagIndexAtRev) {
256
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
340 if (tagIndex == -1) {
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
341 break;
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
342 }
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
343 if (m[tagIndex] != null) {
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
344 System.out.printf("There's another revision (%s) associated with tag %s already while we try to associate %s\n", m[tagIndex].shortNotation(), allTags[tagIndex].name(), nid.shortNotation());
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
345 }
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
346 m[tagIndex] = nid;
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
347 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
348 return true;
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
349 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
350
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
351 public boolean end(int manifestRevision) {
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
352 return true;
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
353 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
354
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
355 }, tagLocalRevs);
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
356 System.out.printf("Cache built: %d ms\n", System.currentTimeMillis() - start);
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
357 //
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
358 // look up specific file. This part is fast.
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
359 HgDataFile fileNode = repository.getFileNode(targetPath);
285
6dbbc53fc46d Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 268
diff changeset
360 final Nodeid[] allTagsOfTheFile = file2rev2tag.get(targetPath);
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
361 // TODO if fileNode.isCopy, repeat for each getCopySourceName()
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
362 for (int fileRevIndex = 0; fileRevIndex < fileNode.getRevisionCount(); fileRevIndex++) {
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
363 Nodeid fileRev = fileNode.getRevision(fileRevIndex);
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
364 int changesetRevIndex = fileNode.getChangesetRevisionIndex(fileRevIndex);
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
365 List<String> associatedTags = new LinkedList<String>();
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
366 for (int i = 0; i < allTagsOfTheFile.length; i++) {
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
367 if (fileRev.equals(allTagsOfTheFile[i])) {
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
368 associatedTags.add(allTags[i].name());
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
369 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
370 }
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
371 System.out.printf("%3d%7d%s\n", fileRevIndex, changesetRevIndex, associatedTags);
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
372 }
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
373 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
374
366
189dc6dc1c3e Use exceptions to expose errors reading mercurial data
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
375 private void collectTagsPerFile_Approach_2(HgRepository repository, final int[] tagLocalRevs, final IntMap<List<TagInfo>> tagLocalRev2TagInfo, TagInfo[] allTags, Path targetPath) throws HgException {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
376 //
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
377 // Approach 2. No all-file map. Collect file revisions recorded at the time of tagging,
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
378 // then for each file revision check if it is among those above, and if yes, take corresponding tags
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
379 HgDataFile fileNode = repository.getFileNode(targetPath);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
380 final long start2 = System.nanoTime();
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
381 final int lastRev = fileNode.getLastRevision();
426
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
382 final Map<Integer, Nodeid> fileRevisionAtTagRevision = new HashMap<Integer, Nodeid>();
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
383 HgManifest.Inspector collectFileRevAtCset = new HgManifest.Inspector() {
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
384
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
385 private int csetRevIndex;
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
386
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
387 public boolean next(Nodeid nid, Path fname, Flags flags) {
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
388 fileRevisionAtTagRevision.put(csetRevIndex, nid);
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
389 return true;
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
390 }
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
391
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
392 public boolean end(int manifestRevision) {
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
393 return true;
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
394 }
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
395
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
396 public boolean begin(int mainfestRevision, Nodeid nid, int changelogRevision) {
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
397 csetRevIndex = changelogRevision;
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
398 return true;
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
399 }
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
400 };
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
401 repository.getManifest().walkFileRevisions(targetPath, collectFileRevAtCset,tagLocalRevs);
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
402
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
403 final long start2a = System.nanoTime();
431
12f668401613 FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 427
diff changeset
404 fileNode.indexWalk(0, lastRev, new HgDataFile.RevisionInspector() {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
405
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
406 public void next(int fileRevisionIndex, Nodeid fileRevision, int changesetRevisionIndex) {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
407 List<String> associatedTags = new LinkedList<String>();
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
408 for (int taggetRevision : tagLocalRevs) {
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
409 // current file revision can't appear in tags that point to earlier changelog revisions (they got own file revision)
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
410 if (taggetRevision >= changesetRevisionIndex) {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
411 // z points to some changeset with tag
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
412 Nodeid wasKnownAs = fileRevisionAtTagRevision.get(taggetRevision);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
413 if (wasKnownAs.equals(fileRevision)) {
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
414 // has tag associated with changeset at index z
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
415 List<TagInfo> tagsAtRev = tagLocalRev2TagInfo.get(taggetRevision);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
416 assert tagsAtRev != null;
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
417 for (TagInfo ti : tagsAtRev) {
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
418 associatedTags.add(ti.name());
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
419 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
420 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
421 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
422 }
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
423 System.out.printf("%3d%7d%s\n", fileRevisionIndex, changesetRevisionIndex, associatedTags);
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
424 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
425 });
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
426 System.out.printf("Alternative total time: %d ms, of that init: %d ms\n", (System.nanoTime() - start2)/1000000, (start2a-start2)/1000000);
255
5a6ab50b4cbf Improve memory footprint of tag collection (about 14 Mb saved for cpython repo without HashMap.Entry and Entry[])
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 254
diff changeset
427 System.out.printf("Free mem: %,d\n", Runtime.getRuntime().freeMemory());
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
428 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
429
424
6437d261048a Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 423
diff changeset
430 static class DoNothingManifestInspector implements HgManifest.Inspector {
329
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
431 public boolean begin(int mainfestRevision, Nodeid nid, int changelogRevision) {
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
432 return true;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
433 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
434 public boolean next(Nodeid nid, Path fname, Flags flags) {
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
435 return true;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
436 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
437 public boolean end(int manifestRevision) {
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
438 return true;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
439 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
440 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
441
423
9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 368
diff changeset
442 public static void main2(String[] args) throws HgCallbackTargetException, HgException, CancelledException {
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
443 final HgRepository repository = new HgLookup().detect(new File("/temp/hg/cpython"));
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
444 final Path targetPath = Path.create("README");
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
445 final HgTags tags = repository.getTags();
423
9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 368
diff changeset
446 final Map<String, HgTags.TagInfo> tagToInfo = tags.getAllTags();
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
447 final HgManifest manifest = repository.getManifest();
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
448 final Map<Nodeid, List<String>> changeSetRevisionToTags = new HashMap<Nodeid, List<String>>();
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
449 final HgDataFile fileNode = repository.getFileNode(targetPath);
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
450 for (String tagName : tagToInfo.keySet()) {
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
451 final HgTags.TagInfo info = tagToInfo.get(tagName);
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
452 final Nodeid nodeId = info.revision();
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
453 // TODO: This is not correct as we can't be sure that file at the corresponding revision is actually our target file (which may have been renamed, etc.)
367
2fadf8695f8a Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 366
diff changeset
454 final Nodeid fileRevision = manifest.getFileRevision(repository.getChangelog().getRevisionIndex(nodeId), targetPath);
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
455 if (fileRevision == null) {
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
456 continue;
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
457 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
458
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
459 final Nodeid changeSetRevision = fileNode.getChangesetRevision(fileRevision);
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
460 List<String> revisionTags = changeSetRevisionToTags.get(changeSetRevision);
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
461 if (revisionTags == null) {
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
462 revisionTags = new ArrayList<String>();
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
463 changeSetRevisionToTags.put(changeSetRevision, revisionTags);
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
464 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
465 revisionTags.add(tagName);
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
466 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
467
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
468 final HgLogCommand logCommand = new HgLogCommand(repository);
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
469 logCommand.file(targetPath, true);
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
470 logCommand.execute(new HgChangesetHandler() {
427
31a89587eb04 FIXMEs: consistent names, throws for commands and their handlers. Use of checked exceptions in hi-level api
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 426
diff changeset
471 public void cset(HgChangeset changeset) {
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
472 if (changeset.getAffectedFiles().contains(targetPath)) {
423
9c9c442b5f2e Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 368
diff changeset
473 System.out.println(changeset.getRevisionIndex() + " " + changeSetRevisionToTags.get(changeset.getNodeid()));
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
474 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
475 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
476 });
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
477 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
478 }