[dev.fuzz] internal/fuzz: move coverage capture closer to function

When instrumented packages intersect with the packages used by the
testing or internal/fuzz packages the coverage counters become noisier,
as counters will be triggered by non-fuzzed harness code.

Ideally counters would be deterministic, as there are many advanced
fuzzing strategies that require mutating the input while maintaining
static coverage.

The simplest way to mitigate this noise is to capture the coverage
counters as closely as possible to the invocation of the fuzz target
in the testing package. In order to do this add a new function which
captures the current values of the counters, SnapshotCoverage. This
function copies the current counters into a static buffer,
coverageSnapshot, which workerServer.fuzz can then inspect when it
comes time to check if new coverage has been found.

This method is not foolproof. As the fuzz target is called in a
goroutine, harness code can still cause counters to be incremented
while the target is being executed. Despite this we do see
significant reduction in churn via this approach. For example,
running a  basic target that causes strconv to be instrumented for
500,000 iterations causes ~800 unique sets of coverage counters,
whereas by capturing the counters closer to the target we get ~40
unique sets.

It may be possible to make counters completely deterministic, but
likely this would require rewriting testing/F.Fuzz to not use tRunner
in a goroutine, and instead use it in a blocking manner (which I
couldn't figure out an obvious way to do), or by doing something even
more complex.

Change-Id: I95c2f3b1d7089c3e6885fc7628a0d3a8ac1a99cf
Reviewed-on: https://go-review.googlesource.com/c/go/+/320329
Trust: Roland Shoemaker <roland@golang.org>
Trust: Katie Hockman <katie@golang.org>
Reviewed-by: Jay Conrod <jayconrod@google.com>
Reviewed-by: Katie Hockman <katie@golang.org>

src/internal/fuzz/coverage.go

@@ -26,25 +26,27 @@ func coverage() []byte {
 	return res
 }
 
-// coverageCopy returns a copy of the current bytes provided by coverage().
-// TODO(jayconrod,katiehockman): consider using a shared buffer instead, to
-// make fewer costly allocations.
-func coverageCopy() []byte {
-	cov := coverage()
-	ret := make([]byte, len(cov))
-	copy(ret, cov)
-	return ret
-}
-
-// resetCovereage sets all of the counters for each edge of the instrumented
+// ResetCovereage sets all of the counters for each edge of the instrumented
 // source code to 0.
-func resetCoverage() {
+func ResetCoverage() {
 	cov := coverage()
 	for i := range cov {
 		cov[i] = 0
 	}
 }
 
+// SnapshotCoverage copies the current counter values into coverageSnapshot,
+// preserving them for later inspection.
+func SnapshotCoverage() {
+	cov := coverage()
+	if coverageSnapshot == nil {
+		coverageSnapshot = make([]byte, len(cov))
+	}
+	copy(coverageSnapshot, cov)
+}
+
+var coverageSnapshot []byte
+
 // _counters and _ecounters mark the start and end, respectively, of where
 // the 8-bit coverage counters reside in memory. They're known to cmd/link,
 // which specially assigns their addresses for this purpose.