Improve performance of line-mode speedup

Reserve 2/3rds of space for text1, 1/3rds for text2. Prevent overflow beyond hard limit.

Author: Neil Fraser

csharp/DiffMatchPatch.cs

@@ -603,8 +603,9 @@ protected Object[] diff_linesToChars(string text1, string text2) {
  // So we'll insert a junk entry to avoid generating a null character.
  lineArray.Add(string.Empty);
 
- string chars1 = diff_linesToCharsMunge(text1, lineArray, lineHash);
- string chars2 = diff_linesToCharsMunge(text2, lineArray, lineHash);
+ // Allocate 2/3rds of the space for text1, the rest for text2.
+ string chars1 = diff_linesToCharsMunge(text1, lineArray, lineHash, 40000);
+ string chars2 = diff_linesToCharsMunge(text2, lineArray, lineHash, 65535);
  return new Object[] { chars1, chars2, lineArray };
  }
 
@@ -614,10 +615,11 @@ protected Object[] diff_linesToChars(string text1, string text2) {
  * @param text String to encode.
  * @param lineArray List of unique strings.
  * @param lineHash Map of strings to indices.
+ * @param maxLines Maximum length of lineArray.
  * @return Encoded string.
  */
  private string diff_linesToCharsMunge(string text, List<string> lineArray,
-  Dictionary<string, int> lineHash) {
+ Dictionary<string, int> lineHash, int maxLines) {
  int lineStart = 0;
  int lineEnd = -1;
  string line;
@@ -635,7 +637,7 @@ private string diff_linesToCharsMunge(string text, List<string> lineArray,
  if (lineHash.ContainsKey(line)) {
  chars.Append(((char)(int)lineHash[line]));
  } else {
- if (lineArray.Count == 65535) {
+ if (lineArray.Count == maxLines) {
  // Bail out at 65535 because char 65536 == char 0.
  line = text.Substring(lineStart);
  lineEnd = text.Length;

dart/DMPClass.dart

@@ -452,8 +452,9 @@ class DiffMatchPatch {
  // So we'll insert a junk entry to avoid generating a null character.
  lineArray.add('');
 
- String chars1 = _diff_linesToCharsMunge(text1, lineArray, lineHash);
- String chars2 = _diff_linesToCharsMunge(text2, lineArray, lineHash);
+ // Allocate 2/3rds of the space for text1, the rest for text2.
+ String chars1 = _diff_linesToCharsMunge(text1, lineArray, lineHash, 40000);
+ String chars2 = _diff_linesToCharsMunge(text2, lineArray, lineHash, 65535);
  return {'chars1': chars1, 'chars2': chars2, 'lineArray': lineArray};
  }
 
@@ -463,10 +464,11 @@ class DiffMatchPatch {
  * [text] is the string to encode.
  * [lineArray] is a List of unique strings.
  * [lineHash] is a Map of strings to indices.
+ * [maxLines] is the maximum length for lineArray.
  * Returns an encoded string.
  */
- String _diff_linesToCharsMunge(
- String text, List<String> lineArray, Map<String, int> lineHash) {
+ String _diff_linesToCharsMunge(String text, List<String> lineArray,
+ Map<String, int> lineHash, int maxLines) {
  int lineStart = 0;
  int lineEnd = -1;
  String line;
@@ -484,7 +486,7 @@ class DiffMatchPatch {
  if (lineHash.containsKey(line)) {
  chars.writeCharCode(lineHash[line]);
  } else {
- if (lineArray.length == 65535) {
+ if (lineArray.length == maxLines) {
  // Bail out at 65535 because
  // final chars1 = new StringBuffer();
  // chars1.writeCharCode(65536);

java/src/name/fraser/neil/plaintext/diff_match_patch.java

@@ -517,8 +517,9 @@ protected LinesToCharsResult diff_linesToChars(String text1, String text2) {
  // So we'll insert a junk entry to avoid generating a null character.
  lineArray.add("");
 
- String chars1 = diff_linesToCharsMunge(text1, lineArray, lineHash);
- String chars2 = diff_linesToCharsMunge(text2, lineArray, lineHash);
+ // Allocate 2/3rds of the space for text1, the rest for text2.
+ String chars1 = diff_linesToCharsMunge(text1, lineArray, lineHash, 40000);
+ String chars2 = diff_linesToCharsMunge(text2, lineArray, lineHash, 65535);
  return new LinesToCharsResult(chars1, chars2, lineArray);
  }
 
@@ -528,10 +529,11 @@ protected LinesToCharsResult diff_linesToChars(String text1, String text2) {
  * @param text String to encode.
  * @param lineArray List of unique strings.
  * @param lineHash Map of strings to indices.
+ * @param maxLines Maximum length of lineArray.
  * @return Encoded string.
  */
  private String diff_linesToCharsMunge(String text, List<String> lineArray,
-  Map<String, Integer> lineHash) {
+ Map<String, Integer> lineHash, int maxLines) {
  int lineStart = 0;
  int lineEnd = -1;
  String line;
@@ -549,7 +551,7 @@ private String diff_linesToCharsMunge(String text, List<String> lineArray,
  if (lineHash.containsKey(line)) {
  chars.append(String.valueOf((char) (int) lineHash.get(line)));
  } else {
- if (lineArray.size() == 65535) {
+ if (lineArray.size() == maxLines) {
  // Bail out at 65535 because
  // String.valueOf((char) 65536).equals(String.valueOf(((char) 0)))
  line = text.substring(lineStart);

javascript/diff_match_patch.js

@@ -475,7 +475,7 @@ diff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) {
  (lineHash[line] !== undefined)) {
  chars += String.fromCharCode(lineHash[line]);
  } else {
- if (lineArrayLength == 65535) {
+ if (lineArrayLength == maxLines) {
  // Bail out at 65535 because
  // String.fromCharCode(65536) == String.fromCharCode(0)
  line = text.substring(lineStart);
@@ -489,8 +489,10 @@ diff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) {
  }
  return chars;
  }
-
+ // Allocate 2/3rds of the space for text1, the rest for text2.
+ var maxLines = 40000;
  var chars1 = diff_linesToCharsMunge_(text1);
+ maxLines = 65535;
  var chars2 = diff_linesToCharsMunge_(text2);
  return {chars1: chars1, chars2: chars2, lineArray: lineArray};
 };

javascript/diff_match_patch_uncompressed.js

@@ -157,7 +157,6 @@ typedef enum {
 - (NSMutableArray *)diff_computeFromOldString:(NSString *)text1 andNewString:(NSString *)text2 checkLines:(BOOL)checklines deadline:(NSTimeInterval)deadline;
 - (NSMutableArray *)diff_lineModeFromOldString:(NSString *)text1 andNewString:(NSString *)text2 deadline:(NSTimeInterval)deadline;
 - (NSArray *)diff_linesToCharsForFirstString:(NSString *)text1 andSecondString:(NSString *)text1;
-- (NSString *)diff_linesToCharsMungeOfText:(NSString *)text lineArray:(NSMutableArray *)lineArray lineHash:(NSMutableDictionary *)lineHash;
 - (void)diff_chars:(NSArray *)diffs toLines:(NSMutableArray *)lineArray;
 - (NSMutableArray *)diff_bisectOfOldString:(NSString *)text1 andNewString:(NSString *)text2 deadline:(NSTimeInterval)deadline;
 - (NSMutableArray *)diff_bisectSplitOfOldString:(NSString *)text1 andNewString:(NSString *)text2 x:(NSUInteger)x y:(NSUInteger)y deadline:(NSTimeInterval)deadline;

objectivec/DiffMatchPatch.h

@@ -623,23 +623,6 @@ - (NSMutableArray *)diff_lineModeFromOldString:(NSString *)text1
  return diffs;
 }
 
-/**
- * Split a text into a list of strings. Reduce the texts to a string of
- * hashes where each Unicode character represents one line.
- * @param text NSString to encode.
- * @param lineArray NSMutableArray of unique strings.
- * @param lineHash Map of strings to indices.
- * @return Encoded string.
- */
-- (NSString *)diff_linesToCharsMungeOfText:(NSString *)text
- lineArray:(NSMutableArray *)lineArray
- lineHash:(NSMutableDictionary *)lineHash;
-{
- return [((NSString *)diff_linesToCharsMungeCFStringCreate((CFStringRef)text,
- (CFMutableArrayRef)lineArray,
- (CFMutableDictionaryRef)lineHash)) autorelease];
-}
-
 /**
  * Find the 'middle snake' of a diff, split the problem in two
  * and return the recursively constructed diff.
@@ -859,12 +842,15 @@ - (NSArray *)diff_linesToCharsForFirstString:(NSString *)text1
  // So we'll insert a junk entry to avoid generating a nil character.
  [lineArray addObject:@""];
 
+ // Allocate 2/3rds of the space for text1, the rest for text2.
  NSString *chars1 = (NSString *)diff_linesToCharsMungeCFStringCreate((CFStringRef)text1,
  (CFMutableArrayRef)lineArray,
- (CFMutableDictionaryRef)lineHash);
+ (CFMutableDictionaryRef)lineHash,
+ 40000);
  NSString *chars2 = (NSString *)diff_linesToCharsMungeCFStringCreate((CFStringRef)text2,
  (CFMutableArrayRef)lineArray,
- (CFMutableDictionaryRef)lineHash);
+ (CFMutableDictionaryRef)lineHash,
+ 65535);
 
  NSArray *result = [NSArray arrayWithObjects:chars1, chars2, lineArray, nil];
 

objectivec/DiffMatchPatch.m

@@ -450,9 +450,10 @@ CFArrayRef diff_halfMatchICreate(CFStringRef longtext, CFStringRef shorttext, CF
  * @param text CFString to encode.
  * @param lineArray CFMutableArray of unique strings.
  * @param lineHash Map of strings to indices.
+ * @param maxLines Maximum length for lineArray.
  * @return Encoded CFStringRef.
  */
-CFStringRef diff_linesToCharsMungeCFStringCreate(CFStringRef text, CFMutableArrayRef lineArray, CFMutableDictionaryRef lineHash) {
+CFStringRef diff_linesToCharsMungeCFStringCreate(CFStringRef text, CFMutableArrayRef lineArray, CFMutableDictionaryRef lineHash, CFIndex maxLines) {
  #define lineStart lineStartRange.location
  #define lineEnd lineEndRange.location
 
@@ -487,7 +488,7 @@ CFStringRef diff_linesToCharsMungeCFStringCreate(CFStringRef text, CFMutableArra
  const UniChar hashChar = (UniChar)hash;
  CFStringAppendCharacters(chars, &hashChar, 1);
  } else {
- if (CFArrayGetCount(lineArray) == 65535) {
+ if (CFArrayGetCount(lineArray) == maxLength) {
  // Bail out at 65535 because char 65536 == char 0.
  line = diff_CFStringCreateJavaSubstring(text, lineStart, textLength);
  lineEnd = textLength;

objectivec/DiffMatchPatchCFUtilities.c

@@ -31,7 +31,7 @@ CFIndex diff_commonOverlap(CFStringRef text1, CFStringRef text2);
 CFArrayRef diff_halfMatchCreate(CFStringRef text1, CFStringRef text2, const float diffTimeout);
 CFArrayRef diff_halfMatchICreate(CFStringRef longtext, CFStringRef shorttext, CFIndex i);
 
-CFStringRef diff_linesToCharsMungeCFStringCreate(CFStringRef text, CFMutableArrayRef lineArray, CFMutableDictionaryRef lineHash);
+CFStringRef diff_linesToCharsMungeCFStringCreate(CFStringRef text, CFMutableArrayRef lineArray, CFMutableDictionaryRef lineHash, CFIndex maxLines);
 
 CFIndex diff_cleanupSemanticScore(CFStringRef one, CFStringRef two);
 

objectivec/DiffMatchPatchCFUtilities.h

@@ -426,7 +426,7 @@ def diff_linesToCharsMunge(text):
  if line in lineHash:
  chars.append(unichr(lineHash[line]))
  else:
- if len(lineArray) == 65535:
+ if len(lineArray) == maxLines:
  # Bail out at 65535 because unichr(65536) throws.
  line = text[lineStart:]
  lineEnd = len(text)
@@ -436,7 +436,10 @@ def diff_linesToCharsMunge(text):
  lineStart = lineEnd + 1
  return "".join(chars)
 
+ # Allocate 2/3rds of the space for text1, the rest for text2.
+ maxLines = 40000
  chars1 = diff_linesToCharsMunge(text1)
+ maxLines = 65535
  chars2 = diff_linesToCharsMunge(text2)
  return (chars1, chars2, lineArray)