Optimize splice

The old code was a cute one-liner,
but it allocated needlessly, quite a lot.
Replace it with slightly more careful code
that only allocates and copies as necessary.


name                       old time/op    new time/op    delta
DiffCommonPrefix-8            135ns ± 2%     133ns ± 1%     ~     (p=0.213 n=10+9)
DiffCommonSuffix-8            142ns ± 3%     141ns ± 2%     ~     (p=0.173 n=10+9)
DiffHalfMatch-8               107µs ± 0%     107µs ± 0%     ~     (p=0.400 n=9+9)
DiffCleanupSemantic-8        11.4ms ± 1%     0.9ms ± 1%  -91.72%  (p=0.000 n=10+9)
DiffMain-8                    1.01s ± 0%     1.01s ± 0%     ~     (p=0.780 n=10+9)
DiffMainLarge-8               134ms ± 1%     101ms ± 4%  -24.45%  (p=0.000 n=9+9)
DiffMainRunesLargeLines-8     707µs ± 0%     681µs ± 2%   -3.61%  (p=0.000 n=9+10)

name                       old alloc/op   new alloc/op   delta
DiffCommonPrefix-8            0.00B          0.00B          ~     (all equal)
DiffCommonSuffix-8            0.00B          0.00B          ~     (all equal)
DiffHalfMatch-8               106kB ± 0%     106kB ± 0%     ~     (all equal)
DiffCleanupSemantic-8        17.7MB ± 0%     0.3MB ± 0%  -98.56%  (p=0.000 n=9+9)
DiffMain-8                   16.4MB ± 0%    16.4MB ± 0%   -0.00%  (p=0.000 n=10+10)
DiffMainLarge-8              63.8MB ± 0%     4.8MB ± 0%  -92.42%  (p=0.000 n=9+10)
DiffMainRunesLargeLines-8     209kB ± 0%     175kB ± 0%  -16.54%  (p=0.000 n=10+10)

name                       old allocs/op  new allocs/op  delta
DiffCommonPrefix-8             0.00           0.00          ~     (all equal)
DiffCommonSuffix-8             0.00           0.00          ~     (all equal)
DiffHalfMatch-8                2.00 ± 0%      2.00 ± 0%     ~     (all equal)
DiffCleanupSemantic-8         11.4k ± 0%      3.1k ± 0%  -72.46%  (p=0.000 n=10+10)
DiffMain-8                     89.0 ± 0%      83.0 ± 0%   -6.74%  (p=0.000 n=10+10)
DiffMainLarge-8               55.3k ± 0%     46.5k ± 0%  -15.94%  (p=0.000 n=10+10)
DiffMainRunesLargeLines-8     1.19k ± 0%     1.09k ± 0%   -8.60%  (p=0.000 n=10+8)

Author: josharian

diffmatchpatch/diff.go

@@ -40,8 +40,41 @@ type Diff struct {
 	Text string
 }
 
+// splice removes amount elements from slice at index index, replacing them with elements.
 func splice(slice []Diff, index int, amount int, elements ...Diff) []Diff {
-	return append(slice[:index], append(elements, slice[index+amount:]...)...)
+	if len(elements) == amount {
+		// Easy case: overwrite the relevant items.
+		copy(slice[index:], elements)
+		return slice
+	}
+	if len(elements) < amount {
+		// Fewer new items than old.
+		// Copy in the new items.
+		copy(slice[index:], elements)
+		// Shift the remaining items left.
+		copy(slice[index+len(elements):], slice[index+amount:])
+		// Calculate the new end of the slice.
+		end := len(slice) - amount + len(elements)
+		// Zero stranded elements at end so that they can be garbage collected.
+		tail := slice[end:]
+		for i := range tail {
+			tail[i] = Diff{}
+		}
+		return slice[:end]
+	}
+	// More new items than old.
+	// Make room in slice for new elements.
+	// There's probably an even more efficient way to do this,
+	// but this is simple and clear.
+	need := len(slice) - amount + len(elements)
+	for len(slice) < need {
+		slice = append(slice, Diff{})
+	}
+	// Shift slice elements right to make room for new elements.
+	copy(slice[index+len(elements):], slice[index+amount:])
+	// Copy in new elements.
+	copy(slice[index:], elements)
+	return slice
 }
 
 // DiffMain finds the differences between two texts.