bytes,strings: optimize Repeat

author Carlo Alberto Ferraris <cafxx@strayorange.com>

Fri, 22 Jul 2022 05:18:33 +0000 (14:18 +0900)

committer Gopher Robot <gobot@golang.org>

Tue, 27 Sep 2022 16:55:15 +0000 (16:55 +0000)
author Carlo Alberto Ferraris <cafxx@strayorange.com>
Fri, 22 Jul 2022 05:18:33 +0000 (14:18 +0900)
committer Gopher Robot <gobot@golang.org>
Tue, 27 Sep 2022 16:55:15 +0000 (16:55 +0000)
diff --git a/src/bytes/bytes.go b/src/bytes/bytes.go

index 119b1f62b1a4f4525e63eb5a243b1ba8c6788b31..e2e5d5fda757983cf50b26d459d81e48e879263c 100644 (file)
--- a/src/bytes/bytes.go
+++ b/src/bytes/bytes.go
@@ -578,8 +578,8 @@ func Map(mapping func(r rune) rune, s []byte) []byte {
  
  // Repeat returns a new byte slice consisting of count copies of b.
  //
-// It panics if count is negative or if
-// the result of (len(b) * count) overflows.
+// It panics if count is negative or if the result of (len(b) * count)
+// overflows.
  func Repeat(b []byte, count int) []byte {
         if count == 0 {
                 return []byte{}
@@ -587,18 +587,45 @@ func Repeat(b []byte, count int) []byte {
         // Since we cannot return an error on overflow,
         // we should panic if the repeat will generate
         // an overflow.
-       // See Issue golang.org/issue/16237.
+       // See golang.org/issue/16237.
         if count < 0 {
                 panic("bytes: negative Repeat count")
         } else if len(b)*count/count != len(b) {
                 panic("bytes: Repeat count causes overflow")
         }
  
-       nb := make([]byte, len(b)*count)
+       if len(b) == 0 {
+               return []byte{}
+       }
+
+       n := len(b) * count
+
+       // Past a certain chunk size it is counterproductive to use
+       // larger chunks as the source of the write, as when the source
+       // is too large we are basically just thrashing the CPU D-cache.
+       // So if the result length is larger than an empirically-found
+       // limit (8KB), we stop growing the source string once the limit
+       // is reached and keep reusing the same source string - that
+       // should therefore be always resident in the L1 cache - until we
+       // have completed the construction of the result.
+       // This yields significant speedups (up to +100%) in cases where
+       // the result length is large (roughly, over L2 cache size).
+       const chunkLimit = 8 * 1024
+       chunkMax := n
+       if chunkMax > chunkLimit {
+               chunkMax = chunkLimit / len(b) * len(b)
+               if chunkMax == 0 {
+                       chunkMax = len(b)
+               }
+       }
+       nb := make([]byte, n)
         bp := copy(nb, b)
         for bp < len(nb) {
-               copy(nb[bp:], nb[:bp])
-               bp *= 2
+               chunk := bp
+               if chunk > chunkMax {
+                       chunk = chunkMax
+               }
+               bp += copy(nb[bp:], nb[:chunk])
         }
         return nb
  }
diff --git a/src/bytes/bytes_test.go b/src/bytes/bytes_test.go

index 7263af3ed0160596627e4f2688698fed9971b036..f58f18c461bb39cb63a419c12cb2f9313a4b2207 100644 (file)
--- a/src/bytes/bytes_test.go
+++ b/src/bytes/bytes_test.go
@@ -1159,6 +1159,8 @@ type RepeatTest struct {
         count   int
  }
  
+var longString = "a" + string(make([]byte, 1<<16)) + "z"
+
  var RepeatTests = []RepeatTest{
         {"", "", 0},
         {"", "", 1},
@@ -1167,6 +1169,9 @@ var RepeatTests = []RepeatTest{
         {"-", "-", 1},
         {"-", "----------", 10},
         {"abc ", "abc abc abc ", 3},
+       // Tests for results over the chunkLimit
+       {string(rune(0)), string(make([]byte, 1<<16)), 1 << 16},
+       {longString, longString + longString, 2},
  }
  
  func TestRepeat(t *testing.T) {
@@ -2048,6 +2053,25 @@ func BenchmarkRepeat(b *testing.B) {
         }
  }
  
+func BenchmarkRepeatLarge(b *testing.B) {
+       s := Repeat([]byte("@"), 8*1024)
+       for j := 8; j <= 30; j++ {
+               for _, k := range []int{1, 16, 4097} {
+                       s := s[:k]
+                       n := (1 << j) / k
+                       if n == 0 {
+                               continue
+                       }
+                       b.Run(fmt.Sprintf("%d/%d", 1<<j, k), func(b *testing.B) {
+                               for i := 0; i < b.N; i++ {
+                                       Repeat(s, n)
+                               }
+                               b.SetBytes(int64(n * len(s)))
+                       })
+               }
+       }
+}
+
  func BenchmarkBytesCompare(b *testing.B) {
         for n := 1; n <= 2048; n <<= 1 {
                 b.Run(fmt.Sprint(n), func(b *testing.B) {
diff --git a/src/strings/strings.go b/src/strings/strings.go

index fee161e4cc10f1105f02476a13633e044ca491c9..646161fdda72ac302c7305518d918c26dc72690d 100644 (file)
--- a/src/strings/strings.go
+++ b/src/strings/strings.go
@@ -520,8 +520,8 @@ func Map(mapping func(rune) rune, s string) string {
  
  // Repeat returns a new string consisting of count copies of the string s.
  //
-// It panics if count is negative or if
-// the result of (len(s) * count) overflows.
+// It panics if count is negative or if the result of (len(s) * count)
+// overflows.
  func Repeat(s string, count int) string {
         switch count {
         case 0:
@@ -533,24 +533,50 @@ func Repeat(s string, count int) string {
         // Since we cannot return an error on overflow,
         // we should panic if the repeat will generate
         // an overflow.
-       // See Issue golang.org/issue/16237
+       // See golang.org/issue/16237.
         if count < 0 {
                 panic("strings: negative Repeat count")
         } else if len(s)*count/count != len(s) {
                 panic("strings: Repeat count causes overflow")
         }
  
+       if len(s) == 0 {
+               return ""
+       }
+
         n := len(s) * count
+
+       // Past a certain chunk size it is counterproductive to use
+       // larger chunks as the source of the write, as when the source
+       // is too large we are basically just thrashing the CPU D-cache.
+       // So if the result length is larger than an empirically-found
+       // limit (8KB), we stop growing the source string once the limit
+       // is reached and keep reusing the same source string - that
+       // should therefore be always resident in the L1 cache - until we
+       // have completed the construction of the result.
+       // This yields significant speedups (up to +100%) in cases where
+       // the result length is large (roughly, over L2 cache size).
+       const chunkLimit = 8 * 1024
+       chunkMax := n
+       if n > chunkLimit {
+               chunkMax = chunkLimit / len(s) * len(s)
+               if chunkMax == 0 {
+                       chunkMax = len(s)
+               }
+       }
+
         var b Builder
         b.Grow(n)
         b.WriteString(s)
         for b.Len() < n {
-               if b.Len() <= n/2 {
-                       b.WriteString(b.String())
-               } else {
-                       b.WriteString(b.String()[:n-b.Len()])
-                       break
+               chunk := n - b.Len()
+               if chunk > b.Len() {
+                       chunk = b.Len()
+               }
+               if chunk > chunkMax {
+                       chunk = chunkMax
                 }
+               b.WriteString(b.String()[:chunk])
         }
         return b.String()
  }
diff --git a/src/strings/strings_test.go b/src/strings/strings_test.go

index 210bd9e44b4739ed11a1016802e38b58b81579fd..27489c2d1651c7900ada1c0a6603d90484ac9285 100644 (file)
--- a/src/strings/strings_test.go
+++ b/src/strings/strings_test.go
@@ -1105,6 +1105,8 @@ func TestCaseConsistency(t *testing.T) {
         */
  }
  
+var longString = "a" + string(make([]byte, 1<<16)) + "z"
+
  var RepeatTests = []struct {
         in, out string
         count   int
@@ -1116,6 +1118,9 @@ var RepeatTests = []struct {
         {"-", "-", 1},
         {"-", "----------", 10},
         {"abc ", "abc abc abc ", 3},
+       // Tests for results over the chunkLimit
+       {string(rune(0)), string(make([]byte, 1<<16)), 1 << 16},
+       {longString, longString + longString, 2},
  }
  
  func TestRepeat(t *testing.T) {
@@ -1885,6 +1890,25 @@ func BenchmarkRepeat(b *testing.B) {
         }
  }
  
+func BenchmarkRepeatLarge(b *testing.B) {
+       s := Repeat("@", 8*1024)
+       for j := 8; j <= 30; j++ {
+               for _, k := range []int{1, 16, 4097} {
+                       s := s[:k]
+                       n := (1 << j) / k
+                       if n == 0 {
+                               continue
+                       }
+                       b.Run(fmt.Sprintf("%d/%d", 1<<j, k), func(b *testing.B) {
+                               for i := 0; i < b.N; i++ {
+                                       Repeat(s, n)
+                               }
+                               b.SetBytes(int64(n * len(s)))
+                       })
+               }
+       }
+}
+
  func BenchmarkIndexAnyASCII(b *testing.B) {
         x := Repeat("#", 2048) // Never matches set
         cs := "0123456789abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz"
author	Carlo Alberto Ferraris <cafxx@strayorange.com>
	Fri, 22 Jul 2022 05:18:33 +0000 (14:18 +0900)
committer	Gopher Robot <gobot@golang.org>
	Tue, 27 Sep 2022 16:55:15 +0000 (16:55 +0000)
src/bytes/bytes.go		patch \| blob \| history
src/bytes/bytes_test.go		patch \| blob \| history
src/strings/strings.go		patch \| blob \| history
src/strings/strings_test.go		patch \| blob \| history