encoding/json: use pooled encoder in Encoder.Encode

Due to the lack of MarshalWrite in the v1 API,
it is unfortunately common to see:

    json.NewEncoder(out).Encode(in)

where a single-use Encoder is constructed and thrown away.
This performed acceptably in v1 since every call to Encode
used a globally pooled encoder resource.

Prior to this change, the v1-in-v2 implementation relied
on a bytes.Buffer cached only for the lifetime of the Encoder
object itself. Thus, a single-use Encoder does not benefit.
Modify the wrapper implementation to use the internal
pooled encoder from v2 and use the intermediate buffer
to write directly to the output io.Writer.

We assume that the user-provided io.Writer never leaks the buffer,
but this assumption was already held in the v1 implementation.
We are not increasing the surface area of data corruption risk.

Performance of v1 to v1-in-v2 (before the pool fix):

	name                 old time/op    new time/op    delta
	NewEncoderEncode-32    30.2ms ± 4%    28.3ms ± 9%    -6.19%  (p=0.002 n=9+10)

	name                 old alloc/op   new alloc/op   delta
	NewEncoderEncode-32    7.64MB ± 0%   28.37MB ± 0%  +271.23%  (p=0.000 n=10+10)

	name                 old allocs/op  new allocs/op  delta
	NewEncoderEncode-32      200k ± 0%      100k ± 0%   -49.99%  (p=0.000 n=9+10)

Interestingly, v1-in-2 is slightly faster,
but the amount of allocated memory is massive.

Performance of v1 to v1-in-v2 (after the pool fix):

	name                 old time/op    new time/op    delta
	NewEncoderEncode-32    30.2ms ± 4%    24.0ms ± 7%  -20.36%  (p=0.000 n=9+10)

	name                 old alloc/op   new alloc/op   delta
	NewEncoderEncode-32    7.64MB ± 0%    4.09MB ± 3%  -46.52%  (p=0.000 n=10+10)

	name                 old allocs/op  new allocs/op  delta
	NewEncoderEncode-32      200k ± 0%      100k ± 0%  -50.00%  (p=0.000 n=9+9)

Now, the v1-in-v2 implementation is better than v1 on all metrics.

Fixes #75026

Change-Id: I50c975b1d5b8da806e46bc627966b0a39c1817eb
Reviewed-on: https://go-review.googlesource.com/c/go/+/740660
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Damien Neil <dneil@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

1 files changed, 11 insertions, 8 deletions

diff --git a/src/encoding/json/v2_stream.go b/src/encoding/json/v2_stream.go
index ca0822cb73..ee16629cbb 100644
--- a/src/encoding/json/v2_stream.go
+++ b/src/encoding/json/v2_stream.go
@@ -96,7 +96,6 @@ type Encoder struct {
 	opts jsonv2.Options
 	err  error
 
-	buf       bytes.Buffer
 	indentBuf bytes.Buffer
 
 	indentPrefix string
@@ -121,21 +120,22 @@ func (enc *Encoder) Encode(v any) error {
 		return enc.err
 	}
 
-	buf := &enc.buf
-	buf.Reset()
-	if err := jsonv2.MarshalWrite(buf, v, enc.opts); err != nil {
+	e := export.GetBufferedEncoder(enc.opts)
+	defer export.PutBufferedEncoder(e)
+	if err := jsonv2.MarshalEncode(e, v); err != nil {
 		return err
 	}
+	b := export.Encoder(e).Buf // b must not leak current scope
 	if len(enc.indentPrefix)+len(enc.indentValue) > 0 {
 		enc.indentBuf.Reset()
-		if err := Indent(&enc.indentBuf, buf.Bytes(), enc.indentPrefix, enc.indentValue); err != nil {
+		if err := Indent(&enc.indentBuf, b, enc.indentPrefix, enc.indentValue); err != nil {
 			return err
 		}
-		buf = &enc.indentBuf
+		b = enc.indentBuf.Bytes()
 	}
-	buf.WriteByte('\n')
+	b = append(b, '\n')
 
-	if _, err := enc.w.Write(buf.Bytes()); err != nil {
+	if _, err := enc.w.Write(b); err != nil {
 		enc.err = err
 		return err
 	}
@@ -146,6 +146,9 @@ func (enc *Encoder) Encode(v any) error {
 // value as if indented by the package-level function Indent(dst, src, prefix, indent).
 // Calling SetIndent("", "") disables indentation.
 func (enc *Encoder) SetIndent(prefix, indent string) {
+	// NOTE: Do not rely on the newer [jsontext.WithIndent] option since
+	// the v1 [Indent] behavior has historical bugs that cannot be changed
+	// for backward compatibility reasons.
 	enc.indentPrefix = prefix
 	enc.indentValue = indent
 }