Implement Bram Cohen's Patience Diff

Change-Id: Ic7a76df2861ea6c569ab9756a62018987912bd13
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>

org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/PatienceDiffTest.java

@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2010, Google Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.diff;
+
+import java.io.UnsupportedEncodingException;
+
+import junit.framework.TestCase;
+
+public class PatienceDiffTest extends TestCase {
+	public void testEmptyInputs() {
+		EditList r = diff(t(""), t(""));
+		assertTrue("is empty", r.isEmpty());
+	}
+
+	public void testCreateFile() {
+		EditList r = diff(t(""), t("AB"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(0, 0, 0, 2), r.get(0));
+	}
+
+	public void testDeleteFile() {
+		EditList r = diff(t("AB"), t(""));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(0, 2, 0, 0), r.get(0));
+	}
+
+	public void testDegenerate_InsertMiddle() {
+		EditList r = diff(t("ac"), t("aBc"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(1, 1, 1, 2), r.get(0));
+	}
+
+	public void testDegenerate_DeleteMiddle() {
+		EditList r = diff(t("aBc"), t("ac"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(1, 2, 1, 1), r.get(0));
+	}
+
+	public void testDegenerate_ReplaceMiddle() {
+		EditList r = diff(t("bCd"), t("bEd"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(1, 2, 1, 2), r.get(0));
+	}
+
+	public void testDegenerate_InsertsIntoMidPosition() {
+		EditList r = diff(t("aaaa"), t("aaXaa"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(2, 2, 2, 3), r.get(0));
+	}
+
+	public void testDegenerate_InsertStart() {
+		EditList r = diff(t("bc"), t("Abc"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(0, 0, 0, 1), r.get(0));
+	}
+
+	public void testDegenerate_DeleteStart() {
+		EditList r = diff(t("Abc"), t("bc"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(0, 1, 0, 0), r.get(0));
+	}
+
+	public void testDegenerate_InsertEnd() {
+		EditList r = diff(t("bc"), t("bcD"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(2, 2, 2, 3), r.get(0));
+	}
+
+	public void testDegenerate_DeleteEnd() {
+		EditList r = diff(t("bcD"), t("bc"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(2, 3, 2, 2), r.get(0));
+	}
+
+	public void testEdit_ReplaceCommonDelete() {
+		EditList r = diff(t("RbC"), t("Sb"));
+		assertEquals(2, r.size());
+		assertEquals(new Edit(0, 1, 0, 1), r.get(0));
+		assertEquals(new Edit(2, 3, 2, 2), r.get(1));
+	}
+
+	public void testEdit_CommonReplaceCommonDeleteCommon() {
+		EditList r = diff(t("aRbCd"), t("aSbd"));
+		assertEquals(2, r.size());
+		assertEquals(new Edit(1, 2, 1, 2), r.get(0));
+		assertEquals(new Edit(3, 4, 3, 3), r.get(1));
+	}
+
+	public void testEdit_MoveBlock() {
+		EditList r = diff(t("aYYbcdz"), t("abcdYYz"));
+		assertEquals(2, r.size());
+		assertEquals(new Edit(1, 3, 1, 1), r.get(0));
+		assertEquals(new Edit(6, 6, 4, 6), r.get(1));
+	}
+
+	public void testEdit_InvertBlocks() {
+		EditList r = diff(t("aYYbcdXXz"), t("aXXbcdYYz"));
+		assertEquals(2, r.size());
+		assertEquals(new Edit(1, 3, 1, 3), r.get(0));
+		assertEquals(new Edit(6, 8, 6, 8), r.get(1));
+	}
+
+	public void testEdit_NoUniqueMiddleSideA() {
+		EditList r = diff(t("aRRSSz"), t("aSSRRz"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(1, 5, 1, 5), r.get(0));
+	}
+
+	public void testEdit_NoUniqueMiddleSideB() {
+		EditList r = diff(t("aRSz"), t("aSSRRz"));
+		assertEquals(1, r.size());
+		assertEquals(new Edit(1, 3, 1, 5), r.get(0));
+	}
+
+	public void testEdit_UniqueCommonLargerThanMatchPoint() {
+		// We are testing 3 unique common matches, but two of
+		// them are consumed as part of the 1st's LCS region.
+		EditList r = diff(t("AbdeZ"), t("PbdeQR"));
+		assertEquals(2, r.size());
+		assertEquals(new Edit(0, 1, 0, 1), r.get(0));
+		assertEquals(new Edit(4, 5, 4, 6), r.get(1));
+	}
+
+	public void testEdit_CommonGrowsPrefixAndSuffix() {
+		// Here there is only one common unique point, but we can grow it
+		// in both directions to find the LCS in the middle.
+		EditList r = diff(t("AaabccZ"), t("PaabccR"));
+		assertEquals(2, r.size());
+		assertEquals(new Edit(0, 1, 0, 1), r.get(0));
+		assertEquals(new Edit(6, 7, 6, 7), r.get(1));
+	}
+
+	public void testEdit_DuplicateAButCommonUniqueInB() {
+		EditList r = diff(t("AbbcR"), t("CbcS"));
+		assertEquals(2, r.size());
+		assertEquals(new Edit(0, 2, 0, 1), r.get(0));
+		assertEquals(new Edit(4, 5, 3, 4), r.get(1));
+	}
+
+	public void testPerformanceTestDeltaLength() {
+		String a = DiffTestDataGenerator.generateSequence(40000, 971, 3);
+		String b = DiffTestDataGenerator.generateSequence(40000, 1621, 5);
+		CharArray ac = new CharArray(a);
+		CharArray bc = new CharArray(b);
+		EditList r = new PatienceDiff().diff(new CharCmp(), ac, bc);
+		assertEquals(25, r.size());
+	}
+
+	private static EditList diff(RawText a, RawText b) {
+		return new PatienceDiff().diff(RawTextComparator.DEFAULT, a, b);
+	}
+
+	private static RawText t(String text) {
+		StringBuilder r = new StringBuilder();
+		for (int i = 0; i < text.length(); i++) {
+			r.append(text.charAt(i));
+			r.append('\n');
+		}
+		try {
+			return new RawText(r.toString().getBytes("UTF-8"));
+		} catch (UnsupportedEncodingException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private static class CharArray extends Sequence {
+		final char[] array;
+
+		public CharArray(String s) {
+			array = s.toCharArray();
+		}
+
+		@Override
+		public int size() {
+			return array.length;
+		}
+	}
+
+	private static class CharCmp extends SequenceComparator<CharArray> {
+		@Override
+		public boolean equals(CharArray a, int ai, CharArray b, int bi) {
+			return a.array[ai] == b.array[bi];
+		}
+
+		@Override
+		public int hash(CharArray seq, int ptr) {
+			return seq.array[ptr];
+		}
+	}
+}

org.eclipse.jgit/src/org/eclipse/jgit/diff/PatienceDiff.java

@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2010, Google Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.diff;
+
+/**
+ * An implementation of the patience difference algorithm.
+ *
+ * This implementation was derived by using the 4 rules that are outlined in
+ * Bram Cohen's <a href="http://bramcohen.livejournal.com/73318.html">blog</a>.
+ *
+ * Because this algorithm requires finding a unique common point to center the
+ * longest common subsequence around, input sequences which have no unique
+ * elements create a degenerate Edit that simply replaces all of one sequence
+ * with all of the other sequence. For many source code files and other human
+ * maintained text, this isn't likely to occur. When it does occur, it can be
+ * easier to read the resulting large-scale replace than to navigate through a
+ * lot of slices of common-but-not-unique lines, like curly braces on lone
+ * lines, or XML close tags. Consequently this algorithm is willing to create a
+ * degenerate Edit in the worst case, in exchange for what may still be
+ * perceived to be an easier to read patch script.
+ *
+ * In a nutshell, the implementation defines an Edit that replaces all of
+ * sequence {@code a} with all of {@code b}. This Edit is reduced and/or split
+ * to remove common elements, until only Edits spanning non-common elements
+ * remain. Those {@link Edit}s are the differences.
+ *
+ * A slightly more detailed description of the implementation is:
+ *
+ * <ol>
+ * <li>Define an Edit that spans the entire two sequences. This edit replaces
+ * all of {@code a} with all of {@code b}.</li>
+ *
+ * <li>Shrink the Edit by shifting the starting points later in the sequence to
+ * skip over any elements that are common between {@code a} and {@code b}.
+ * Likewise shift the ending points earlier in the sequence to skip any trailing
+ * elements that are common. The first and last element of the edit are now not
+ * common, however there may be common content within the interior of the Edit
+ * that hasn't been discovered yet.</li>
+ *
+ * <li>Find unique elements within the Edit region that are in both sequences.
+ * This is currently accomplished by hashing the elements and merging them
+ * through a custom hash table in {@link PatienceDiffIndex}.</li>
+ *
+ * <li>Order the common unique elements by their position within {@code b}.</li>
+ *
+ * <li>For each unique element, stretch an Edit around it in both directions,
+ * consuming neighboring elements that are common to both sequences. Select the
+ * longest such Edit out of the unique element list. During this stretching,
+ * some subsequent unique elements may be consumed into an earlier's common
+ * Edit. This means not all unique elements are evaluated.</li>
+ *
+ * <li>Split the Edit region at the longest common edit. Because step 2 shrank
+ * the initial region, there must be at least one element before, and at least
+ * one element after the split.</li>
+ *
+ * <li>Recurse on the before and after split points, starting from step 3. Step
+ * 2 doesn't need to be done again because any common part was already removed
+ * by the prior step 2 or 5.</li>
+ * </ol>
+ */
+public class PatienceDiff implements DiffAlgorithm {
+	/** Algorithm we use when there are no common unique lines in a region. */
+	private DiffAlgorithm fallback;
+
+	/**
+	 * Set the algorithm used when there are no common unique lines remaining.
+	 *
+	 * @param alg
+	 *            the secondary algorithm. If null the region will be denoted as
+	 *            a single REPLACE block.
+	 */
+	public void setFallbackAlgorithm(DiffAlgorithm alg) {
+		fallback = alg;
+	}
+
+	public <S extends Sequence, C extends SequenceComparator<? super S>> EditList diff(
+			C cmp, S a, S b) {
+		Edit region = new Edit(0, a.size(), 0, b.size());
+		region = cmp.reduceCommonStartEnd(a, b, region);
+
+		switch (region.getType()) {
+		case INSERT:
+		case DELETE: {
+			EditList r = new EditList();
+			r.add(region);
+			return r;
+		}
+
+		case REPLACE: {
+			SubsequenceComparator<S> cs = new SubsequenceComparator<S>(cmp);
+			Subsequence<S> as = Subsequence.a(a, region);
+			Subsequence<S> bs = Subsequence.b(b, region);
+			return Subsequence.toBase(diffImpl(cs, as, bs), as, bs);
+		}
+
+		case EMPTY:
+			return new EditList();
+
+		default:
+			throw new IllegalStateException();
+		}
+	}
+
+	private <S extends Sequence, C extends SequenceComparator<? super S>> EditList diffImpl(
+			C cmp, S a, S b) {
+		State<S> s = new State<S>(new HashedSequencePair<S>(cmp, a, b));
+		s.diff(new Edit(0, s.a.size(), 0, s.b.size()), null, 0, 0);
+		return s.edits;
+	}
+
+	private class State<S extends Sequence> {
+		private final HashedSequenceComparator<S> cmp;
+
+		private final HashedSequence<S> a;
+
+		private final HashedSequence<S> b;
+
+		/** Result edits we have determined that must be made to convert a to b. */
+		final EditList edits;
+
+		State(HashedSequencePair<S> p) {
+			this.cmp = p.getComparator();
+			this.a = p.getA();
+			this.b = p.getB();
+			this.edits = new EditList();
+		}
+
+		private void diff(Edit r, long[] pCommon, int pIdx, int pEnd) {
+			switch (r.getType()) {
+			case INSERT:
+			case DELETE:
+				edits.add(r);
+				return;
+
+			case REPLACE:
+				break;
+
+			case EMPTY:
+			default:
+				throw new IllegalStateException();
+			}
+
+			PatienceDiffIndex<S> p;
+
+			p = new PatienceDiffIndex<S>(cmp, a, b, r, pCommon, pIdx, pEnd);
+			Edit lcs = p.findLongestCommonSequence();
+
+			if (lcs != null) {
+				pCommon = p.nCommon;
+				pIdx = p.cIdx;
+				pEnd = p.nCnt;
+				p = null;
+
+				diff(r.before(lcs), pCommon, 0, pIdx);
+				diff(r.after(lcs), pCommon, pIdx + 1, pEnd);
+
+			} else if (fallback != null) {
+				p = null;
+				pCommon = null;
+
+				SubsequenceComparator<HashedSequence<S>> cs;
+				cs = new SubsequenceComparator<HashedSequence<S>>(cmp);
+
+				Subsequence<HashedSequence<S>> as = Subsequence.a(a, r);
+				Subsequence<HashedSequence<S>> bs = Subsequence.b(b, r);
+				EditList res = fallback.diff(cs, as, bs);
+				edits.addAll(Subsequence.toBase(res, as, bs));
+
+			} else {
+				edits.add(r);
+			}
+		}
+	}
+}

org.eclipse.jgit/src/org/eclipse/jgit/diff/PatienceDiffIndex.java

@@ -0,0 +1,442 @@
+/*
+ * Copyright (C) 2010, Google Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.diff;
+
+/**
+ * Supports {@link PatienceDiff} by finding unique but common elements.
+ *
+ * This index object is constructed once for each region being considered by the
+ * main {@link PatienceDiff} algorithm, which really means its once for each
+ * recursive step. Each index instance processes a fixed sized region from the
+ * sequences, and during recursion the region is split into two smaller segments
+ * and processed again.
+ *
+ * Index instances from a higher level invocation message some state into a
+ * lower level invocation by passing the {@link #nCommon} array from the higher
+ * invocation into the two sub-steps as {@link #pCommon}. This permits some
+ * matching work that was already done in the higher invocation to be reused in
+ * the sub-step and can save a lot of time when element equality is expensive.
+ *
+ * @param <S>
+ *            type of sequence the scanner will scan.
+ */
+final class PatienceDiffIndex<S extends Sequence> {
+	private static final int A_DUPLICATE = 1;
+
+	private static final int B_DUPLICATE = 2;
+
+	private static final int DUPLICATE_MASK = B_DUPLICATE | A_DUPLICATE;
+
+	private static final int A_SHIFT = 2;
+
+	private static final int B_SHIFT = 31 + 2;
+
+	private static final int PTR_MASK = 0x7fffffff;
+
+	private final HashedSequenceComparator<S> cmp;
+
+	private final HashedSequence<S> a;
+
+	private final HashedSequence<S> b;
+
+	private final Edit region;
+
+	/** Pairs of beginB, endB indices previously found to be common and unique. */
+	private final long[] pCommon;
+
+	/** First valid index in {@link #pCommon}. */
+	private final int pBegin;
+
+	/** 1 past the last valid entry in {@link #pCommon}. */
+	private final int pEnd;
+
+	/** Keyed by {@code cmp.hash() & tableMask} to yield an entry offset. */
+	private final int[] table;
+
+	private final int tableMask;
+
+	// To save memory the buckets for hash chains are stored in correlated
+	// arrays. This permits us to get 3 values per entry, without paying
+	// the penalty for an object header on each entry.
+
+	/** Cached hash value for an element as returned by {@link #cmp}. */
+	private final int[] hash;
+
+	/**
+	 * A matched (or partially examined) element from the two sequences.
+	 *
+	 * This is actually a 4-tuple: (bPtr, aPtrP1, bDuplicate, aDuplicate).
+	 *
+	 * bPtr and aPtr are each 31 bits. bPtr is exactly the position in the b
+	 * sequence, while aPtrP1 is {@code aPtr + 1}. This permits us to determine
+	 * if there is corresponding element in a by testing for aPtrP1 != 0. If it
+	 * equals 0, there is no element in a. If it equals 1, element 0 of a
+	 * matches with element bPtr of b.
+	 *
+	 * bDuplicate is 1 if this element occurs more than once in b; likewise
+	 * aDuplicate is 1 if this element occurs more than once in a. These flags
+	 * permit each element to only be added to the index once. As the duplicates
+	 * are the low 2 bits a unique record meets (@code (rec & 2) == 0}.
+	 */
+	private final long[] ptrs;
+
+	/** Array index of the next entry in the table; 0 if at end of chain. */
+	private final int[] next;
+
+	/** Total number of entries that exist in {@link #ptrs}. */
+	private int entryCnt;
+
+	/** Number of entries in {@link #ptrs} that are actually unique. */
+	private int uniqueCommonCnt;
+
+	/**
+	 * Pairs of beginB, endB indices found to be common and unique.
+	 *
+	 * In order to find the longest common (but unique) sequence within a
+	 * region, we also found all of the other common but unique sequences in
+	 * that same region. This array stores all of those results, allowing them
+	 * to be passed into the subsequent recursive passes so we can later reuse
+	 * these matches and avoid recomputing the same points again.
+	 */
+	long[] nCommon;
+
+	/** Number of items in {@link #nCommon}. */
+	int nCnt;
+
+	/** Index of the longest common subsequence in {@link #nCommon}. */
+	int cIdx;
+
+	PatienceDiffIndex(HashedSequenceComparator<S> cmp, //
+			HashedSequence<S> a, //
+			HashedSequence<S> b, //
+			Edit region, //
+			long[] pCommon, int pIdx, int pCnt) {
+		this.cmp = cmp;
+		this.a = a;
+		this.b = b;
+		this.region = region;
+		this.pCommon = pCommon;
+		this.pBegin = pIdx;
+		this.pEnd = pCnt;
+
+		final int blockCnt = region.getLengthB();
+		if (blockCnt < 1) {
+			table = new int[] {};
+			tableMask = 0;
+
+			hash = new int[] {};
+			ptrs = new long[] {};
+			next = new int[] {};
+
+		} else {
+			table = new int[tableSize(blockCnt)];
+			tableMask = table.length - 1;
+
+			// As we insert elements we preincrement so that 0 is never a
+			// valid entry. Therefore we have to allocate one extra space.
+			//
+			hash = new int[1 + blockCnt];
+			ptrs = new long[hash.length];
+			next = new int[hash.length];
+		}
+	}
+
+	/**
+	 * Index elements in sequence B for later matching with sequence A.
+	 *
+	 * This is the first stage of preparing an index to find the longest common
+	 * sequence. Elements of sequence B in the range [ptr, end) are scanned in
+	 * order and added to the internal hashtable.
+	 *
+	 * If prior matches were given in the constructor, these may be used to
+	 * fast-forward through sections of B to avoid unnecessary recomputation.
+	 */
+	private void scanB() {
+		// We insert in ascending order so that a later scan of the table
+		// from 0 through entryCnt will iterate through B in order. This
+		// is the desired result ordering from match().
+		//
+		int ptr = region.beginB;
+		final int end = region.endB;
+		int pIdx = pBegin;
+		SCAN: while (ptr < end) {
+			final int key = cmp.hash(b, ptr);
+			final int tIdx = key & tableMask;
+
+			if (pIdx < pEnd) {
+				final long priorRec = pCommon[pIdx];
+				if (ptr == bOf(priorRec)) {
+					// We know this region is unique from a prior pass.
+					// Insert the start point, and skip right to the end.
+					//
+					insertB(key, tIdx, ptr);
+					pIdx++;
+					ptr = aOfRaw(priorRec);
+					continue SCAN;
+				}
+			}
+
+			// We aren't sure what the status of this element is. Add
+			// it to our hashtable, and flag it as duplicate if there
+			// was already a different entry present.
+			//
+			for (int eIdx = table[tIdx]; eIdx != 0; eIdx = next[eIdx]) {
+				if (hash[eIdx] != key)
+					continue;
+
+				final long rec = ptrs[eIdx];
+				if (cmp.equals(b, ptr, b, bOf(rec))) {
+					ptrs[eIdx] = rec | B_DUPLICATE;
+					ptr++;
+					continue SCAN;
+				}
+			}
+
+			insertB(key, tIdx, ptr);
+			ptr++;
+		}
+	}
+
+	private void insertB(final int key, final int tIdx, int ptr) {
+		final int eIdx = ++entryCnt;
+		hash[eIdx] = key;
+		ptrs[eIdx] = ((long) ptr) << B_SHIFT;
+		next[eIdx] = table[tIdx];
+		table[tIdx] = eIdx;
+	}
+
+	/**
+	 * Index elements in sequence A for later matching.
+	 *
+	 * This is the second stage of preparing an index to find the longest common
+	 * sequence. The state requires {@link #scanB()} to have been invoked first.
+	 *
+	 * Each element of A in the range [ptr, end) are searched for in the
+	 * internal hashtable, to see if B has already registered a location.
+	 *
+	 * If prior matches were given in the constructor, these may be used to
+	 * fast-forward through sections of A to avoid unnecessary recomputation.
+	 */
+	private void scanA() {
+		int ptr = region.beginA;
+		final int end = region.endA;
+		int pLast = pBegin - 1;
+		SCAN: while (ptr < end) {
+			final int key = cmp.hash(a, ptr);
+			final int tIdx = key & tableMask;
+
+			for (int eIdx = table[tIdx]; eIdx != 0; eIdx = next[eIdx]) {
+				final long rec = ptrs[eIdx];
+
+				if (isDuplicate(rec) || hash[eIdx] != key)
+					continue;
+
+				final int aPtr = aOfRaw(rec);
+				if (aPtr != 0 && cmp.equals(a, ptr, a, aPtr - 1)) {
+					ptrs[eIdx] = rec | A_DUPLICATE;
+					uniqueCommonCnt--;
+					ptr++;
+					continue SCAN;
+				}
+
+				final int bs = bOf(rec);
+				if (!cmp.equals(a, ptr, b, bs)) {
+					ptr++;
+					continue SCAN;
+				}
+
+				// This element is both common and unique. Link the
+				// two sequences together at this point.
+				//
+				ptrs[eIdx] = rec | (((long) (ptr + 1)) << A_SHIFT);
+				uniqueCommonCnt++;
+
+				if (pBegin < pEnd) {
+					// If we have prior match point data, we might be able
+					// to locate the length of the match and skip past all
+					// of those elements. We try to take advantage of the
+					// fact that pCommon is sorted by B, and its likely that
+					// matches in A appear in the same order as they do in B.
+					//
+					for (int pIdx = pLast + 1;; pIdx++) {
+						if (pIdx == pEnd)
+							pIdx = pBegin;
+						else if (pIdx == pLast)
+							break;
+
+						final long priorRec = pCommon[pIdx];
+						final int priorB = bOf(priorRec);
+						if (bs < priorB)
+							break;
+						if (bs == priorB) {
+							ptr += aOfRaw(priorRec) - priorB;
+							pLast = pIdx;
+							continue SCAN;
+						}
+					}
+				}
+
+				ptr++;
+				continue SCAN;
+			}
+
+			ptr++;
+		}
+	}
+
+	/**
+	 * Scan all potential matches and find the longest common sequence.
+	 *
+	 * If this method returns non-null, the caller should copy out the
+	 * {@link #nCommon} array and pass that through to the recursive sub-steps
+	 * so that existing common matches can be reused rather than recomputed.
+	 *
+	 * @return an edit covering the longest common sequence. Null if there are
+	 *         no common unique sequences present.
+	 */
+	Edit findLongestCommonSequence() {
+		scanB();
+		scanA();
+
+		if (uniqueCommonCnt == 0)
+			return null;
+
+		nCommon = new long[uniqueCommonCnt];
+		int pIdx = pBegin;
+		Edit lcs = new Edit(0, 0);
+
+		MATCH: for (int eIdx = 1; eIdx <= entryCnt; eIdx++) {
+			final long rec = ptrs[eIdx];
+			if (isDuplicate(rec) || aOfRaw(rec) == 0)
+				continue;
+
+			int bs = bOf(rec);
+			if (bs < lcs.endB)
+				continue;
+
+			int as = aOf(rec);
+			if (pIdx < pEnd) {
+				final long priorRec = pCommon[pIdx];
+				if (bs == bOf(priorRec)) {
+					// We had a prior match and we know its unique.
+					// Reuse its region rather than computing again.
+					//
+					int be = aOfRaw(priorRec);
+
+					if (lcs.getLengthB() < be - bs) {
+						as -= bOf(rec) - bs;
+						lcs.beginA = as;
+						lcs.beginB = bs;
+						lcs.endA = as + (be - bs);
+						lcs.endB = be;
+						cIdx = nCnt;
+					}
+
+					nCommon[nCnt] = priorRec;
+					if (++nCnt == uniqueCommonCnt)
+						break MATCH;
+
+					pIdx++;
+					continue MATCH;
+				}
+			}
+
+			// We didn't have prior match data, or this is the first time
+			// seeing this particular pair. Extend the region as large as
+			// possible and remember it for future use.
+			//
+			int ae = as + 1;
+			int be = bs + 1;
+
+			while (region.beginA < as && region.beginB < bs
+					&& cmp.equals(a, as - 1, b, bs - 1)) {
+				as--;
+				bs--;
+			}
+			while (ae < region.endA && be < region.endB
+					&& cmp.equals(a, ae, b, be)) {
+				ae++;
+				be++;
+			}
+
+			if (lcs.getLengthB() < be - bs) {
+				lcs.beginA = as;
+				lcs.beginB = bs;
+				lcs.endA = ae;
+				lcs.endB = be;
+				cIdx = nCnt;
+			}
+
+			nCommon[nCnt] = (((long) bs) << B_SHIFT) | (((long) be) << A_SHIFT);
+			if (++nCnt == uniqueCommonCnt)
+				break MATCH;
+		}
+
+		return lcs;
+	}
+
+	private static boolean isDuplicate(long rec) {
+		return (((int) rec) & DUPLICATE_MASK) != 0;
+	}
+
+	private static int aOfRaw(long rec) {
+		return ((int) (rec >>> A_SHIFT)) & PTR_MASK;
+	}
+
+	private static int aOf(long rec) {
+		return aOfRaw(rec) - 1;
+	}
+
+	private static int bOf(long rec) {
+		return (int) (rec >>> B_SHIFT);
+	}
+
+	private static int tableSize(final int worstCaseBlockCnt) {
+		int shift = 32 - Integer.numberOfLeadingZeros(worstCaseBlockCnt);
+		int sz = 1 << (shift - 1);
+		if (sz < worstCaseBlockCnt)
+			sz <<= 1;
+		return sz;
+	}
+}

org.eclipse.jgit/src/org/eclipse/jgit/diff/SequenceComparator.java

@@ -92,4 +92,41 @@ public abstract class SequenceComparator<S extends Sequence> {
 	 * @return hash the hash value.
 	 */
 	public abstract int hash(S seq, int ptr);
+
+	/**
+	 * Modify the edit to remove common leading and trailing items.
+	 *
+	 * The supplied edit {@code e} is reduced in size by moving the beginning A
+	 * and B points so the edit does not cover any items that are in common
+	 * between the two sequences. The ending A and B points are also shifted to
+	 * remove common items from the end of the region.
+	 *
+	 * @param a
+	 *            the first sequence.
+	 * @param b
+	 *            the second sequence.
+	 * @param e
+	 *            the edit to start with and update.
+	 * @return {@code e} if it was updated in-place, otherwise a new edit
+	 *         containing the reduced region.
+	 */
+	public Edit reduceCommonStartEnd(S a, S b, Edit e) {
+		// Skip over items that are common at the start.
+		//
+		while (e.beginA < e.endA && e.beginB < e.endB
+				&& equals(a, e.beginA, b, e.beginB)) {
+			e.beginA++;
+			e.beginB++;
+		}
+
+		// Skip over items that are common at the end.
+		//
+		while (e.beginA < e.endA && e.beginB < e.endB
+				&& equals(a, e.endA - 1, b, e.endB - 1)) {
+			e.endA--;
+			e.endB--;
+		}
+
+		return e;
+	}
 }