encoding/json: Unmarshal into any is slower with jsonv2 compatibility than with nojsonv2

[iandyh]

Go version

go1.27rc1 darwin/arm64

Unexpected slowness

Rank	Library	Total time	Mean/pass	Throughput	ns/record	Allocated bytes/record	Allocs/record	Relative to v1
1	encoding/json/v2 native	983ms	197ms	213.32 MiB/s	1967	1755	53.04	1.76x
2	encoding/json (nojsonv2 v1)	1.726s	345ms	121.55 MiB/s	3451	2139	71.49	1.00x
3	encoding/json (default jsonv2)	2.216s	443ms	94.65 MiB/s	4433	2089	69.84	0.78x

We can see jsonv2 with v1 compatibility is roughly 20% slower.

How to reproduce

Benchmarked encoding/json.Unmarshal into any using Go 1.27rc1 default jsonv2-backed encoding/json and compared it with GOEXPERIMENT=nojsonv2.

The benchmark decodes NDJSON records into a fresh any:

var v any
if err := json.Unmarshal(record, &v); err != nil {
        log.Fatal(err)
}

When there is no any in the data structure

Rank	Library	Time	Mean/pass	Throughput	ns/record	Allocated bytes/record	Allocs/record	Relative to v1
1	encoding/json (default jsonv2)	14.346s	2.869s	152.84 MiB/s	28,691	7,149	131.42	1.69×
2	encoding/json (nojsonv2 v1)	24.203s	4.841s	90.59 MiB/s	48,405	8,347	188.00	1.00×

We can see the promised performance gain.

Profiling results

Function	Flat	Flat %	Cumulative	Cumulative %	Meaning
encoding/json/v2.makeInterfaceArshaler.func2	390ms	3.10%	10.32s	82.10%	Generic interface decode path.
encoding/json/v2.makeMapArshaler.func3	180ms	1.43%	10.18s	80.99%	Generic map decode path.
encoding/json/v2.makeStringArshaler.func2	180ms	1.43%	2.29s	18.22%	Generic string decode path.
runtime.mallocgc	270ms	2.15%	2.19s	17.42%	Allocation and GC work.
encoding/json/v2.makeSliceArshaler.func3	90ms	0.72%	2.13s	16.95%	Generic slice decode path.
encoding/json/v2.newAddressableValue	10ms	0.08%	1.64s	13.05%	Addressable reflection value construction.
reflect.unsafe_New	50ms	0.40%	1.55s	12.33%	Reflection allocation.
reflect.New	10ms	0.08%	1.50s	11.93%	Reflection allocation wrapper.
reflect.Value.Set	80ms	0.64%	1.35s	10.74%	Reflection assignment.
reflect.Value.assignTo	170ms	1.35%	1.29s	10.26%	Reflection conversion and assignment.
reflect.Value.SetMapIndex	130ms	1.03%	1.22s	9.71%	Reflection map insertion.

This is caused by the extra reflection cost.

Fast path is skipped due to compatibility support

// encoding/json/v2/arshal_default.go
if optimizeCommon &&
    t == anyType && !uo.Flags.Get(jsonflags.AllowDuplicateNames|jsonflags.FormatTag) &&
    (uo.Unmarshalers == nil || !uo.Unmarshalers.(*Unmarshalers).fromAny) {
    v, err := unmarshalValueAny(dec, uo)
    if v != nil {
        va.Set(reflect.ValueOf(v))
    }
    return err
}

Because AllowDuplicateNames is true, the optimized native v2 any path is skipped.

[gabyhelp]

Related Issues

• encoding/json/v2: performance regression when umarshalling in []any #77642
• encoding/json: skyrocketing memory allocation in encoding when `jsonv2` experiment enabled #75026 (closed)
• encoding/json: Unmarshal to a typed struct uses 50% more bytes in go 1.21 (and current versions) vs go 1.20 #69828 (closed)
• encoding/json: performance regression marshaling small values for goexperiment.jsonv2 #74617
• encoding/json: json.Unmarshal converts an interface variable with a value to a Map #69875 (closed)
• encoding/json: map[string]interface performance #35585 (closed)
• encoding/json: do not fill d.errorContext until deemed necessary #37571 (closed)
• encoding/json: infinite recursion in Umarshaler on named pointer type with GOEXPERIMENT=jsonv2 #75361
• encoding/json: changes in gotip(1.27) without any changes #79770 (closed)
• encoding/json: decoding performance regression in 1.9beta1 #20693 (closed)

_{(Emoji vote if this was helpful or unhelpful; more detailed feedback welcome in this discussion.)}

[dsnet]

Thanks for the report. This is unfortunate and we should fix this, but I don't think this should block Go 1.27. Fixing this would be a non-trivial change that too late in the cycle to address. I believe the proper optimization will have to wait until Go 1.28.

[iandyh]

@dsnet Thank you and I agree. The good news is, as long as the any is only a fraction of the data type, the v2 performance improvement can offset this regression.

[dr2chase]

@neild

[davidteather]

Hey, took a stab at this over here: https://go-review.googlesource.com/c/go/+/812340

Not super familiar with the json package but it seemed like the any fastpath was only run when !AllowDuplicateNames which for v1 was always false because AllowDuplicateNames was true.

While in there I also noticed unmarshalObjectAny keeps the last non-fatal error in an object where unmarshalArrayAny and makeMapArshaler keep the first, didn't matter before since v1 never reached it, but it does once the fast path is live, so I swapped the cmp.Or operands too.

benches

goos: darwin
goarch: arm64
pkg: encoding/json/v2
cpu: Apple M2 Pro
                                               │     old      │                 new                 │
                                               │    sec/op    │   sec/op     vs base                │
Testdata/CanadaGeometry/Unmarshal/Interface-10    3.566m ± 1%   2.325m ± 2%  -34.80% (p=0.000 n=10)
Testdata/CitmCatalog/Unmarshal/Interface-10       8.549m ± 2%   5.438m ± 2%  -36.39% (p=0.000 n=10)
Testdata/GolangSource/Unmarshal/Interface-10      20.65m ± 2%   12.48m ± 2%  -39.58% (p=0.000 n=10)
Testdata/StringEscaped/Unmarshal/Interface-10     274.3µ ± 2%   268.3µ ± 1%   -2.18% (p=0.002 n=10)
Testdata/StringUnicode/Unmarshal/Interface-10     61.88µ ± 1%   57.41µ ± 6%   -7.22% (p=0.002 n=10)
Testdata/SyntheaFhir/Unmarshal/Interface-10      12.128m ± 3%   7.521m ± 2%  -37.99% (p=0.000 n=10)
Testdata/TwitterStatus/Unmarshal/Interface-10     3.910m ± 3%   2.714m ± 2%  -30.58% (p=0.000 n=10)
geomean                                           2.434m        1.747m       -28.25%

                                               │      old      │                 new                  │
                                               │     B/op      │     B/op      vs base                │
Testdata/CanadaGeometry/Unmarshal/Interface-10   1280.2Ki ± 0%   988.8Ki ± 0%  -22.76% (p=0.000 n=10)
Testdata/CitmCatalog/Unmarshal/Interface-10       5.290Mi ± 0%   4.736Mi ± 0%  -10.47% (p=0.000 n=10)
Testdata/GolangSource/Unmarshal/Interface-10      7.455Mi ± 0%   6.668Mi ± 0%  -10.56% (p=0.000 n=10)
Testdata/StringEscaped/Unmarshal/Interface-10     69.68Ki ± 0%   69.40Ki ± 0%   -0.40% (p=0.000 n=10)
Testdata/StringUnicode/Unmarshal/Interface-10     26.58Ki ± 0%   26.31Ki ± 0%   -1.03% (p=0.000 n=10)
Testdata/SyntheaFhir/Unmarshal/Interface-10       7.453Mi ± 0%   6.600Mi ± 0%  -11.44% (p=0.000 n=10)
Testdata/TwitterStatus/Unmarshal/Interface-10     1.971Mi ± 0%   1.907Mi ± 0%   -3.28% (p=0.000 n=10)
geomean                                           1.036Mi        966.7Ki        -8.86%

                                               │     old      │                 new                 │
                                               │  allocs/op   │  allocs/op   vs base                │
Testdata/CanadaGeometry/Unmarshal/Interface-10    59.85k ± 0%   37.90k ± 0%  -36.68% (p=0.000 n=10)
Testdata/CitmCatalog/Unmarshal/Interface-10      114.25k ± 0%   81.01k ± 0%  -29.09% (p=0.000 n=10)
Testdata/GolangSource/Unmarshal/Interface-10      257.8k ± 0%   218.8k ± 0%  -15.11% (p=0.000 n=10)
Testdata/StringEscaped/Unmarshal/Interface-10      325.0 ± 0%    299.0 ± 0%   -8.00% (p=0.000 n=10)
Testdata/StringUnicode/Unmarshal/Interface-10      207.0 ± 0%    181.0 ± 0%  -12.56% (p=0.000 n=10)
Testdata/SyntheaFhir/Unmarshal/Interface-10       163.2k ± 0%   117.5k ± 0%  -28.00% (p=0.000 n=10)
Testdata/TwitterStatus/Unmarshal/Interface-10     38.28k ± 0%   28.10k ± 0%  -26.59% (p=0.000 n=10)
geomean                                           18.50k        14.26k       -22.89%

[gopherbot]

Change https://go.dev/cl/812340 mentions this issue: encoding/json/v2: use the any fast path under v1 merge semantics

[dsnet]

Thank you for the contribution. I'm not going to review this until after Go 1.27 is released. By then I may forget, so feel free to ping the issue.

[cee-dub]

Thank you for the contribution. I'm not going to review this until after Go 1.27 is released. By then I may forget, so feel free to ping the issue.

Friendly ping for @dsnet