Mercurial > hg4j

annotate test/org/tmatesoft/hg/test/MapTagsToFileRevisions.java @ 655:bcbcc318f250

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Performance: reuse unzip output buffer
author Artem Tikhomirov <tikhomirov.artem@gmail.com>
date Thu, 04 Jul 2013 18:36:38 +0200
parents 6526d8adbc0f
children
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;
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
8 import java.util.Collections;
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
9 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
10 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
11 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
12 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
13
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
14 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
15 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
16 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
17 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
18 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
19 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
20 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
21 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
22 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
23 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
24 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
25 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
26 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
27 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
28 import org.tmatesoft.hg.repo.HgRepository;
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 438
diff changeset
29 import org.tmatesoft.hg.repo.HgRuntimeException;
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
30 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
31 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
32 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
33 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
34 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
35
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 * @author Marc Strapetz
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 public class MapTagsToFileRevisions {
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
40
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
41 // Static =================================================================
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
42
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
43 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
44 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
45 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
46 // m.measurePatchAffectsArbitraryRevisionRead();
329
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
47 // m.collectTagsPerFile();
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
48 // m.manifestWalk();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
49 // m.changelogWalk();
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
50 // m.revisionMap();
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
51 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
52 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
53 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
54 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
55 }
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
56
329
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
57
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
58 // 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
59 // revision == 2405 - 69 ms per run (baseRevision == 1403)
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
60 public void measurePatchAffectsArbitraryRevisionRead() throws Exception {
329
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
61 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
62 final DoNothingManifestInspector insp = new DoNothingManifestInspector();
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
63 final int revision = 2405;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
64 // warm-up.
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
65 repository.getManifest().walk(revision, revision, insp);
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
66 final int runs = 10;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
67 final long start = System.nanoTime();
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
68 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
69 repository.getManifest().walk(revision, revision, insp);
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
70 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
71 final long end = System.nanoTime();
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
72 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
73 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
74
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
75 /*
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
76 * .hgtags, 261 revisions
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
77 * 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
78 * 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
79 * README, 465 revisions
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
80 * 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
81 * 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
82 * configure.in, 1109 revisions
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
83 * 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
84 * 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
85 */
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
86 /* 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
87 *.hgtags, 306 revisions
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
88 * Approach 0: total 136
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
89 * 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
90 * 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
91 * Approach 3: total 17
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
92 *
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
93 * README, 499 revisions
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
94 * Approach 0: total 149
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
95 * 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
96 * 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
97 * Approach 3: total 18
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
98 *
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
99 * configure.in, 1170 revisions
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
100 * Approach 0: total 321
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
101 * 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
102 * 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
103 * Approach 3: total 30
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
104 *
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
105 * Misc/NEWS, 10863 revisions
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
106 * Approach 0: total 4946
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
107 * 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
108 * 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
109 * Approach 3: total 140
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
110 */
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
111 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
112 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
113 final HgChangelog clog = repository.getChangelog();
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
114 // 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
115 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
116
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
117 for (String fname : fileNames) {
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
118 HgDataFile fileNode = repository.getFileNode(fname);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
119 // warm-up
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
120 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
121 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
122 final int latestRevision = fileNode.getLastRevision();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
123 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
124 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
125 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
126 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
127 Nodeid fileRevision = fileNode.getRevision(fileRevisionIndex);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
128 Nodeid changesetRevision = fileNode.getChangesetRevision(fileRevision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
129 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
130 }
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
131 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
132 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
133 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
134 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
135 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
136 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
137 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
138 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
139 int localCset = fileNode.getChangesetRevisionIndex(revision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
140 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
141 // 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
142 changesetToNodeid_1.put(changesetId, nodeId);
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 end_1 = System.nanoTime();
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
145 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
146 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
147 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
148 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
149 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
150 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
151 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
152 Nodeid nidFile = fileMap.revision(revision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
153 int localCset = fileNode.getChangesetRevisionIndex(revision);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
154 Nodeid nidCset = clogMap.revision(localCset);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
155 changesetToNodeid_2.put(nidCset, nidFile);
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
156 }
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
157 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
158 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
159 //
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
160 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
161 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
162 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
163
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 438
diff changeset
164 public void next(int fileRevisionIndex, Nodeid revision, int linkedRevisionIndex) throws HgRuntimeException {
436
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
165 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
166 }
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
167 });
9265f7f4b49b Updated sample to map changeset and file revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 433
diff changeset
168 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
169 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
170 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
171 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
172 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
173 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
174 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
175 }
324
283b294d1079 Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
176 }
263
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
177
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
178 /*
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
179 * 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
180 * 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
181 * 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
182 * 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
183 * 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
184 * 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
185 */
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
186 public void revisionMap() throws Exception {
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
187 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
188 final HgChangelog clog = repository.getChangelog();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
189 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
190 final int step = 5000;
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
191 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
192 revisions.add(clog.getRevision(i));
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
193 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
194 final long s1 = System.nanoTime();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
195 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
196 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
197 if (r % step != 0) {
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
198 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
199 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
200 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
201 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
202 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
203 final long s2 = System.nanoTime();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
204 rmap.init();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
205 final long s3 = System.nanoTime();
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
206 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
207 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
208 if (r % step != 0) {
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
209 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
210 }
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 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
213 }
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
214
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
215 public void changelogWalk() throws Exception {
307
2f2ab5c27f41 Collect sort reverse indexes along with array sorting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 304
diff changeset
216 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
217 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
218 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
219 public int xx = 0;
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
220
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
221 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
222 if (xx+revisionNumber < 0) {
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
223 System.out.println(xx);
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
224 System.out.println(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 xx += revisionNumber;
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
227 }
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
228 });
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
229 // 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
230 // 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
231 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
232 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
233 }
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
234
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
235 public 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
236 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
237 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
238 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
239 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
240 // 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
241 // 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
242 // 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
243 // 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
244 // 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
245 //
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
246 // 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
247 // 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
248 // 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
249 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
250 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
251 }
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
252
433
be697c3e951e Revlog.RevisionMap helper class got promoted as TLC, renamed to HgRevisionMap
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
253 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
254 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
255 int x = 0;
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
256 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
257 final Nodeid tagRevision = allTags[i].revision();
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
258 final int tagRevisionIndex = clogrmap.revisionIndex(tagRevision);
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
259 if (tagRevisionIndex != HgRepository.BAD_REVISION) {
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
260 tagLocalRevs[x++] = tagRevisionIndex;
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
261 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
262 if (tagsAssociatedWithRevision == null) {
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
263 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
264 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
265 tagsAssociatedWithRevision.add(allTags[i]);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
266 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
267 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
268 if (x != allTags.length) {
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
269 // 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
270 int[] copy = new int[x];
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
271 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
272 tagLocalRevs = copy;
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
273 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
274 return tagLocalRevs;
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
275 }
263
31f67be94e71 RevlogStream - reduce number of object instances, reuse when possible
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 259
diff changeset
276
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 438
diff changeset
277 public void collectTagsPerFile() throws HgException, CancelledException, HgRuntimeException {
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
278 final long start = System.currentTimeMillis();
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
279 final HgRepository repository = new HgLookup().detect(new File("/home/artem/hg/cpython"));
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
280 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
281 //
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
282 // 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
283 //
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
284 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
285 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
286 // 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
287 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
288 // 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
289 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
290 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
291 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
292 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
293
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
294 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
295 //
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
296 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
297 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
298
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
299 System.out.println("\nApproach 2");
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
300 collectTagsPerFile_Approach_2(repository, tagLocalRevs, tagLocalRev2TagInfo, targetPath);
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
301 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
302
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
303 // 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
304 //
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 438
diff changeset
305 private void collectTagsPerFile_Approach_1(final HgRevisionMap<HgChangelog> clogrmap, final int[] tagLocalRevs, final TagInfo[] allTags, Path targetPath) throws HgException, IllegalArgumentException, HgRuntimeException {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
306 HgRepository repository = clogrmap.getRepo();
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
307 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
308 // 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
309 // 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
310 final Map<Path, Nodeid[]> file2rev2tag = new HashMap<Path, Nodeid[]>();
424
6437d261048a Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 423
diff changeset
311 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
312 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
313
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
314 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
315 // 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
316 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
317 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
318 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
319 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
320 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
321 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
322 // 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
323 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
324 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
325 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
326 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
327 }
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
328 }
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
329 }
256
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
330 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
331 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
332 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
333 return true;
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
334 }
285
6dbbc53fc46d Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 268
diff changeset
335
6dbbc53fc46d Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 268
diff changeset
336 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
337 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
338 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
339 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
340 }
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
341 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
342 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
343 break;
b61ed0f2c4da Yet another slight perf/mem improvement for the tags per file sample
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 255
diff changeset
344 }
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
345 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
346 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
347 }
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
348 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
349 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
350 return true;
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
351 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
352
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
353 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
354 return true;
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
355 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
356
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
357 }, 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
358 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
359 //
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
360 // 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
361 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
362 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
363 // 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
364 for (int fileRevIndex = 0; fileRevIndex < fileNode.getRevisionCount(); fileRevIndex++) {
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
365 Nodeid fileRev = fileNode.getRevision(fileRevIndex);
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
366 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
367 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
368 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
369 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
370 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
371 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
372 }
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
373 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
374 }
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
375 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
376
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 438
diff changeset
377 private void collectTagsPerFile_Approach_2(HgRepository repository, final int[] tagLocalRevs, final IntMap<List<TagInfo>> tagRevIndex2TagInfo, Path targetPath) throws HgException, HgRuntimeException {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
378 //
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
379 // 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
380 // 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
381 HgDataFile fileNode = repository.getFileNode(targetPath);
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
382 final long start2 = System.nanoTime();
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
383 final Map<Integer, Nodeid> fileRevisionAtTagRevision = new HashMap<Integer, Nodeid>();
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
384 final Map<Nodeid, List<String>> fileRev2TagNames = new HashMap<Nodeid, List<String>>();
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
385 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
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 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
388
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 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
390 fileRevisionAtTagRevision.put(csetRevIndex, nid);
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
391 if (tagRevIndex2TagInfo.containsKey(csetRevIndex)) {
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
392 List<String> tags = fileRev2TagNames.get(nid);
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
393 if (tags == null) {
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
394 fileRev2TagNames.put(nid, tags = new ArrayList<String>(3));
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
395 }
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
396 for (TagInfo ti : tagRevIndex2TagInfo.get(csetRevIndex)) {
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
397 tags.add(ti.name());
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
398 }
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
399 }
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
400 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
401 }
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
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
403 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
404 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
405 }
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
406
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
407 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
408 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
409 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
410 }
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
411 };
063b0663495a HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
412 repository.getManifest().walkFileRevisions(targetPath, collectFileRevAtCset,tagLocalRevs);
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
413
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
414 final long start2a = System.nanoTime();
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
415 fileNode.indexWalk(0, TIP, new HgDataFile.RevisionInspector() {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
416
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
417 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
418 List<String> associatedTags = new LinkedList<String>();
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
419
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
420 for (int taggedRevision : tagLocalRevs) {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
421 // current file revision can't appear in tags that point to earlier changelog revisions (they got own file revision)
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
422 if (taggedRevision >= changesetRevisionIndex) {
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
423 // z points to some changeset with tag
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
424 Nodeid wasKnownAs = fileRevisionAtTagRevision.get(taggedRevision);
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
425 if (wasKnownAs.equals(fileRevision)) {
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
426 // has tag associated with changeset at index z
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
427 List<TagInfo> tagsAtRev = tagRevIndex2TagInfo.get(taggedRevision);
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
428 assert tagsAtRev != null;
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
429 for (TagInfo ti : tagsAtRev) {
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
430 associatedTags.add(ti.name());
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
431 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
432 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
433 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
434 }
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
435 //
368
8107b95f4280 Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
436 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
437 }
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
438 });
438
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
439 for (int i = 0, lastRev = fileNode.getLastRevision(); i <= lastRev; i++) {
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
440 Nodeid fileRevision = fileNode.getRevision(i);
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
441 List<String> associatedTags2 = fileRev2TagNames.get(fileRevision);
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
442 int changesetRevIndex = fileNode.getChangesetRevisionIndex(i);
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
443 System.out.printf("%3d%7d%s\n", i, changesetRevIndex, associatedTags2 == null ? Collections.emptyList() : associatedTags2);
0d128e09d70f Yet another alternative to collect tags for a file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 436
diff changeset
444 }
326
d42a45a2c9d6 Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 324
diff changeset
445 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
446 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
447 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
448
424
6437d261048a Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 423
diff changeset
449 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
450 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
451 return true;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
452 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
453 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
454 return true;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
455 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
456 public boolean end(int manifestRevision) {
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
457 return true;
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
458 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
459 }
694ebabb5cb3 Refactor revlog patch mechanism, towards patch merging
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 326
diff changeset
460
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 438
diff changeset
461 public static void main2(String[] args) throws HgCallbackTargetException, HgException, CancelledException, HgRuntimeException {
254
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
462 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
463 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
464 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
465 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
466 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
467 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
468 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
469 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
470 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
471 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
472 // 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
473 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
474 if (fileRevision == null) {
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
475 continue;
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 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
479 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
480 if (revisionTags == null) {
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
481 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
482 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
483 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
484 revisionTags.add(tagName);
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
485 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
486
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
487 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
488 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
489 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
490 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
491 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
492 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
493 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
494 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
495 });
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
496 }
a620f0663a37 Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
497 }