use sync.Pool for runner pooling

Currently as noted in the comment of `putRunner`, there's no attempt
being made to limit the size of the runner pooling - this can result in
the pool containing a lot of runners that were once created in a spur
but will likely not be used anymore. Instead of trying to do gc within
this code, move the pooling to `sync.Pool` which will deallocated objects
in idle and therefore keep the size of the pool as small as possible. For proper
usage of `sync.Pool` there must be a hard limit on the size of `runtrack`,
`runstrack`, `runcrawl` in the case they are too big they will not be
cached, the `initMatch` function has been adjusted to make sure if one
of three slices weren't cached they will be allocated again.

The pool is global and not per-regexp because sync.Pool has a noCopy
struct which conflicts with the the UnmarshalText function of `Regexp`.
This should have the added benefit that if you're executing many
different regexps they will benefit from each other allocated runners.

The motivation for this change is that I'm seeing a lot of memory (~300MiB) being
hold by these runners until the Go program is restarted which feels like
an unoptimal usage of memory, with this change after a spur of these
runners have been created in a small amount of time they are gracefully
deallocated over time and no longer hold memory indefinitely.

Author: Gusted

regexp.go

@@ -12,7 +12,6 @@ import (
 	"errors"
 	"math"
 	"strconv"
-	"sync"
 	"time"
 
 	"github.com/dlclark/regexp2/syntax"
@@ -45,10 +44,6 @@ type Regexp struct {
 	capsize  int            // size of the capture array
 
 	code *syntax.Code // compiled program
-
-	// cache of machines for running regexp
-	muRun  *sync.Mutex
-	runner []*runner
 }
 
 // Compile parses a regular expression and returns, if successful,
@@ -76,7 +71,6 @@ func Compile(expr string, opt RegexOptions) (*Regexp, error) {
 		capsize:      code.Capsize,
 		code:         code,
 		MatchTimeout: DefaultMatchTimeout,
-		muRun:        &sync.Mutex{},
 	}, nil
 }
 

runner.go

@@ -7,6 +7,7 @@ import (
 	"math"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 	"unicode"
 
@@ -1356,38 +1357,30 @@ func (r *runner) initMatch() {
 		r.runmatch.reset(r.runtext, r.runtextstart)
 	}
 
-	// note we test runcrawl, because it is the last one to be allocated
-	// If there is an alloc failure in the middle of the three allocations,
-	// we may still return to reuse this instance, and we want to behave
-	// as if the allocations didn't occur. (we used to test _trackcount != 0)
-
-	if r.runcrawl != nil {
-		r.runtrackpos = len(r.runtrack)
-		r.runstackpos = len(r.runstack)
-		r.runcrawlpos = len(r.runcrawl)
-		return
-	}
-
 	r.initTrackCount()
 
-	tracksize := r.runtrackcount * 8
-	stacksize := r.runtrackcount * 8
-
-	if tracksize < 32 {
-		tracksize = 32
-	}
-	if stacksize < 16 {
-		stacksize = 16
+	if r.runtrack == nil {
+		tracksize := r.runtrackcount * 8
+		if tracksize < 32 {
+			tracksize = 32
+		}
+		r.runtrack = make([]int, tracksize)
+		r.runtrackpos = tracksize
 	}
 
-	r.runtrack = make([]int, tracksize)
-	r.runtrackpos = tracksize
-
-	r.runstack = make([]int, stacksize)
-	r.runstackpos = stacksize
+	if r.runstack == nil {
+		stacksize := r.runtrackcount * 8
+		if stacksize < 16 {
+			stacksize = 16
+		}
+		r.runstack = make([]int, stacksize)
+		r.runstackpos = stacksize
+	}
 
-	r.runcrawl = make([]int, 32)
-	r.runcrawlpos = 32
+	if r.runcrawl == nil {
+		r.runcrawl = make([]int, 32)
+		r.runcrawlpos = 32
+	}
 }
 
 func (r *runner) tidyMatch(quick bool) *Match {
@@ -1579,35 +1572,39 @@ func (r *runner) initTrackCount() {
 	r.runtrackcount = r.code.TrackCount
 }
 
+// Pool of runners, use getRunner and putRunner to retrieve and put back
+// runners, respectively.
+var runnerPool = sync.Pool{
+	New: func() interface{} {
+		return new(runner)
+	},
+}
+
 // getRunner returns a run to use for matching re.
-// It uses the re's runner cache if possible, to avoid
-// unnecessary allocation.
+// It uses the runner cache if possible, to avoid unnecessary allocation.
 func (re *Regexp) getRunner() *runner {
-	re.muRun.Lock()
-	if n := len(re.runner); n > 0 {
-		z := re.runner[n-1]
-		re.runner = re.runner[:n-1]
-		re.muRun.Unlock()
-		return z
-	}
-	re.muRun.Unlock()
-	z := &runner{
-		re:   re,
-		code: re.code,
-	}
+	z := runnerPool.Get().(*runner)
+	z.re = re
+	z.code = re.code
 	return z
 }
 
-// putRunner returns a runner to the re's cache.
-// There is no attempt to limit the size of the cache, so it will
-// grow to the maximum number of simultaneous matches
-// run using re.  (The cache empties when re gets garbage collected.)
+// putRunner returns a runner to the runner pool.
 func (re *Regexp) putRunner(r *runner) {
-	re.muRun.Lock()
-	r.runtext = nil
-	if r.runmatch != nil {
-		r.runmatch.text = nil
+	// Proper usage of a sync.Pool requires each entry to have approximately
+	// the same memory cost.
+	// See https://golang.org/issue/23199.
+	if cap(r.runtrack) > 32*1024 {
+		r.runtrack = nil
+	}
+	if cap(r.runstack) > 16*1024 {
+		r.runstack = nil
+	}
+	if cap(r.runcrawl) > 1024 {
+		r.runcrawl = nil
 	}
-	re.runner = append(re.runner, r)
-	re.muRun.Unlock()
+
+	r.runtext = nil
+	r.runmatch = nil
+	runnerPool.Put(r)
 }