Reuse coder options in MarshalEncode and UnmarshalDecode (#137)

When calling MarshalEncode and UnmarshalDecode, there are cases
when we can directly reuse the coder.Struct options since
it is identical to the resulting options if we were to merge the
user-provided options with the coder-specific options in coder.Struct.

Performance benefit on AMD Ryzen 9950X:

    UnmarshalDecodeOptions/None  57.8ns ± 1%  41.8ns ± 1%  -27.66%  (p=0.008 n=5+5)
    UnmarshalDecodeOptions/Same  63.1ns ± 1%  42.2ns ± 1%  -33.09%  (p=0.008 n=5+5)
    UnmarshalDecodeOptions/New   64.4ns ± 1%  64.1ns ± 2%     ~     (p=0.690 n=5+5)
    MarshalEncodeOptions/None    55.6ns ± 3%  39.3ns ± 1%  -29.26%  (p=0.016 n=5+4)
    MarshalEncodeOptions/Same    60.0ns ± 2%  38.8ns ± 1%  -35.41%  (p=0.008 n=5+5)
    MarshalEncodeOptions/New     61.1ns ± 1%  61.2ns ± 1%     ~     (p=1.000 n=5+5)

Author: huww98

arshal.go

@@ -21,6 +21,26 @@ import (
 // export exposes internal functionality of the "jsontext" package.
 var export = jsontext.Internal.Export(&internal.AllowInternalUse)
 
+// mayReuseOpt reuses coderOpts if joining opts with the coderOpts
+// would produce the equivalent set of options.
+func mayReuseOpt(coderOpts *jsonopts.Struct, opts []Options) *jsonopts.Struct {
+	switch len(opts) {
+	// In the common case, the caller plumbs down options from the caller's caller,
+	// which is usually the [jsonopts.Struct] constructed by the top-level arshal call.
+	case 1:
+		o, _ := opts[0].(*jsonopts.Struct)
+		if o == coderOpts {
+			return coderOpts
+		}
+	// If the caller provides no options, then just reuse the coder's options,
+	// which should only contain encoding/decoding related flags.
+	case 0:
+		// TODO: This is buggy if coderOpts ever contains non-coder options.
+		return coderOpts
+	}
+	return nil
+}
+
 var structOptionsPool = &sync.Pool{New: func() any { return new(jsonopts.Struct) }}
 
 func getStructOptions() *jsonopts.Struct {
@@ -192,13 +212,16 @@ func MarshalWrite(out io.Writer, in any, opts ...Options) (err error) {
 // they must have already been specified on the provided [jsontext.Encoder].
 // See [Marshal] for details about the conversion of a Go value into JSON.
 func MarshalEncode(out *jsontext.Encoder, in any, opts ...Options) (err error) {
-	mo := getStructOptions()
-	defer putStructOptions(mo)
-	mo.Join(opts...)
 	xe := export.Encoder(out)
-	mo.CopyCoderOptions(&xe.Struct)
+	mo := mayReuseOpt(&xe.Struct, opts)
+	if mo == nil {
+		mo = getStructOptions()
+		defer putStructOptions(mo)
+		mo.Join(opts...)
+		mo.CopyCoderOptions(&xe.Struct)
+	}
 	err = marshalEncode(out, in, mo)
-	if err != nil && xe.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+	if err != nil && mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
 		return internal.TransformMarshalError(in, err)
 	}
 	return err
@@ -435,11 +458,14 @@ func unmarshalFull(in *jsontext.Decoder, out any, uo *jsonopts.Struct) error {
 // The output must be a non-nil pointer.
 // See [Unmarshal] for details about the conversion of JSON into a Go value.
 func UnmarshalDecode(in *jsontext.Decoder, out any, opts ...Options) (err error) {
-	uo := getStructOptions()
-	defer putStructOptions(uo)
-	uo.Join(opts...)
 	xd := export.Decoder(in)
-	uo.CopyCoderOptions(&xd.Struct)
+	uo := mayReuseOpt(&xd.Struct, opts)
+	if uo == nil {
+		uo = getStructOptions()
+		defer putStructOptions(uo)
+		uo.Join(opts...)
+		uo.CopyCoderOptions(&xd.Struct)
+	}
 	err = unmarshalDecode(in, out, uo)
 	if err != nil && uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
 		return internal.TransformUnmarshalError(out, err)

arshal_test.go

@@ -9299,3 +9299,47 @@ func TestUintSet(t *testing.T) {
 		}
 	}
 }
+
+// BenchmarkUnmarshalDecodeOptions is a minimal decode operation to measure
+// the overhead options setup before the unmarshal operation.
+func BenchmarkUnmarshalDecodeOptions(b *testing.B) {
+	var i int
+	in := new(bytes.Buffer)
+	dec := jsontext.NewDecoder(in)
+	makeBench := func(opts ...Options) func(*testing.B) {
+		return func(b *testing.B) {
+			for range b.N {
+				in.WriteString("0 ")
+			}
+			dec.Reset(in)
+			b.ResetTimer()
+			for range b.N {
+				UnmarshalDecode(dec, &i, opts...)
+			}
+		}
+	}
+	b.Run("None", makeBench())
+	b.Run("Same", makeBench(&export.Decoder(dec).Struct))
+	b.Run("New", makeBench(DefaultOptionsV2()))
+}
+
+// BenchmarkMarshalEncodeOptions is a minimal encode operation to measure
+// the overhead of options setup before the marshal operation.
+func BenchmarkMarshalEncodeOptions(b *testing.B) {
+	var i int
+	out := new(bytes.Buffer)
+	enc := jsontext.NewEncoder(out)
+	makeBench := func(opts ...Options) func(*testing.B) {
+		return func(b *testing.B) {
+			out.Reset()
+			enc.Reset(out)
+			b.ResetTimer()
+			for range b.N {
+				MarshalEncode(enc, &i, opts...)
+			}
+		}
+	}
+	b.Run("None", makeBench())
+	b.Run("Same", makeBench(&export.Encoder(enc).Struct))
+	b.Run("New", makeBench(DefaultOptionsV2()))
+}