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

comparison src/org/tmatesoft/hg/internal/RevlogStream.java @ 263:31f67be94e71

RevlogStream - reduce number of object instances, reuse when possible

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Thu, 18 Aug 2011 18:06:44 +0200
parents	e5776067b3b8
children	6bb5e7ed051a

comparison

equal deleted inserted replaced

-:3dcd3dd90c77
+:31f67be94e71
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.zip.Inflater;
 import org.tmatesoft.hg.core.HgBadStateException;
 import org.tmatesoft.hg.core.Nodeid;
 import org.tmatesoft.hg.repo.HgRepository;
 		private final boolean needData;
 		private DataAccess daIndex = null, daData = null;
 		private Lifecycle.BasicCallback cb = null;
 		private int lastRevisionRead = BAD_REVISION;
 		private DataAccess lastUserData;
+		// next are to track two major bottlenecks - patch application and actual time spent in inspector
+//		private long applyTime, inspectorTime;
 		public ReaderN1(boolean needData, Inspector insp) {
 			assert insp != null;
 			this.needData = needData;
 			inspector = insp;
 			}
 			if (inspector instanceof Lifecycle) {
 				cb = new Lifecycle.BasicCallback();
 				((Lifecycle) inspector).start(totalWork, cb, cb);
 			}
+//			applyTime = inspectorTime = 0;
 		}
 		public void finish() {
 			if (lastUserData != null) {
 				lastUserData.done();
 			}
 			daIndex.done();
 			if (daData != null) {
 				daData.done();
 			}
-		}
+//			System.out.printf("applyTime:%d ms, inspectorTime: %d ms\n", applyTime, inspectorTime);
+		}
 		public boolean range(int start, int end) throws IOException {
 			byte[] nodeidBuf = new byte[20];
 			int i;
 			boolean extraReadsToBaseRev = false; // to indicate we read revision prior to start. XXX not sure can't do without
 			// it (i.e. replace with i >= start)
 				i = start;
 			}
 			daIndex.seek(getIndexOffsetInt(i));
 			//
+			// reuse some instances
 			final ArrayList<PatchRecord> patches = new ArrayList<PatchRecord>();
+			final Inflater inflater = new Inflater();
+			// can share buffer between instances of InflaterDataAccess as I never read any two of them in parallel
+			final byte[] inflaterBuffer = new byte[1024];
+			//
 			for (; i <= end; i++ ) {
 				if (inline && needData) {
 					// inspector reading data (though FilterDataAccess) may have affected index position
 					daIndex.seek(getIndexOffsetInt(i));
 					if (streamDataAccess.isEmpty()) {
 						userDataAccess = new DataAccess(); // empty
 					} else {
 						final byte firstByte = streamDataAccess.readByte();
 						if (firstByte == 0x78 /* 'x' */) {
-							userDataAccess = new InflaterDataAccess(streamDataAccess, streamOffset, compressedLen, patchToPrevious ? -1 : actualLen);
+							inflater.reset();
+							userDataAccess = new InflaterDataAccess(streamDataAccess, streamOffset, compressedLen, patchToPrevious ? -1 : actualLen, inflater, inflaterBuffer);
 						} else if (firstByte == 0x75 /* 'u' */) {
 							userDataAccess = new FilterDataAccess(streamDataAccess, streamOffset+1, compressedLen-1);
 						} else {
 							// XXX Python impl in fact throws exception when there's not 'x', 'u' or '0'
 							// but I don't see reason not to return data as is
 						}
 					}
 					// XXX
 					if (patchToPrevious) {
 						// this is a patch
+						patches.clear(); // won't hurt to ensure there are no leftovers, even if we already cleaned
 						while (!userDataAccess.isEmpty()) {
 							PatchRecord pr = PatchRecord.read(userDataAccess);
 //							System.out.printf("PatchRecord:%d %d %d\n", pr.start, pr.end, pr.len);
 							patches.add(pr);
 						}
 						userDataAccess.done();
 						//
+						// it shall be reset at the end of prev iteration, when it got assigned from userDataAccess
+						// however, actual userDataAccess and lastUserData may share Inflater object, which needs to be reset
+						// Alternatively, userDataAccess.done() above may be responsible to reset Inflater (if it's InflaterDataAccess)
+						lastUserData.reset();
+//						final long startMeasuring = System.currentTimeMillis();
 						byte[] userData = apply(lastUserData, actualLen, patches);
-						patches.clear();
+//						applyTime += (System.currentTimeMillis() - startMeasuring);
+						patches.clear(); // do not keep any reference, allow PatchRecord to be gc'd
 						userDataAccess = new ByteArrayDataAccess(userData);
 					}
 				} else {
 					if (inline) {
 						daIndex.skip(compressedLen);
 					}
 				}
 				if (!extraReadsToBaseRev || i >= start) {
+//					final long startMeasuring = System.currentTimeMillis();
 					inspector.next(i, actualLen, baseRevision, linkRevision, parent1Revision, parent2Revision, nodeidBuf, userDataAccess);
+//					inspectorTime += (System.currentTimeMillis() - startMeasuring);
 				}
 				if (cb != null) {
 					if (cb.isStopped()) {
 						return false;
 					}
 				}
 				if (userDataAccess != null) {
-					userDataAccess.reset();
+					userDataAccess.reset(); // not sure this is necessary here, as lastUserData would get reset anyway before next use.
-					if (lastUserData != null) {
+				}
-						lastUserData.done();
+				if (lastUserData != null) {
-					}
+					lastUserData.done();
-					lastUserData = userDataAccess;
+				}
-				}
+				lastUserData = userDataAccess;
 			}
 			lastRevisionRead = end;
 			return true;
 		}
 	}
 	// FIXME need to implement patch merge (fold, combine, gather and discard from aforementioned mpatch.[c|py]), also see Revlog and Mercurial PDF
 	public/*for HgBundle; until moved to better place*/static byte[] apply(DataAccess baseRevisionContent, int outcomeLen, List<PatchRecord> patch) throws IOException {
 		int last = 0, destIndex = 0;
 		if (outcomeLen == -1) {
 			outcomeLen = baseRevisionContent.length();
-			for (PatchRecord pr : patch) {
+			for (int i = 0, x = patch.size(); i < x; i++) {
+				PatchRecord pr = patch.get(i);
 				outcomeLen += pr.start - last + pr.len;
 				last = pr.end;
 			}
 			outcomeLen -= last;
 			last = 0;
 		}
 		byte[] rv = new byte[outcomeLen];
-		for (PatchRecord pr : patch) {
+		for (int i = 0, x = patch.size(); i < x; i++) {
+			PatchRecord pr = patch.get(i);
 			baseRevisionContent.seek(last);
 			baseRevisionContent.readBytes(rv, destIndex, pr.start-last);
 			destIndex += pr.start - last;
 			System.arraycopy(pr.data, 0, rv, destIndex, pr.data.length);
 			destIndex += pr.data.length;

Mercurial > jhg

comparison src/org/tmatesoft/hg/internal/RevlogStream.java @ 263:31f67be94e71