jhg: src/org/tmatesoft/hg/internal/RevlogStream.java comparison

comparison src/org/tmatesoft/hg/internal/RevlogStream.java @ 593:9619301a7bb9

Share last revision read between #iterate() invocations, to save revision rebuild efforts when few subsequent revisions are read

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Thu, 02 May 2013 16:51:02 +0200
parents	b47ef0d2777b
children	cc7b0c4dc993

comparison

equal deleted inserted replaced

-:b12cc3d64a35
+:9619301a7bb9
 import static org.tmatesoft.hg.repo.HgRepository.TIP;
 import static org.tmatesoft.hg.internal.Internals.REVLOGV1_RECORD_SIZE;
 import java.io.File;
 import java.io.IOException;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
 import java.util.zip.Inflater;
 import org.tmatesoft.hg.core.Nodeid;
 import org.tmatesoft.hg.repo.HgInternals;
 import org.tmatesoft.hg.repo.HgInvalidControlFileException;
 	private int[] baseRevisions;
 	private boolean inline = false;
 	private final File indexFile;
 	private File dataFile;
 	private final DataAccessProvider dataAccess;
+	// keeps last complete revision we've read. Note, this cached revision doesn't help
+	// for subsequent #iterate() calls with the same revision (Inspector needs more data than
+	// we currently cache here, perhaps, we shall cache everything it wants to cover same
+	// revision case as well). Now this helps when second #iterate() call is for a revision greater
+	// than one from the first call, and both revisions got same base rev. It's often the case when
+	// parents/children are analyzed.
+	private SoftReference<CachedRevision> lastRevisionRead;
+	private final ReferenceQueue<CachedRevision> lastRevisionQueue = new ReferenceQueue<CachedRevision>();
 	// if we need anything else from HgRepo, might replace DAP parameter with HgRepo and query it for DAP.
 	public RevlogStream(DataAccessProvider dap, File indexFile) {
 		this.dataAccess = dap;
 		this.indexFile = indexFile;
 		} finally {
 			daIndex.done();
 		}
 	}
 	// should be possible to use TIP, ALL, or -1, -2, -n notation of Hg
 	// ? boolean needsNodeid
 	public void iterate(int start, int end, boolean needData, Inspector inspector) throws HgInvalidRevisionException, HgInvalidControlFileException {
 		initOutline();
 		final int indexSize = revisionCount();
 		HgInternals.checkRevlogRange(start, end, indexSize-1);
 		// XXX may cache [start .. end] from index with a single read (pre-read)
 		ReaderN1 r = new ReaderN1(needData, inspector, dataAccess.shallMergePatches());
 		try {
-			r.start(end - start + 1);
+			r.start(end - start + 1, getLastRevisionRead());
 			r.range(start, end);
 		} catch (IOException ex) {
 			throw new HgInvalidControlFileException(String.format("Failed reading [%d..%d]", start, end), ex, indexFile);
 		} catch (HgInvalidControlFileException ex) {
 			throw ex;
 		} finally {
-			r.finish();
+			CachedRevision cr = r.finish();
+			setLastRevisionRead(cr);
 		}
 	}
 	/**
 	 * Effective alternative to {@link #iterate(int, int, boolean, Inspector) batch read}, when only few selected
 			throw new HgInvalidRevisionException(String.format("Can't iterate [%d, %d] in range [0..%d]", sortedRevisions[0], sortedRevisions[sortedRevisions.length - 1], indexSize), null, sortedRevisions[sortedRevisions.length - 1]);
 		}
 		ReaderN1 r = new ReaderN1(needData, inspector, dataAccess.shallMergePatches());
 		try {
-			r.start(sortedRevisions.length);
+			r.start(sortedRevisions.length, lastRevisionRead == null ? null : lastRevisionRead.get());
 			for (int i = 0; i < sortedRevisions.length; ) {
 				int x = i;
 				i++;
 				while (i < sortedRevisions.length) {
 					if (sortedRevisions[i] == sortedRevisions[i-1] + 1) {
 			throw new HgInvalidControlFileException(String.format("Failed reading %d revisions in [%d; %d]",c, sortedRevisions[0], sortedRevisions[c-1]), ex, indexFile);
 		} catch (HgInvalidControlFileException ex) {
 			// TODO post-1.0 fill HgRuntimeException with appropriate file (either index or data, depending on error source)
 			throw ex;
 		} finally {
-			r.finish();
+			CachedRevision cr = r.finish();
+			setLastRevisionRead(cr);
 		}
 	}
 	void revisionAdded(int revisionIndex, Nodeid revision, int baseRevisionIndex, long revisionOffset) throws HgInvalidControlFileException {
 		if (!outlineCached()) {
 		} finally {
 			da.done();
 		}
 	}
+	private CachedRevision getLastRevisionRead() {
+		return lastRevisionRead == null ? null : lastRevisionRead.get();
+	}
+	private void setLastRevisionRead(CachedRevision cr) {
+		// done() for lastRevisionRead.userData has been called by ReaderN1 once
+		// it noticed unsuitable DataAccess.
+		// Now, done() for any CachedRevision cleared by GC:
+		for (Reference<? extends CachedRevision> r; (r = lastRevisionQueue.poll()) != null;) {
+			CachedRevision toClean = r.get();
+			if (toClean != null && toClean.userData != null) {
+				toClean.userData.done();
+			}
+		}
+		if (cr != null) {
+			lastRevisionRead = new SoftReference<CachedRevision>(cr, lastRevisionQueue);
+		} else {
+			lastRevisionRead = null;
+		}
+	}
+	final static class CachedRevision {
+		final int revision;
+		final DataAccess userData;
+		public CachedRevision(int lastRevisionRead, DataAccess lastUserData) {
+			revision = lastRevisionRead;
+			userData = lastUserData;
+		}
+	}
 	/**
 	 * operation with single file open/close and multiple diverse reads.
 	 * XXX initOutline might need similar extraction to keep N1 format knowledge
 	 */
 	final class ReaderN1 {
 		private int actualLen;
 		private int baseRevision;
 		private int linkRevision;
 		private int parent1Revision;
 		private int parent2Revision;
-		// next are to track two major bottlenecks - patch application and actual time spent in inspector
-//		private long applyTime, inspectorTime; // TIMING
 		public ReaderN1(boolean dataRequested, Inspector insp, boolean usePatchMerge) {
 			assert insp != null;
 			needData = dataRequested;
 			inspector = insp;
 			mergePatches = usePatchMerge;
 		}
-		public void start(int totalWork) {
+		public void start(int totalWork, CachedRevision cachedRevision) {
 			daIndex = getIndexStream();
 			if (needData && !inline) {
 				daData = getDataStream();
 			}
 			lifecycleListener = Adaptable.Factory.getAdapter(inspector, Lifecycle.class, null);
 			if (lifecycleListener != null) {
 				cb = new Lifecycle.BasicCallback();
 				lifecycleListener.start(totalWork, cb, cb);
 			}
-//			applyTime = inspectorTime = 0; // TIMING
+			if (needData && cachedRevision != null) {
+				lastUserData = cachedRevision.userData;
+				lastRevisionRead = cachedRevision.revision;
+				assert lastUserData != null;
+			}
 		}
 		// invoked only once per instance
-		public void finish() {
+		public CachedRevision finish() {
+			CachedRevision rv = null;
 			if (lastUserData != null) {
-				lastUserData.done();
+				rv = new CachedRevision(lastRevisionRead, lastUserData);
 				lastUserData = null;
 			}
 			if (lifecycleListener != null) {
 				lifecycleListener.finish(cb);
 				lifecycleListener = null;
 			daIndex.done();
 			if (daData != null) {
 				daData.done();
 				daData = null;
 			}
-//			System.out.printf("applyTime:%d ms, inspectorTime: %d ms\n", applyTime, inspectorTime); // TIMING
+			return rv;
 		}
 		private void readHeaderRecord(int i) throws IOException {
 			if (inline && needData) {
 				// inspector reading data (though FilterDataAccess) may have affected index position

Mercurial > jhg

comparison src/org/tmatesoft/hg/internal/RevlogStream.java @ 593:9619301a7bb9