hg4j: test/org/tmatesoft/hg/test/MapTagsToFileRevisions.java annotate

annotate test/org/tmatesoft/hg/test/MapTagsToFileRevisions.java @ 438:0d128e09d70f

Yet another alternative to collect tags for a file

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Thu, 19 Apr 2012 19:16:45 +0200
parents	9265f7f4b49b
children	6526d8adbc0f

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

Mercurial > hg4j

annotate test/org/tmatesoft/hg/test/MapTagsToFileRevisions.java @ 438:0d128e09d70f