Optimize JSON codec (#1148)

* Better Json benchmarks

* Reuse JsonMapSerializer instance instead of allocating per writeMap()

* Override serialize() in JsonCodec with larger initial buffer

* Close deserializer in deserializeShape to enable Jackson buffer recycling

* Pre-compute SerializableString per Schema member for field name writes

* Cache resolved TimestampFormatter per Schema in UseTimestampFormatTrait

* Optimize fieldToMember cache with get-before-compute pattern

* Replace InterceptingSerializer with flat struct serializer

* Add Schema extension system with SPI and migrate JSON caches

* Use bounded recycler pool for Jackson buffer recycling

* Remove FAST_DOUBLE_WRITER

* Add some more thread safety guards in DeferredRootSchema

* Make Schema Extensions lazy

* Add a Smithy Json serializer and deserializer

* Remove publication guard

* Correctness fixes

* More perf improvements

* More perf improvements

* Improve timestamp serialization

* Use copy of Schubfach for direct conversion of Double/Float to byte

* Add SmithyJson to fuzz tests

* Use Arrays.equals in the fast path

* Use FastDoubleParser for direct byte-to-double parsing

* Reuse Schubfach DoubleToDecimal/FloatToDecimal instances

* Write ISO-8601 timestamps directly to byte buffer

* Fast-path BigInteger/BigDecimal when value fits in long

* Use parseLong for integer epoch-seconds timestamps

* Parse ISO-8601 and HTTP-date timestamps directly from bytes

* Write HTTP-date timestamps directly to byte buffer

* Localize pos to register in readStruct hot loop

* Fast-path BigDecimal with non-zero scale when unscaled fits in long

* Localize pos in readList and readStringMap hot loops

* Handle out-of-range epoch seconds in parseLong fast path

* Cleanup and add differential fuzzing

* More tests and correctness changes

* Codegen perf improvements

* Fuse speculative field name check with scan in readStruct

* Pool SmithyJsonSerializer to avoid per-call allocation

* Eliminate OffsetDateTime allocation in timestamp writes

* Write BigInteger directly to byte buffer via 18-digit groups

* Add equals/hashCode to JsonSettings for serializer pool matching

* Merge buffer pool into serializer pool and fix exception safety

* Fuse field name and value capacity checks in StructSerializer

* Use getPlain/compareAndExchangeAcquire for cheaper pool operations

* Cleanups and refactor fuzz test to use one codec

* Tighten fuzz tests, reduce allocations while reading blobs

* Address PR comments

* Clear out needsComma if there is a exception

* Replace streams with loop while loading Schema extensions

Author: adwsingh

codecs/cbor-codec/src/fuzz/java/software/amazon/smithy/java/cbor/DeserializationFuzzTest.java

@@ -8,9 +8,6 @@
 import software.amazon.smithy.java.core.serde.Codec;
 import software.amazon.smithy.java.fuzz.CodecDeserializationFuzzTestBase;
 
-/**
- * Fuzz tests for Rpcv2CborCodec with various configurations.
- */
 class DeserializationFuzzTest {
 
     static class DefaultTest extends CodecDeserializationFuzzTestBase {
@@ -20,5 +17,4 @@ protected Codec codecToFuzz() {
             return Rpcv2CborCodec.builder().build();
         }
     }
-
 }

codecs/json-codec/build.gradle.kts

@@ -2,6 +2,7 @@ plugins {
     id("smithy-java.module-conventions")
     id("smithy-java.fuzz-test")
     id("me.champeau.jmh") version "0.7.3"
+    id("software.amazon.smithy.gradle.smithy-base")
     alias(libs.plugins.shadow)
 }
 
@@ -13,7 +14,10 @@ extra["moduleName"] = "software.amazon.smithy.java.json"
 dependencies {
     api(project(":core"))
     compileOnly(libs.jackson.core)
+    compileOnly(libs.fastdoubleparser)
     testRuntimeOnly(libs.jackson.core)
+    testRuntimeOnly(libs.fastdoubleparser)
+    smithyBuild(project(":codegen:codegen-plugin"))
 }
 
 tasks {
@@ -29,7 +33,15 @@ tasks {
                         .toString(),
                 ),
             )
+            include(
+                dependency(
+                    libs.fastdoubleparser
+                        .get()
+                        .toString(),
+                ),
+            )
             relocate("tools.jackson.core", "software.amazon.smithy.java.internal.shaded.tools.jackson.core")
+            relocate("ch.randelshofer", "software.amazon.smithy.java.internal.shaded.ch.randelshofer")
         }
     }
     jar {
@@ -56,10 +68,53 @@ afterEvaluate {
     }
 }
 
+afterEvaluate {
+    val typePath = smithy.getPluginProjectionPath(smithy.sourceProjection.get(), "java-codegen").get()
+    sourceSets.named("jmh") {
+        java {
+            srcDir("$typePath/java")
+        }
+        resources {
+            srcDir("$typePath/resources")
+        }
+    }
+    sourceSets.named("test") {
+        java {
+            srcDir("$typePath/java")
+        }
+        resources {
+            srcDir("$typePath/resources")
+        }
+    }
+}
+
+tasks.named("compileJmhJava") {
+    dependsOn("smithyBuild")
+}
+
+tasks.named("compileTestJava") {
+    dependsOn("smithyBuild")
+}
+
+tasks.named("processJmhResources") {
+    dependsOn("smithyBuild")
+}
+
+tasks.named("processTestResources") {
+    dependsOn("smithyBuild")
+}
+
 jmh {
     warmupIterations = 3
-    iterations = 3
-    fork = 3
-    // profilers.add("async:output=flamegraph")
+    iterations = 5
+    fork = 1
+    jvmArgs.addAll("-Xms1g", "-Xmx1g")
+    includes.addAll(
+        providers
+            .gradleProperty("jmh.includes")
+            .map { listOf(it) }
+            .orElse(emptyList()),
+    )
+    profilers.add("async:output=jfr;dir=${layout.buildDirectory.get()}/jmh-profiler")
     // profilers.add("gc")
 }

codecs/json-codec/model/bench.smithy

@@ -0,0 +1,268 @@
+$version: "2"
+
+namespace smithy.java.json.bench
+
+/// A simple structure with only scalar fields for baseline benchmarks.
+structure SimpleStruct {
+    @required
+    name: String
+
+    @required
+    age: Integer
+
+    active: Boolean
+
+    score: Double
+
+    createdAt: Timestamp
+}
+
+/// A complex structure that exercises many Smithy type features.
+structure ComplexStruct {
+    @required
+    id: String
+
+    @required
+    count: Integer
+
+    @required
+    enabled: PrimitiveBoolean = false
+
+    @required
+    ratio: PrimitiveDouble = 0
+
+    @required
+    score: PrimitiveFloat = 0
+
+    @required
+    bigCount: PrimitiveLong = 0
+
+    optionalString: String
+
+    optionalInt: Integer
+
+    createdAt: Timestamp
+
+    @timestampFormat("date-time")
+    updatedAt: Timestamp
+
+    @timestampFormat("http-date")
+    expiresAt: Timestamp
+
+    payload: Blob
+
+    tags: StringList
+
+    intList: IntegerList
+
+    metadata: StringMap
+
+    intMap: IntegerMap
+
+    @required
+    nested: NestedStruct
+
+    optionalNested: NestedStruct
+
+    structList: NestedStructList
+
+    structMap: NestedStructMap
+
+    choice: BenchUnion
+
+    color: Color
+
+    colorList: ColorList
+
+    sparseStrings: SparseStringList
+
+    sparseMap: SparseStringMap
+
+    bigIntValue: BigInteger
+
+    bigDecValue: BigDecimal
+
+    freeformData: Document
+}
+
+structure NestedStruct {
+    @required
+    field1: String
+
+    @required
+    field2: Integer
+
+    inner: InnerStruct
+}
+
+structure InnerStruct {
+    value: String
+    numbers: IntegerList
+}
+
+union BenchUnion {
+    stringValue: String
+    intValue: Integer
+    structValue: NestedStruct
+}
+
+enum Color {
+    RED
+    GREEN
+    BLUE
+    YELLOW
+}
+
+list StringList {
+    member: String
+}
+
+list IntegerList {
+    member: Integer
+}
+
+list NestedStructList {
+    member: NestedStruct
+}
+
+list ColorList {
+    member: Color
+}
+
+@sparse
+list SparseStringList {
+    member: String
+}
+
+map StringMap {
+    key: String
+    value: String
+}
+
+map IntegerMap {
+    key: String
+    value: Integer
+}
+
+map NestedStructMap {
+    key: String
+    value: NestedStruct
+}
+
+@sparse
+map SparseStringMap {
+    key: String
+    value: String
+}
+
+/// Structure focused on numeric boundary testing
+structure NumericStruct {
+    byteVal: Byte
+    shortVal: Short
+    intVal: Integer
+    longVal: Long
+    floatVal: Float
+    doubleVal: Double
+    bigIntVal: BigInteger
+    bigDecVal: BigDecimal
+}
+
+/// Structure focused on string edge cases
+structure StringStruct {
+    @required
+    value: String
+}
+
+/// Structure with all three timestamp formats
+structure TimestampStruct {
+    epochSeconds: Timestamp
+
+    @timestampFormat("date-time")
+    dateTime: Timestamp
+
+    @timestampFormat("http-date")
+    httpDate: Timestamp
+}
+
+/// Structure with jsonName trait on multiple fields
+structure JsonNameStruct {
+    @jsonName("ID")
+    id: String
+
+    @jsonName("DisplayName")
+    displayName: String
+
+    normalField: String
+}
+
+/// Structure that nests itself for depth testing
+structure RecursiveStruct {
+    value: String
+    child: RecursiveStruct
+}
+
+/// Structure for blob testing
+structure BlobStruct {
+    data: Blob
+}
+
+list DoubleList {
+    member: Double
+}
+
+list BigDecimalList {
+    member: BigDecimal
+}
+
+map IntToStructMap {
+    key: String
+    value: InnerStruct
+}
+
+list BooleanList {
+    member: Boolean
+}
+
+list ByteList {
+    member: Byte
+}
+
+list ShortList {
+    member: Short
+}
+
+list LongList {
+    member: Long
+}
+
+list FloatList {
+    member: Float
+}
+
+list BigIntegerList {
+    member: BigInteger
+}
+
+list BlobList {
+    member: Blob
+}
+
+list TimestampList {
+    member: Timestamp
+}
+
+/// Structure containing lists of all types to exercise ListElementSerializer
+structure AllListsStruct {
+    booleans: BooleanList
+    bytes: ByteList
+    shorts: ShortList
+    ints: IntegerList
+    longs: LongList
+    floats: FloatList
+    doubles: DoubleList
+    bigInts: BigIntegerList
+    bigDecs: BigDecimalList
+    strings: StringList
+    blobs: BlobList
+    timestamps: TimestampList
+}

codecs/json-codec/smithy-build.json

@@ -0,0 +1,9 @@
+{
+  "version": "1.0",
+  "plugins": {
+    "java-codegen": {
+      "namespace": "software.amazon.smithy.java.json.bench",
+      "modes": ["types"]
+    }
+  }
+}