From 51db09b9099e11b7b77e231690803ad87bafbb61 Mon Sep 17 00:00:00 2001 From: bbaker Date: Fri, 25 Jul 2025 16:25:32 +1000 Subject: [PATCH 01/21] A smidge faster unwrap non-null --- .../graphql/execution/ExecutionStepInfo.java | 12 ++++++++ .../execution/ExecutionStepInfoFactory.java | 2 +- .../graphql/execution/ExecutionStrategy.java | 10 +++---- .../SubscriptionExecutionStrategy.java | 2 +- .../java/graphql/schema/GraphQLTypeUtil.java | 8 +++-- .../graphql/schema/GraphQLTypeUtilTest.groovy | 30 ++++++++++++++++++- 6 files changed, 54 insertions(+), 10 deletions(-) diff --git a/src/main/java/graphql/execution/ExecutionStepInfo.java b/src/main/java/graphql/execution/ExecutionStepInfo.java index eefa8a81cc..c9f27c38c4 100644 --- a/src/main/java/graphql/execution/ExecutionStepInfo.java +++ b/src/main/java/graphql/execution/ExecutionStepInfo.java @@ -126,6 +126,18 @@ public GraphQLOutputType getUnwrappedNonNullType() { return (GraphQLOutputType) GraphQLTypeUtil.unwrapNonNull(this.type); } + /** + * This returns the type which is unwrapped if it was {@link GraphQLNonNull} wrapped + * and then cast to the target type. + * + * @param for two + * + * @return the graphql type in question + */ + public T getUnwrappedNonNullTypeAs() { + return GraphQLTypeUtil.unwrapNonNullAs(this.type); + } + /** * This returns the field definition that is in play when this type info was created or null * if the type is a root query type diff --git a/src/main/java/graphql/execution/ExecutionStepInfoFactory.java b/src/main/java/graphql/execution/ExecutionStepInfoFactory.java index ec2716aec3..286106a7dc 100644 --- a/src/main/java/graphql/execution/ExecutionStepInfoFactory.java +++ b/src/main/java/graphql/execution/ExecutionStepInfoFactory.java @@ -25,7 +25,7 @@ public class ExecutionStepInfoFactory { public ExecutionStepInfo newExecutionStepInfoForListElement(ExecutionStepInfo executionInfo, ResultPath indexedPath) { - GraphQLList fieldType = (GraphQLList) executionInfo.getUnwrappedNonNullType(); + GraphQLList fieldType = executionInfo.getUnwrappedNonNullTypeAs(); GraphQLOutputType typeInList = (GraphQLOutputType) fieldType.getWrappedType(); return executionInfo.transform(typeInList, executionInfo, indexedPath); } diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java index a16f0f80f1..feb831b6d6 100644 --- a/src/main/java/graphql/execution/ExecutionStrategy.java +++ b/src/main/java/graphql/execution/ExecutionStrategy.java @@ -394,7 +394,7 @@ protected Object resolveFieldWithInfo(ExecutionContext executionContext, Executi @DuckTyped(shape = "CompletableFuture | ") protected Object fetchField(ExecutionContext executionContext, ExecutionStrategyParameters parameters) { MergedField field = parameters.getField(); - GraphQLObjectType parentType = (GraphQLObjectType) parameters.getExecutionStepInfo().getUnwrappedNonNullType(); + GraphQLObjectType parentType = parameters.getExecutionStepInfo().getUnwrappedNonNullTypeAs(); GraphQLFieldDefinition fieldDef = getFieldDef(executionContext.getGraphQLSchema(), parentType, field.getSingleField()); return fetchField(fieldDef, executionContext, parameters); } @@ -408,7 +408,7 @@ private Object fetchField(GraphQLFieldDefinition fieldDef, ExecutionContext exec } MergedField field = parameters.getField(); - GraphQLObjectType parentType = (GraphQLObjectType) parameters.getExecutionStepInfo().getUnwrappedNonNullType(); + GraphQLObjectType parentType = parameters.getExecutionStepInfo().getUnwrappedNonNullTypeAs(); // if the DF (like PropertyDataFetcher) does not use the arguments or execution step info then dont build any @@ -615,13 +615,13 @@ protected FieldValueInfo completeField(ExecutionContext executionContext, executionContext.throwIfCancelled(); Field field = parameters.getField().getSingleField(); - GraphQLObjectType parentType = (GraphQLObjectType) parameters.getExecutionStepInfo().getUnwrappedNonNullType(); + GraphQLObjectType parentType = parameters.getExecutionStepInfo().getUnwrappedNonNullTypeAs(); GraphQLFieldDefinition fieldDef = getFieldDef(executionContext.getGraphQLSchema(), parentType, field); return completeField(fieldDef, executionContext, parameters, fetchedValue); } private FieldValueInfo completeField(GraphQLFieldDefinition fieldDef, ExecutionContext executionContext, ExecutionStrategyParameters parameters, Object fetchedValue) { - GraphQLObjectType parentType = (GraphQLObjectType) parameters.getExecutionStepInfo().getUnwrappedNonNullType(); + GraphQLObjectType parentType = parameters.getExecutionStepInfo().getUnwrappedNonNullTypeAs(); ExecutionStepInfo executionStepInfo = createExecutionStepInfo(executionContext, parameters, fieldDef, parentType); Instrumentation instrumentation = executionContext.getInstrumentation(); @@ -1008,7 +1008,7 @@ private boolean incrementAndCheckMaxNodesExceeded(ExecutionContext executionCont * @return a {@link GraphQLFieldDefinition} */ protected GraphQLFieldDefinition getFieldDef(ExecutionContext executionContext, ExecutionStrategyParameters parameters, Field field) { - GraphQLObjectType parentType = (GraphQLObjectType) parameters.getExecutionStepInfo().getUnwrappedNonNullType(); + GraphQLObjectType parentType = parameters.getExecutionStepInfo().getUnwrappedNonNullTypeAs(); return getFieldDef(executionContext.getGraphQLSchema(), parentType, field); } diff --git a/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java b/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java index 45e2192248..d2da978471 100644 --- a/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java +++ b/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java @@ -226,7 +226,7 @@ private ExecutionStrategyParameters firstFieldOfSubscriptionSelection(ExecutionC private ExecutionStepInfo createSubscribedFieldStepInfo(ExecutionContext executionContext, ExecutionStrategyParameters parameters) { Field field = parameters.getField().getSingleField(); - GraphQLObjectType parentType = (GraphQLObjectType) parameters.getExecutionStepInfo().getUnwrappedNonNullType(); + GraphQLObjectType parentType = parameters.getExecutionStepInfo().getUnwrappedNonNullTypeAs(); GraphQLFieldDefinition fieldDef = getFieldDef(executionContext.getGraphQLSchema(), parentType, field); return createExecutionStepInfo(executionContext, parameters, fieldDef, parentType); } diff --git a/src/main/java/graphql/schema/GraphQLTypeUtil.java b/src/main/java/graphql/schema/GraphQLTypeUtil.java index c2a44d641c..af649ff5fc 100644 --- a/src/main/java/graphql/schema/GraphQLTypeUtil.java +++ b/src/main/java/graphql/schema/GraphQLTypeUtil.java @@ -219,15 +219,19 @@ private static GraphQLType unwrapAllImpl(GraphQLType type) { /** - * Unwraps all non nullable layers of the type until it reaches a type that is not {@link GraphQLNonNull} + * Unwraps all non-nullable layers of the type until it reaches a type that is not {@link GraphQLNonNull} * * @param type the type to unwrap * * @return the underlying type that is not {@link GraphQLNonNull} */ public static GraphQLType unwrapNonNull(GraphQLType type) { + // nominally its illegal to have a type that is a non null wrapping a non-null + // but the code is like this just in case and anyway it has to do 1 non-null check + // so this works even if it wont really loop while (isNonNull(type)) { - type = unwrapOne(type); + // is cheaper doing this direct rather than calling #unwrapOne + type = ((GraphQLNonNull) type).getWrappedType(); } return type; } diff --git a/src/test/groovy/graphql/schema/GraphQLTypeUtilTest.groovy b/src/test/groovy/graphql/schema/GraphQLTypeUtilTest.groovy index 39763a0b0d..a2d23ac6a8 100644 --- a/src/test/groovy/graphql/schema/GraphQLTypeUtilTest.groovy +++ b/src/test/groovy/graphql/schema/GraphQLTypeUtilTest.groovy @@ -6,7 +6,7 @@ import static graphql.Scalars.GraphQLString import static graphql.schema.GraphQLList.list import static graphql.schema.GraphQLNonNull.nonNull import static graphql.schema.GraphQLObjectType.newObject -import static graphql.schema.GraphQLTypeReference.* +import static graphql.schema.GraphQLTypeReference.typeRef class GraphQLTypeUtilTest extends Specification { @@ -205,4 +205,32 @@ class GraphQLTypeUtilTest extends Specification { then: !GraphQLTypeUtil.isInput(type) } + + def "can unwrap non null-ness"() { + + when: + def type = GraphQLTypeUtil.unwrapNonNull(nonNull(GraphQLString)) + + then: + (type as GraphQLNamedType).getName() == "String" + + when: + type = GraphQLTypeUtil.unwrapNonNull(nonNull(list(GraphQLString))) + + then: + type instanceof GraphQLList + + when: + type = GraphQLTypeUtil.unwrapNonNull(list(GraphQLString)) + + then: + type instanceof GraphQLList + + when: + type = GraphQLTypeUtil.unwrapNonNull(GraphQLString) + + then: + (type as GraphQLNamedType).getName() == "String" + + } } From 4dc1f344b641c212f76617d3b02646fdc631c9e0 Mon Sep 17 00:00:00 2001 From: bbaker Date: Fri, 25 Jul 2025 17:02:25 +1000 Subject: [PATCH 02/21] A smidge faster unwrap non-null - updated to only do 1 check --- src/main/java/graphql/schema/GraphQLNonNull.java | 4 ++-- src/main/java/graphql/schema/GraphQLTypeUtil.java | 14 +++++++------- .../graphql/schema/GraphQLTypeUtilTest.groovy | 6 +++--- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/main/java/graphql/schema/GraphQLNonNull.java b/src/main/java/graphql/schema/GraphQLNonNull.java index 12f131b428..6de1ba61d3 100644 --- a/src/main/java/graphql/schema/GraphQLNonNull.java +++ b/src/main/java/graphql/schema/GraphQLNonNull.java @@ -46,8 +46,8 @@ public GraphQLNonNull(GraphQLType wrappedType) { } private void assertNonNullWrapping(GraphQLType wrappedType) { - assertTrue(!GraphQLTypeUtil.isNonNull(wrappedType), - "A non null type cannot wrap an existing non null type '%s'", GraphQLTypeUtil.simplePrint(wrappedType)); + assertTrue(!GraphQLTypeUtil.isNonNull(wrappedType), () -> + String.format("A non null type cannot wrap an existing non null type '%s'", GraphQLTypeUtil.simplePrint(wrappedType))); } @Override diff --git a/src/main/java/graphql/schema/GraphQLTypeUtil.java b/src/main/java/graphql/schema/GraphQLTypeUtil.java index af649ff5fc..ef933eb291 100644 --- a/src/main/java/graphql/schema/GraphQLTypeUtil.java +++ b/src/main/java/graphql/schema/GraphQLTypeUtil.java @@ -219,17 +219,17 @@ private static GraphQLType unwrapAllImpl(GraphQLType type) { /** - * Unwraps all non-nullable layers of the type until it reaches a type that is not {@link GraphQLNonNull} + * Unwraps a single non-nullable layer of the type if its present. Note there can + * only ever be one non-nullable wrapping of a type and this is enforced by {@link GraphQLNonNull} * * @param type the type to unwrap * * @return the underlying type that is not {@link GraphQLNonNull} */ public static GraphQLType unwrapNonNull(GraphQLType type) { - // nominally its illegal to have a type that is a non null wrapping a non-null - // but the code is like this just in case and anyway it has to do 1 non-null check - // so this works even if it wont really loop - while (isNonNull(type)) { + // its illegal to have a type that is a non-null wrapping a non-null type + // and GraphQLNonNull has code that prevents it so we can just check once during the unwrapping + if (isNonNull(type)) { // is cheaper doing this direct rather than calling #unwrapOne type = ((GraphQLNonNull) type).getWrappedType(); } @@ -237,8 +237,8 @@ public static GraphQLType unwrapNonNull(GraphQLType type) { } /** - * Unwraps all non nullable layers of the type until it reaches a type that is not {@link GraphQLNonNull} - * and then cast to the target type. + * Unwraps a single non-nullable layer of the type if its present and then cast to the target type. Note there can + * only ever be one non-nullable wrapping of a type and this is enforced by {@link GraphQLNonNull} * * @param type the type to unwrap * @param for two diff --git a/src/test/groovy/graphql/schema/GraphQLTypeUtilTest.groovy b/src/test/groovy/graphql/schema/GraphQLTypeUtilTest.groovy index a2d23ac6a8..bc8a08aff1 100644 --- a/src/test/groovy/graphql/schema/GraphQLTypeUtilTest.groovy +++ b/src/test/groovy/graphql/schema/GraphQLTypeUtilTest.groovy @@ -215,19 +215,19 @@ class GraphQLTypeUtilTest extends Specification { (type as GraphQLNamedType).getName() == "String" when: - type = GraphQLTypeUtil.unwrapNonNull(nonNull(list(GraphQLString))) + type = GraphQLTypeUtil.unwrapNonNull(nonNull(list(GraphQLString))) then: type instanceof GraphQLList when: - type = GraphQLTypeUtil.unwrapNonNull(list(GraphQLString)) + type = GraphQLTypeUtil.unwrapNonNull(list(GraphQLString)) then: type instanceof GraphQLList when: - type = GraphQLTypeUtil.unwrapNonNull(GraphQLString) + type = GraphQLTypeUtil.unwrapNonNull(GraphQLString) then: (type as GraphQLNamedType).getName() == "String" From 7e0a66ef021ce4ec27cfc53515a82c173efd6b99 Mon Sep 17 00:00:00 2001 From: bbaker Date: Fri, 25 Jul 2025 17:12:36 +1000 Subject: [PATCH 03/21] A smidge faster unwrap non-null - asssert tweak --- src/main/java/graphql/schema/GraphQLNonNull.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/graphql/schema/GraphQLNonNull.java b/src/main/java/graphql/schema/GraphQLNonNull.java index 6de1ba61d3..44762d1017 100644 --- a/src/main/java/graphql/schema/GraphQLNonNull.java +++ b/src/main/java/graphql/schema/GraphQLNonNull.java @@ -47,7 +47,7 @@ public GraphQLNonNull(GraphQLType wrappedType) { private void assertNonNullWrapping(GraphQLType wrappedType) { assertTrue(!GraphQLTypeUtil.isNonNull(wrappedType), () -> - String.format("A non null type cannot wrap an existing non null type '%s'", GraphQLTypeUtil.simplePrint(wrappedType))); + "A non null type cannot wrap an existing non null type"); } @Override From b581f846cf72ed1a94a315f5e54c0dd99a79349a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 28 Jul 2025 19:04:52 +0000 Subject: [PATCH 04/21] Bump io.projectreactor:reactor-core from 3.7.7 to 3.7.8 Bumps [io.projectreactor:reactor-core](https://github.com/reactor/reactor-core) from 3.7.7 to 3.7.8. - [Release notes](https://github.com/reactor/reactor-core/releases) - [Commits](https://github.com/reactor/reactor-core/compare/v3.7.7...v3.7.8) --- updated-dependencies: - dependency-name: io.projectreactor:reactor-core dependency-version: 3.7.8 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 58fb67f900..0ecf97a0b5 100644 --- a/build.gradle +++ b/build.gradle @@ -140,7 +140,7 @@ dependencies { testImplementation 'org.reactivestreams:reactive-streams-tck:' + reactiveStreamsVersion testImplementation "io.reactivex.rxjava2:rxjava:2.2.21" - testImplementation "io.projectreactor:reactor-core:3.7.7" + testImplementation "io.projectreactor:reactor-core:3.7.8" testImplementation 'org.testng:testng:7.11.0' // use for reactive streams test inheritance testImplementation "com.tngtech.archunit:archunit-junit5:1.4.1" From b72999e032613e13cd62d0d849faac2031810e17 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 28 Jul 2025 19:06:08 +0000 Subject: [PATCH 05/21] Bump com.graphql-java:java-dataloader from 5.0.1 to 5.0.2 Bumps [com.graphql-java:java-dataloader](https://github.com/graphql-java/java-dataloader) from 5.0.1 to 5.0.2. - [Release notes](https://github.com/graphql-java/java-dataloader/releases) - [Commits](https://github.com/graphql-java/java-dataloader/compare/v5.0.1...v5.0.2) --- updated-dependencies: - dependency-name: com.graphql-java:java-dataloader dependency-version: 5.0.2 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 58fb67f900..933089c726 100644 --- a/build.gradle +++ b/build.gradle @@ -119,7 +119,7 @@ jar { } dependencies { - api 'com.graphql-java:java-dataloader:5.0.1' + api 'com.graphql-java:java-dataloader:5.0.2' api 'org.reactivestreams:reactive-streams:' + reactiveStreamsVersion api "org.jspecify:jspecify:1.0.0" From 5a90844ba5ae906aef9944b1ff97531134bfefae Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 28 Jul 2025 19:06:35 +0000 Subject: [PATCH 06/21] Bump com.fasterxml.jackson.core:jackson-databind from 2.19.1 to 2.19.2 Bumps [com.fasterxml.jackson.core:jackson-databind](https://github.com/FasterXML/jackson) from 2.19.1 to 2.19.2. - [Commits](https://github.com/FasterXML/jackson/commits) --- updated-dependencies: - dependency-name: com.fasterxml.jackson.core:jackson-databind dependency-version: 2.19.2 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 58fb67f900..f418e71249 100644 --- a/build.gradle +++ b/build.gradle @@ -134,7 +134,7 @@ dependencies { testImplementation 'org.apache.groovy:groovy-json:4.0.27' testImplementation 'com.google.code.gson:gson:2.13.1' testImplementation 'org.eclipse.jetty:jetty-server:11.0.25' - testImplementation 'com.fasterxml.jackson.core:jackson-databind:2.19.1' + testImplementation 'com.fasterxml.jackson.core:jackson-databind:2.19.2' testImplementation 'org.awaitility:awaitility-groovy:4.3.0' testImplementation 'com.github.javafaker:javafaker:1.0.2' From bee9de0ffbc3c999d999877e4d1075fe83744761 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 28 Jul 2025 19:09:50 +0000 Subject: [PATCH 07/21] Bump org.apache.groovy:groovy from 4.0.27 to 4.0.28 Bumps [org.apache.groovy:groovy](https://github.com/apache/groovy) from 4.0.27 to 4.0.28. - [Commits](https://github.com/apache/groovy/commits) --- updated-dependencies: - dependency-name: org.apache.groovy:groovy dependency-version: 4.0.28 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- build.gradle | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/build.gradle b/build.gradle index 58fb67f900..8ec43c1b11 100644 --- a/build.gradle +++ b/build.gradle @@ -130,8 +130,8 @@ dependencies { testImplementation 'org.spockframework:spock-core:2.3-groovy-4.0' testImplementation 'net.bytebuddy:byte-buddy:1.17.6' testImplementation 'org.objenesis:objenesis:3.4' - testImplementation 'org.apache.groovy:groovy:4.0.27"' - testImplementation 'org.apache.groovy:groovy-json:4.0.27' + testImplementation 'org.apache.groovy:groovy:4.0.28"' + testImplementation 'org.apache.groovy:groovy-json:4.0.28' testImplementation 'com.google.code.gson:gson:2.13.1' testImplementation 'org.eclipse.jetty:jetty-server:11.0.25' testImplementation 'com.fasterxml.jackson.core:jackson-databind:2.19.1' From 08429c69a3a31ef74271a8be29b3854335699b2d Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 28 Jul 2025 20:56:28 +0000 Subject: [PATCH 08/21] Bump com.google.errorprone:error_prone_core from 2.40.0 to 2.41.0 Bumps [com.google.errorprone:error_prone_core](https://github.com/google/error-prone) from 2.40.0 to 2.41.0. - [Release notes](https://github.com/google/error-prone/releases) - [Commits](https://github.com/google/error-prone/compare/v2.40.0...v2.41.0) --- updated-dependencies: - dependency-name: com.google.errorprone:error_prone_core dependency-version: 2.41.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 58fb67f900..0e5bb5bda9 100644 --- a/build.gradle +++ b/build.gradle @@ -153,7 +153,7 @@ dependencies { jmhAnnotationProcessor 'org.openjdk.jmh:jmh-generator-annprocess:1.37' errorprone 'com.uber.nullaway:nullaway:0.12.7' - errorprone 'com.google.errorprone:error_prone_core:2.40.0' + errorprone 'com.google.errorprone:error_prone_core:2.41.0' // just tests - no Kotlin otherwise testCompileOnly 'org.jetbrains.kotlin:kotlin-stdlib-jdk8' From 23f078da4f181751f972d6ce071093fa8e661df7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Mon, 28 Jul 2025 21:24:04 +0000 Subject: [PATCH 09/21] Add performance results for commit db9f64ea67056746df85dc2901f82970e1dcc487 --- ...7056746df85dc2901f82970e1dcc487-jdk17.json | 1279 +++++++++++++++++ 1 file changed, 1279 insertions(+) create mode 100644 performance-results/2025-07-28T21:23:46Z-db9f64ea67056746df85dc2901f82970e1dcc487-jdk17.json diff --git a/performance-results/2025-07-28T21:23:46Z-db9f64ea67056746df85dc2901f82970e1dcc487-jdk17.json b/performance-results/2025-07-28T21:23:46Z-db9f64ea67056746df85dc2901f82970e1dcc487-jdk17.json new file mode 100644 index 0000000000..f4502dfb3e --- /dev/null +++ b/performance-results/2025-07-28T21:23:46Z-db9f64ea67056746df85dc2901f82970e1dcc487-jdk17.json @@ -0,0 +1,1279 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "5" + }, + "primaryMetric" : { + "score" : 3.331643164772836, + "scoreError" : 0.051247818181749914, + "scoreConfidence" : [ + 3.280395346591086, + 3.382890982954586 + ], + "scorePercentiles" : { + "0.0" : 3.3206381936419542, + "50.0" : 3.333204573495289, + "90.0" : 3.3395253184588114, + "95.0" : 3.3395253184588114, + "99.0" : 3.3395253184588114, + "99.9" : 3.3395253184588114, + "99.99" : 3.3395253184588114, + "99.999" : 3.3395253184588114, + "99.9999" : 3.3395253184588114, + "100.0" : 3.3395253184588114 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.333739461894395, + 3.3326696850961826 + ], + [ + 3.3206381936419542, + 3.3395253184588114 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "10" + }, + "primaryMetric" : { + "score" : 1.6818165999056673, + "scoreError" : 0.0268110540331406, + "scoreConfidence" : [ + 1.6550055458725268, + 1.7086276539388079 + ], + "scorePercentiles" : { + "0.0" : 1.676581598598524, + "50.0" : 1.6820594087665177, + "90.0" : 1.68656598349111, + "95.0" : 1.68656598349111, + "99.0" : 1.68656598349111, + "99.9" : 1.68656598349111, + "99.99" : 1.68656598349111, + "99.999" : 1.68656598349111, + "99.9999" : 1.68656598349111, + "100.0" : 1.68656598349111 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.6829436628482946, + 1.68656598349111 + ], + [ + 1.676581598598524, + 1.6811751546847407 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "20" + }, + "primaryMetric" : { + "score" : 0.8451206185553661, + "scoreError" : 0.028158247701432854, + "scoreConfidence" : [ + 0.8169623708539333, + 0.873278866256799 + ], + "scorePercentiles" : { + "0.0" : 0.839166147307282, + "50.0" : 0.8462662582459716, + "90.0" : 0.8487838104222392, + "95.0" : 0.8487838104222392, + "99.0" : 0.8487838104222392, + "99.9" : 0.8487838104222392, + "99.99" : 0.8487838104222392, + "99.999" : 0.8487838104222392, + "99.9999" : 0.8487838104222392, + "100.0" : 0.8487838104222392 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.839166147307282, + 0.8487838104222392 + ], + [ + 0.844613342854886, + 0.8479191736370572 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 15.991852858006974, + "scoreError" : 0.2893930297259564, + "scoreConfidence" : [ + 15.702459828281018, + 16.28124588773293 + ], + "scorePercentiles" : { + "0.0" : 15.825655653459275, + "50.0" : 15.994339276151408, + "90.0" : 16.131730692048308, + "95.0" : 16.131730692048308, + "99.0" : 16.131730692048308, + "99.9" : 16.131730692048308, + "99.99" : 16.131730692048308, + "99.999" : 16.131730692048308, + "99.9999" : 16.131730692048308, + "100.0" : 16.131730692048308 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 16.131730692048308, + 15.825655653459275, + 15.987034413792097 + ], + [ + 16.055992516436707, + 16.00164413851072, + 15.949059733794734 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput_getImmediateFields", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2635.2188133655827, + "scoreError" : 121.33905865655838, + "scoreConfidence" : [ + 2513.8797547090244, + 2756.557872022141 + ], + "scorePercentiles" : { + "0.0" : 2587.552765539256, + "50.0" : 2625.0432501873474, + "90.0" : 2686.5489180150803, + "95.0" : 2686.5489180150803, + "99.0" : 2686.5489180150803, + "99.9" : 2686.5489180150803, + "99.99" : 2686.5489180150803, + "99.999" : 2686.5489180150803, + "99.9999" : 2686.5489180150803, + "100.0" : 2686.5489180150803 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2609.501709446339, + 2587.552765539256, + 2600.9857496997092 + ], + [ + 2686.5489180150803, + 2640.584790928356, + 2686.138946564755 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 75121.99264019799, + "scoreError" : 2899.2101794917526, + "scoreConfidence" : [ + 72222.78246070624, + 78021.20281968974 + ], + "scorePercentiles" : { + "0.0" : 74003.79761382437, + "50.0" : 75206.79416276628, + "90.0" : 76205.35181396423, + "95.0" : 76205.35181396423, + "99.0" : 76205.35181396423, + "99.9" : 76205.35181396423, + "99.99" : 76205.35181396423, + "99.999" : 76205.35181396423, + "99.9999" : 76205.35181396423, + "100.0" : 76205.35181396423 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 76038.22467289977, + 75900.37684015009, + 76205.35181396423 + ], + [ + 74513.21148538248, + 74070.99341496703, + 74003.79761382437 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 348.31523010548176, + "scoreError" : 14.34267483846891, + "scoreConfidence" : [ + 333.97255526701286, + 362.65790494395065 + ], + "scorePercentiles" : { + "0.0" : 342.2807512258495, + "50.0" : 348.4780580738318, + "90.0" : 353.8869869384937, + "95.0" : 353.8869869384937, + "99.0" : 353.8869869384937, + "99.9" : 353.8869869384937, + "99.99" : 353.8869869384937, + "99.999" : 353.8869869384937, + "99.9999" : 353.8869869384937, + "100.0" : 353.8869869384937 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 353.56004531067157, + 350.67953479823257, + 353.8869869384937 + ], + [ + 346.276581349431, + 343.2074810102121, + 342.2807512258495 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 113.41423355966064, + "scoreError" : 3.66211911767386, + "scoreConfidence" : [ + 109.75211444198679, + 117.0763526773345 + ], + "scorePercentiles" : { + "0.0" : 112.14262805577192, + "50.0" : 113.37295573035257, + "90.0" : 114.79595469387294, + "95.0" : 114.79595469387294, + "99.0" : 114.79595469387294, + "99.9" : 114.79595469387294, + "99.99" : 114.79595469387294, + "99.999" : 114.79595469387294, + "99.9999" : 114.79595469387294, + "100.0" : 114.79595469387294 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 112.14262805577192, + 112.3311606901494, + 112.21156920423408 + ], + [ + 114.41475077055574, + 114.58933794337959, + 114.79595469387294 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.06229997289667589, + "scoreError" : 8.386683911875162E-4, + "scoreConfidence" : [ + 0.061461304505488375, + 0.06313864128786341 + ], + "scorePercentiles" : { + "0.0" : 0.061992412597946835, + "50.0" : 0.06227300967056189, + "90.0" : 0.06266411988745668, + "95.0" : 0.06266411988745668, + "99.0" : 0.06266411988745668, + "99.9" : 0.06266411988745668, + "99.99" : 0.06266411988745668, + "99.999" : 0.06266411988745668, + "99.9999" : 0.06266411988745668, + "100.0" : 0.06266411988745668 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.06266411988745668, + 0.061992412597946835, + 0.06211519034249723 + ], + [ + 0.062008153430229675, + 0.06258913212329839, + 0.06243082899862654 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime_getImmediateFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 3.7806239285135683E-4, + "scoreError" : 3.299084706897687E-5, + "scoreConfidence" : [ + 3.4507154578238E-4, + 4.110532399203337E-4 + ], + "scorePercentiles" : { + "0.0" : 3.643146844686191E-4, + "50.0" : 3.7814691054728936E-4, + "90.0" : 3.9005836309059924E-4, + "95.0" : 3.9005836309059924E-4, + "99.0" : 3.9005836309059924E-4, + "99.9" : 3.9005836309059924E-4, + "99.99" : 3.9005836309059924E-4, + "99.999" : 3.9005836309059924E-4, + "99.9999" : 3.9005836309059924E-4, + "100.0" : 3.9005836309059924E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.8585234062375913E-4, + 3.9005836309059924E-4, + 3.8978859857380344E-4 + ], + [ + 3.6791888988054047E-4, + 3.643146844686191E-4, + 3.7044148047081954E-4 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DataLoaderPerformance.executeRequestWithDataLoaders", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.12713244157367373, + "scoreError" : 0.0046481853466590435, + "scoreConfidence" : [ + 0.12248425622701468, + 0.13178062692033277 + ], + "scorePercentiles" : { + "0.0" : 0.12543768301493924, + "50.0" : 0.12718442822571785, + "90.0" : 0.12886493870003352, + "95.0" : 0.12886493870003352, + "99.0" : 0.12886493870003352, + "99.9" : 0.12886493870003352, + "99.99" : 0.12886493870003352, + "99.999" : 0.12886493870003352, + "99.9999" : 0.12886493870003352, + "100.0" : 0.12886493870003352 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.12843506913513653, + 0.12859790914702365, + 0.12886493870003352 + ], + [ + 0.12593378731629917, + 0.12543768301493924, + 0.12552526212861034 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.013143034323990497, + "scoreError" : 4.8252151400674344E-4, + "scoreConfidence" : [ + 0.012660512809983754, + 0.01362555583799724 + ], + "scorePercentiles" : { + "0.0" : 0.012943142682783194, + "50.0" : 0.013151494756082769, + "90.0" : 0.013377522964142147, + "95.0" : 0.013377522964142147, + "99.0" : 0.013377522964142147, + "99.9" : 0.013377522964142147, + "99.99" : 0.013377522964142147, + "99.999" : 0.013377522964142147, + "99.9999" : 0.013377522964142147, + "100.0" : 0.013377522964142147 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.013377522964142147, + 0.013273398080159704, + 0.013189463002919989 + ], + [ + 0.01311352650924555, + 0.012961152704692384, + 0.012943142682783194 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF2Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 1.0189571718304444, + "scoreError" : 0.05048367241199941, + "scoreConfidence" : [ + 0.9684734994184451, + 1.069440844242444 + ], + "scorePercentiles" : { + "0.0" : 1.002440727947073, + "50.0" : 1.0178045820635433, + "90.0" : 1.0372601136811535, + "95.0" : 1.0372601136811535, + "99.0" : 1.0372601136811535, + "99.9" : 1.0372601136811535, + "99.99" : 1.0372601136811535, + "99.999" : 1.0372601136811535, + "99.9999" : 1.0372601136811535, + "100.0" : 1.0372601136811535 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 1.0327662514716514, + 1.0372601136811535, + 1.035983271418212 + ], + [ + 1.002449753809142, + 1.002440727947073, + 1.0028429126554352 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "2" + }, + "primaryMetric" : { + "score" : 0.01095586365769796, + "scoreError" : 4.40702445061621E-4, + "scoreConfidence" : [ + 0.01051516121263634, + 0.01139656610275958 + ], + "scorePercentiles" : { + "0.0" : 0.010765138448786264, + "50.0" : 0.010970742090528885, + "90.0" : 0.011130419814617772, + "95.0" : 0.011130419814617772, + "99.0" : 0.011130419814617772, + "99.9" : 0.011130419814617772, + "99.99" : 0.011130419814617772, + "99.999" : 0.011130419814617772, + "99.9999" : 0.011130419814617772, + "100.0" : 0.011130419814617772 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.011098440128738694, + 0.0110465389135833, + 0.011130419814617772 + ], + [ + 0.010799699372987264, + 0.010765138448786264, + 0.010894945267474468 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "10" + }, + "primaryMetric" : { + "score" : 3.2042947257471455, + "scoreError" : 0.2941758148099074, + "scoreConfidence" : [ + 2.9101189109372383, + 3.4984705405570526 + ], + "scorePercentiles" : { + "0.0" : 3.103877549348231, + "50.0" : 3.1971679404254294, + "90.0" : 3.321170586321381, + "95.0" : 3.321170586321381, + "99.0" : 3.321170586321381, + "99.9" : 3.321170586321381, + "99.99" : 3.321170586321381, + "99.999" : 3.321170586321381, + "99.9999" : 3.321170586321381, + "100.0" : 3.321170586321381 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.103877549348231, + 3.1202652407985028, + 3.1048289894475483 + ], + [ + 3.274070640052356, + 3.321170586321381, + 3.3015553485148517 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2.8547099613500584, + "scoreError" : 0.03933021225603408, + "scoreConfidence" : [ + 2.815379749094024, + 2.8940401736060926 + ], + "scorePercentiles" : { + "0.0" : 2.8406476160181766, + "50.0" : 2.8517831442122312, + "90.0" : 2.881364099106886, + "95.0" : 2.881364099106886, + "99.0" : 2.881364099106886, + "99.9" : 2.881364099106886, + "99.99" : 2.881364099106886, + "99.999" : 2.881364099106886, + "99.9999" : 2.881364099106886, + "100.0" : 2.881364099106886 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.8478931976082005, + 2.8547885669426205, + 2.8406476160181766 + ], + [ + 2.8493563934472936, + 2.854209894977169, + 2.881364099106886 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkDeepAbstractConcrete", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.1756349745244731, + "scoreError" : 0.004332128107500396, + "scoreConfidence" : [ + 0.17130284641697271, + 0.1799671026319735 + ], + "scorePercentiles" : { + "0.0" : 0.17369850514138818, + "50.0" : 0.1761021839924573, + "90.0" : 0.1772355841943888, + "95.0" : 0.1772355841943888, + "99.0" : 0.1772355841943888, + "99.9" : 0.1772355841943888, + "99.99" : 0.1772355841943888, + "99.999" : 0.1772355841943888, + "99.9999" : 0.1772355841943888, + "100.0" : 0.1772355841943888 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.1737629930670188, + 0.17593057899829354, + 0.17369850514138818 + ], + [ + 0.17690839675912823, + 0.1772355841943888, + 0.17627378898662108 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.33801709073173153, + "scoreError" : 0.00600661825870432, + "scoreConfidence" : [ + 0.33201047247302723, + 0.34402370899043583 + ], + "scorePercentiles" : { + "0.0" : 0.33513639282841823, + "50.0" : 0.3379684057409665, + "90.0" : 0.34079614309569245, + "95.0" : 0.34079614309569245, + "99.0" : 0.34079614309569245, + "99.9" : 0.34079614309569245, + "99.99" : 0.34079614309569245, + "99.999" : 0.34079614309569245, + "99.9999" : 0.34079614309569245, + "100.0" : 0.34079614309569245 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.34079614309569245, + 0.3371740507434506, + 0.33979485769622836 + ], + [ + 0.33643833928811734, + 0.33513639282841823, + 0.3387627607384824 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.14765633204777087, + "scoreError" : 0.011111430803548622, + "scoreConfidence" : [ + 0.13654490124422225, + 0.1587677628513195 + ], + "scorePercentiles" : { + "0.0" : 0.14350285903911833, + "50.0" : 0.14749487041746023, + "90.0" : 0.15259609337137975, + "95.0" : 0.15259609337137975, + "99.0" : 0.15259609337137975, + "99.9" : 0.15259609337137975, + "99.99" : 0.15259609337137975, + "99.999" : 0.15259609337137975, + "99.9999" : 0.15259609337137975, + "100.0" : 0.15259609337137975 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.14350285903911833, + 0.1445069205080778, + 0.14435569037892457 + ], + [ + 0.15048282032684263, + 0.15049360866228234, + 0.15259609337137975 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.4096547899709148, + "scoreError" : 0.012798631943481974, + "scoreConfidence" : [ + 0.39685615802743285, + 0.4224534219143968 + ], + "scorePercentiles" : { + "0.0" : 0.40474324971669096, + "50.0" : 0.40932563235845926, + "90.0" : 0.4151857947770489, + "95.0" : 0.4151857947770489, + "99.0" : 0.4151857947770489, + "99.9" : 0.4151857947770489, + "99.99" : 0.4151857947770489, + "99.999" : 0.4151857947770489, + "99.9999" : 0.4151857947770489, + "100.0" : 0.4151857947770489 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.4086183155185094, + 0.40474324971669096, + 0.40476389614279357 + ], + [ + 0.4100329491984091, + 0.4151857947770489, + 0.4145845344720368 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.15859302569501932, + "scoreError" : 0.008073820047993934, + "scoreConfidence" : [ + 0.1505192056470254, + 0.16666684574301324 + ], + "scorePercentiles" : { + "0.0" : 0.1556597189465164, + "50.0" : 0.15854398725939578, + "90.0" : 0.16206386583152368, + "95.0" : 0.16206386583152368, + "99.0" : 0.16206386583152368, + "99.9" : 0.16206386583152368, + "99.99" : 0.16206386583152368, + "99.999" : 0.16206386583152368, + "99.9999" : 0.16206386583152368, + "100.0" : 0.16206386583152368 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.16206386583152368, + 0.16082867278341562, + 0.16062231524759474 + ], + [ + 0.1564656592711968, + 0.1556597189465164, + 0.1559179220898687 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkRepeatedFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.046799052754565175, + "scoreError" : 7.884140873007828E-4, + "scoreConfidence" : [ + 0.04601063866726439, + 0.04758746684186596 + ], + "scorePercentiles" : { + "0.0" : 0.04639564129794332, + "50.0" : 0.04679468600142449, + "90.0" : 0.04713802923929746, + "95.0" : 0.04713802923929746, + "99.0" : 0.04713802923929746, + "99.9" : 0.04713802923929746, + "99.99" : 0.04713802923929746, + "99.999" : 0.04713802923929746, + "99.9999" : 0.04713802923929746, + "100.0" : 0.04713802923929746 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.04713802923929746, + 0.04693714135383518, + 0.04639564129794332 + ], + [ + 0.04702837487302483, + 0.04665223064901379, + 0.04664289911427652 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 8775559.738631895, + "scoreError" : 269473.8422176585, + "scoreConfidence" : [ + 8506085.896414237, + 9045033.580849553 + ], + "scorePercentiles" : { + "0.0" : 8678199.808326107, + "50.0" : 8781481.356036095, + "90.0" : 8866652.171985816, + "95.0" : 8866652.171985816, + "99.0" : 8866652.171985816, + "99.9" : 8866652.171985816, + "99.99" : 8866652.171985816, + "99.999" : 8866652.171985816, + "99.9999" : 8866652.171985816, + "100.0" : 8866652.171985816 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 8704656.553524803, + 8678199.808326107, + 8681924.269965278 + ], + [ + 8858306.158547387, + 8866652.171985816, + 8863619.469441984 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + + From d079fb1cd9673555011ea17bf5309237470e31a5 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 30 Jul 2025 22:03:23 +0000 Subject: [PATCH 10/21] Add performance results for commit 80f35b3b901ac8dd68ab8b45afabc0db3087a5b6 --- ...01ac8dd68ab8b45afabc0db3087a5b6-jdk17.json | 1279 +++++++++++++++++ 1 file changed, 1279 insertions(+) create mode 100644 performance-results/2025-07-30T22:03:05Z-80f35b3b901ac8dd68ab8b45afabc0db3087a5b6-jdk17.json diff --git a/performance-results/2025-07-30T22:03:05Z-80f35b3b901ac8dd68ab8b45afabc0db3087a5b6-jdk17.json b/performance-results/2025-07-30T22:03:05Z-80f35b3b901ac8dd68ab8b45afabc0db3087a5b6-jdk17.json new file mode 100644 index 0000000000..b44612e96a --- /dev/null +++ b/performance-results/2025-07-30T22:03:05Z-80f35b3b901ac8dd68ab8b45afabc0db3087a5b6-jdk17.json @@ -0,0 +1,1279 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "5" + }, + "primaryMetric" : { + "score" : 3.3460800372190596, + "scoreError" : 0.026018905589721572, + "scoreConfidence" : [ + 3.320061131629338, + 3.372098942808781 + ], + "scorePercentiles" : { + "0.0" : 3.3410183864073546, + "50.0" : 3.3465459993581894, + "90.0" : 3.3502097637525043, + "95.0" : 3.3502097637525043, + "99.0" : 3.3502097637525043, + "99.9" : 3.3502097637525043, + "99.99" : 3.3502097637525043, + "99.999" : 3.3502097637525043, + "99.9999" : 3.3502097637525043, + "100.0" : 3.3502097637525043 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.3410183864073546, + 3.3482084996574164 + ], + [ + 3.3448834990589624, + 3.3502097637525043 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "10" + }, + "primaryMetric" : { + "score" : 1.6884764675376813, + "scoreError" : 0.01851244470576729, + "scoreConfidence" : [ + 1.6699640228319141, + 1.7069889122434485 + ], + "scorePercentiles" : { + "0.0" : 1.6845142944551652, + "50.0" : 1.6890237266310426, + "90.0" : 1.691344122433475, + "95.0" : 1.691344122433475, + "99.0" : 1.691344122433475, + "99.9" : 1.691344122433475, + "99.99" : 1.691344122433475, + "99.999" : 1.691344122433475, + "99.9999" : 1.691344122433475, + "100.0" : 1.691344122433475 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.6845142944551652, + 1.6892477336076865 + ], + [ + 1.6887997196543987, + 1.691344122433475 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "20" + }, + "primaryMetric" : { + "score" : 0.8483547677000283, + "scoreError" : 0.009248879937832943, + "scoreConfidence" : [ + 0.8391058877621953, + 0.8576036476378612 + ], + "scorePercentiles" : { + "0.0" : 0.8470417117721241, + "50.0" : 0.8480400135686396, + "90.0" : 0.8502973318907097, + "95.0" : 0.8502973318907097, + "99.0" : 0.8502973318907097, + "99.9" : 0.8502973318907097, + "99.99" : 0.8502973318907097, + "99.999" : 0.8502973318907097, + "99.9999" : 0.8502973318907097, + "100.0" : 0.8502973318907097 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.8485142642745391, + 0.8502973318907097 + ], + [ + 0.84756576286274, + 0.8470417117721241 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 16.11748871557649, + "scoreError" : 0.06158701905901077, + "scoreConfidence" : [ + 16.055901696517477, + 16.1790757346355 + ], + "scorePercentiles" : { + "0.0" : 16.08579749911244, + "50.0" : 16.113787786571887, + "90.0" : 16.147999399668446, + "95.0" : 16.147999399668446, + "99.0" : 16.147999399668446, + "99.9" : 16.147999399668446, + "99.99" : 16.147999399668446, + "99.999" : 16.147999399668446, + "99.9999" : 16.147999399668446, + "100.0" : 16.147999399668446 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 16.11480246676955, + 16.112773106374224, + 16.10745780021079 + ], + [ + 16.147999399668446, + 16.13610202132347, + 16.08579749911244 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput_getImmediateFields", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2727.4950486614894, + "scoreError" : 31.130154912431564, + "scoreConfidence" : [ + 2696.364893749058, + 2758.6252035739208 + ], + "scorePercentiles" : { + "0.0" : 2715.017580095496, + "50.0" : 2727.9003271961824, + "90.0" : 2738.7885308400705, + "95.0" : 2738.7885308400705, + "99.0" : 2738.7885308400705, + "99.9" : 2738.7885308400705, + "99.99" : 2738.7885308400705, + "99.999" : 2738.7885308400705, + "99.9999" : 2738.7885308400705, + "100.0" : 2738.7885308400705 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2715.017580095496, + 2716.996133953458, + 2720.6822170732016 + ], + [ + 2738.7885308400705, + 2738.3673926875476, + 2735.118437319163 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 75520.93425397173, + "scoreError" : 208.36580917073772, + "scoreConfidence" : [ + 75312.568444801, + 75729.30006314247 + ], + "scorePercentiles" : { + "0.0" : 75441.10262054022, + "50.0" : 75506.95709001189, + "90.0" : 75614.04948602953, + "95.0" : 75614.04948602953, + "99.0" : 75614.04948602953, + "99.9" : 75614.04948602953, + "99.99" : 75614.04948602953, + "99.999" : 75614.04948602953, + "99.9999" : 75614.04948602953, + "100.0" : 75614.04948602953 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 75451.72553724766, + 75493.79486898505, + 75441.10262054022 + ], + [ + 75614.04948602953, + 75520.11931103874, + 75604.8136999892 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 356.0250529144755, + "scoreError" : 16.630689264489344, + "scoreConfidence" : [ + 339.3943636499862, + 372.65574217896483 + ], + "scorePercentiles" : { + "0.0" : 350.32916186698924, + "50.0" : 355.9283726253776, + "90.0" : 361.836969519625, + "95.0" : 361.836969519625, + "99.0" : 361.836969519625, + "99.9" : 361.836969519625, + "99.99" : 361.836969519625, + "99.999" : 361.836969519625, + "99.9999" : 361.836969519625, + "100.0" : 361.836969519625 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 350.32916186698924, + 350.8930297205004, + 350.6364150665372 + ], + [ + 360.96371553025483, + 361.49102578294594, + 361.836969519625 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 117.8920167010855, + "scoreError" : 5.543464396779908, + "scoreConfidence" : [ + 112.34855230430558, + 123.4354810978654 + ], + "scorePercentiles" : { + "0.0" : 115.96053380638747, + "50.0" : 117.80244936542726, + "90.0" : 119.91662000747624, + "95.0" : 119.91662000747624, + "99.0" : 119.91662000747624, + "99.9" : 119.91662000747624, + "99.99" : 119.91662000747624, + "99.999" : 119.91662000747624, + "99.9999" : 119.91662000747624, + "100.0" : 119.91662000747624 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 116.33225670228359, + 115.96053380638747, + 116.0157253186122 + ], + [ + 119.91662000747624, + 119.85432234318266, + 119.27264202857093 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.0614265552673224, + "scoreError" : 3.3668008544388516E-4, + "scoreConfidence" : [ + 0.061089875181878514, + 0.06176323535276629 + ], + "scorePercentiles" : { + "0.0" : 0.06129606563486469, + "50.0" : 0.06140238501599983, + "90.0" : 0.06159755376787848, + "95.0" : 0.06159755376787848, + "99.0" : 0.06159755376787848, + "99.9" : 0.06159755376787848, + "99.99" : 0.06159755376787848, + "99.999" : 0.06159755376787848, + "99.9999" : 0.06159755376787848, + "100.0" : 0.06159755376787848 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.06133819969946026, + 0.06129606563486469, + 0.06134081823758174 + ], + [ + 0.06152274246973127, + 0.061463951794417916, + 0.06159755376787848 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime_getImmediateFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 3.6681746603231313E-4, + "scoreError" : 3.989741437255106E-5, + "scoreConfidence" : [ + 3.2692005165976205E-4, + 4.067148804048642E-4 + ], + "scorePercentiles" : { + "0.0" : 3.537229808475251E-4, + "50.0" : 3.666446673142193E-4, + "90.0" : 3.803598765869038E-4, + "95.0" : 3.803598765869038E-4, + "99.0" : 3.803598765869038E-4, + "99.9" : 3.803598765869038E-4, + "99.99" : 3.803598765869038E-4, + "99.999" : 3.803598765869038E-4, + "99.9999" : 3.803598765869038E-4, + "100.0" : 3.803598765869038E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.803598765869038E-4, + 3.793440103911502E-4, + 3.797022554929362E-4 + ], + [ + 3.537229808475251E-4, + 3.538303486380751E-4, + 3.5394532423728837E-4 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DataLoaderPerformance.executeRequestWithDataLoaders", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.1249983755167423, + "scoreError" : 0.0011489724205739774, + "scoreConfidence" : [ + 0.12384940309616832, + 0.12614734793731627 + ], + "scorePercentiles" : { + "0.0" : 0.12447274743589744, + "50.0" : 0.12507293334945305, + "90.0" : 0.12543530287484636, + "95.0" : 0.12543530287484636, + "99.0" : 0.12543530287484636, + "99.9" : 0.12543530287484636, + "99.99" : 0.12543530287484636, + "99.999" : 0.12543530287484636, + "99.9999" : 0.12543530287484636, + "100.0" : 0.12543530287484636 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.12543530287484636, + 0.12529770734610518, + 0.125327495563465 + ], + [ + 0.12484815935280091, + 0.12447274743589744, + 0.12460884052733888 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.013248594903843634, + "scoreError" : 5.094146825521463E-4, + "scoreConfidence" : [ + 0.012739180221291488, + 0.01375800958639578 + ], + "scorePercentiles" : { + "0.0" : 0.013075960317584848, + "50.0" : 0.01325006685660348, + "90.0" : 0.013416597166991343, + "95.0" : 0.013416597166991343, + "99.0" : 0.013416597166991343, + "99.9" : 0.013416597166991343, + "99.99" : 0.013416597166991343, + "99.999" : 0.013416597166991343, + "99.9999" : 0.013416597166991343, + "100.0" : 0.013416597166991343 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.013084574541914617, + 0.013087875810458149, + 0.013075960317584848 + ], + [ + 0.013412257902748812, + 0.013416597166991343, + 0.01341430368336403 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF2Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.9821103882463782, + "scoreError" : 0.08673128197615132, + "scoreConfidence" : [ + 0.8953791062702269, + 1.0688416702225294 + ], + "scorePercentiles" : { + "0.0" : 0.9538307179780638, + "50.0" : 0.9820338022176116, + "90.0" : 1.0107782253891247, + "95.0" : 1.0107782253891247, + "99.0" : 1.0107782253891247, + "99.9" : 1.0107782253891247, + "99.99" : 1.0107782253891247, + "99.999" : 1.0107782253891247, + "99.9999" : 1.0107782253891247, + "100.0" : 1.0107782253891247 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 1.010139483030303, + 1.0101140005050504, + 1.0107782253891247 + ], + [ + 0.9539536039301727, + 0.9538307179780638, + 0.9538462986455551 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "2" + }, + "primaryMetric" : { + "score" : 0.010729451493956557, + "scoreError" : 6.346760668853688E-4, + "scoreConfidence" : [ + 0.010094775427071188, + 0.011364127560841927 + ], + "scorePercentiles" : { + "0.0" : 0.010519571615514731, + "50.0" : 0.01072981262668108, + "90.0" : 0.010937844242804737, + "95.0" : 0.010937844242804737, + "99.0" : 0.010937844242804737, + "99.9" : 0.010937844242804737, + "99.99" : 0.010937844242804737, + "99.999" : 0.010937844242804737, + "99.9999" : 0.010937844242804737, + "100.0" : 0.010937844242804737 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.010937844242804737, + 0.010935829899939855, + 0.010934487524109849 + ], + [ + 0.010523837952117863, + 0.010519571615514731, + 0.01052513772925231 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "10" + }, + "primaryMetric" : { + "score" : 3.1521960089884797, + "scoreError" : 0.18666857592276306, + "scoreConfidence" : [ + 2.965527433065717, + 3.3388645849112426 + ], + "scorePercentiles" : { + "0.0" : 3.0855574713140035, + "50.0" : 3.15077570937262, + "90.0" : 3.217996956241956, + "95.0" : 3.217996956241956, + "99.0" : 3.217996956241956, + "99.9" : 3.217996956241956, + "99.99" : 3.217996956241956, + "99.999" : 3.217996956241956, + "99.9999" : 3.217996956241956, + "100.0" : 3.217996956241956 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.213506692159383, + 3.217996956241956, + 3.206906673076923 + ], + [ + 3.094563515470297, + 3.094644745668317, + 3.0855574713140035 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2.742696288578506, + "scoreError" : 0.11503660288956712, + "scoreConfidence" : [ + 2.627659685688939, + 2.857732891468073 + ], + "scorePercentiles" : { + "0.0" : 2.7040657499324143, + "50.0" : 2.7413798741813262, + "90.0" : 2.785626130362117, + "95.0" : 2.785626130362117, + "99.0" : 2.785626130362117, + "99.9" : 2.785626130362117, + "99.99" : 2.785626130362117, + "99.999" : 2.785626130362117, + "99.9999" : 2.785626130362117, + "100.0" : 2.785626130362117 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.7061974829545457, + 2.7040657499324143, + 2.705816186147186 + ], + [ + 2.785626130362117, + 2.7779099166666668, + 2.776562265408107 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkDeepAbstractConcrete", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.17420262646833398, + "scoreError" : 0.005749665359104493, + "scoreConfidence" : [ + 0.1684529611092295, + 0.17995229182743847 + ], + "scorePercentiles" : { + "0.0" : 0.17168228134388575, + "50.0" : 0.17430648289974532, + "90.0" : 0.1768495236798359, + "95.0" : 0.1768495236798359, + "99.0" : 0.1768495236798359, + "99.9" : 0.1768495236798359, + "99.99" : 0.1768495236798359, + "99.999" : 0.1768495236798359, + "99.9999" : 0.1768495236798359, + "100.0" : 0.1768495236798359 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.1768495236798359, + 0.17562005298187694, + 0.175438542358906 + ], + [ + 0.17317442344058462, + 0.17168228134388575, + 0.17245093500491473 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.3259979455684359, + "scoreError" : 0.004489274816290288, + "scoreConfidence" : [ + 0.3215086707521456, + 0.3304872203847262 + ], + "scorePercentiles" : { + "0.0" : 0.32407702284658757, + "50.0" : 0.3263130527466429, + "90.0" : 0.3276310654894509, + "95.0" : 0.3276310654894509, + "99.0" : 0.3276310654894509, + "99.9" : 0.3276310654894509, + "99.99" : 0.3276310654894509, + "99.999" : 0.3276310654894509, + "99.9999" : 0.3276310654894509, + "100.0" : 0.3276310654894509 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.32543521032249667, + 0.32407702284658757, + 0.32430042802477543 + ], + [ + 0.3273530515565158, + 0.32719089517078914, + 0.3276310654894509 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.14449774652122083, + "scoreError" : 3.9635351046255114E-4, + "scoreConfidence" : [ + 0.14410139301075828, + 0.14489410003168338 + ], + "scorePercentiles" : { + "0.0" : 0.14436442583476491, + "50.0" : 0.14445022494750426, + "90.0" : 0.14474523102420103, + "95.0" : 0.14474523102420103, + "99.0" : 0.14474523102420103, + "99.9" : 0.14474523102420103, + "99.99" : 0.14474523102420103, + "99.999" : 0.14474523102420103, + "99.9999" : 0.14474523102420103, + "100.0" : 0.14474523102420103 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.14474523102420103, + 0.14443204809497676, + 0.14457623934132344 + ], + [ + 0.1444684018000318, + 0.14436442583476491, + 0.14440013303202703 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.40710077240933656, + "scoreError" : 0.006942328913300606, + "scoreConfidence" : [ + 0.40015844349603596, + 0.41404310132263716 + ], + "scorePercentiles" : { + "0.0" : 0.4050743493195075, + "50.0" : 0.40632440813205617, + "90.0" : 0.4115546036462406, + "95.0" : 0.4115546036462406, + "99.0" : 0.4115546036462406, + "99.9" : 0.4115546036462406, + "99.99" : 0.4115546036462406, + "99.999" : 0.4115546036462406, + "99.9999" : 0.4115546036462406, + "100.0" : 0.4115546036462406 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.4115546036462406, + 0.40811117666503427, + 0.4070035775507712 + ], + [ + 0.4050743493195075, + 0.4056452387133412, + 0.40521568856112483 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.15907875000332258, + "scoreError" : 0.012651090802988084, + "scoreConfidence" : [ + 0.1464276592003345, + 0.17172984080631068 + ], + "scorePercentiles" : { + "0.0" : 0.15449959529400858, + "50.0" : 0.1590325722030273, + "90.0" : 0.16438924245064357, + "95.0" : 0.16438924245064357, + "99.0" : 0.16438924245064357, + "99.9" : 0.16438924245064357, + "99.99" : 0.16438924245064357, + "99.999" : 0.16438924245064357, + "99.9999" : 0.16438924245064357, + "100.0" : 0.16438924245064357 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.15598926339926375, + 0.15449959529400858, + 0.15464426556459346 + ], + [ + 0.16438924245064357, + 0.16287425230463534, + 0.16207588100679082 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkRepeatedFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.04745177076858712, + "scoreError" : 0.0032115805946338004, + "scoreConfidence" : [ + 0.04424019017395332, + 0.05066335136322092 + ], + "scorePercentiles" : { + "0.0" : 0.04638537488171884, + "50.0" : 0.04728441744428115, + "90.0" : 0.04872298560257254, + "95.0" : 0.04872298560257254, + "99.0" : 0.04872298560257254, + "99.9" : 0.04872298560257254, + "99.99" : 0.04872298560257254, + "99.999" : 0.04872298560257254, + "99.9999" : 0.04872298560257254, + "100.0" : 0.04872298560257254 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.04872298560257254, + 0.04861319215493731, + 0.04810178364559032 + ], + [ + 0.04642023708373177, + 0.04638537488171884, + 0.04646705124297198 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 8658420.181959266, + "scoreError" : 240687.8205461195, + "scoreConfidence" : [ + 8417732.361413145, + 8899108.002505386 + ], + "scorePercentiles" : { + "0.0" : 8579289.288164666, + "50.0" : 8647310.401244972, + "90.0" : 8766050.457493426, + "95.0" : 8766050.457493426, + "99.0" : 8766050.457493426, + "99.9" : 8766050.457493426, + "99.99" : 8766050.457493426, + "99.999" : 8766050.457493426, + "99.9999" : 8766050.457493426, + "100.0" : 8766050.457493426 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 8766050.457493426, + 8709770.618798956, + 8729172.792321118 + ], + [ + 8579289.288164666, + 8581387.751286449, + 8584850.183690988 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + + From b69dd6b86e8bef01796e016770c431b70880a16e Mon Sep 17 00:00:00 2001 From: dondonz <13839920+dondonz@users.noreply.github.com> Date: Thu, 31 Jul 2025 08:11:50 +1000 Subject: [PATCH 11/21] Cast execution ID to string to make this easier to log --- src/main/java/graphql/ProfilerResult.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/graphql/ProfilerResult.java b/src/main/java/graphql/ProfilerResult.java index bf5159dce9..326fcbf62f 100644 --- a/src/main/java/graphql/ProfilerResult.java +++ b/src/main/java/graphql/ProfilerResult.java @@ -273,7 +273,7 @@ public List getInstrumentationClasses() { public Map shortSummaryMap() { Map result = new LinkedHashMap<>(); - result.put("executionId", Assert.assertNotNull(executionId)); + result.put("executionId", Assert.assertNotNull(executionId).toString()); result.put("operation", operationType + ":" + operationName); result.put("startTime", startTime); result.put("endTime", endTime); From 5de46cd41d00586ba94a7ca4204f3c6da686a0be Mon Sep 17 00:00:00 2001 From: dondonz <13839920+dondonz@users.noreply.github.com> Date: Thu, 31 Jul 2025 09:53:31 +1000 Subject: [PATCH 12/21] Add test to for ExecutionId cast to string in profiler output --- src/test/groovy/graphql/ProfilerTest.groovy | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/test/groovy/graphql/ProfilerTest.groovy b/src/test/groovy/graphql/ProfilerTest.groovy index 1498417c3e..d7c0f27881 100644 --- a/src/test/groovy/graphql/ProfilerTest.groovy +++ b/src/test/groovy/graphql/ProfilerTest.groovy @@ -1,5 +1,6 @@ package graphql +import graphql.execution.ExecutionId import graphql.execution.instrumentation.ChainedInstrumentation import graphql.execution.instrumentation.Instrumentation import graphql.execution.instrumentation.InstrumentationState @@ -457,9 +458,11 @@ class ProfilerTest extends Specification { ]]) def graphql = GraphQL.newGraphQL(schema).build(); + ExecutionId id = ExecutionId.from("myExecutionId") ExecutionInput ei = ExecutionInput.newExecutionInput() .query("{ foo { id name text } foo2: foo { id name text} }") .profileExecution(true) + .executionId(id) .build() when: @@ -480,8 +483,7 @@ class ProfilerTest extends Specification { profilerResult.shortSummaryMap().get("dataFetcherResultTypes") == ["COMPLETABLE_FUTURE_COMPLETED" : "(count:2, invocations:4)", "COMPLETABLE_FUTURE_NOT_COMPLETED": "(count:2, invocations:2)", "MATERIALIZED" : "(count:2, invocations:4)"] - - + profilerResult.shortSummaryMap().get("executionId") == "myExecutionId" } def "operation details"() { From ae4103543c35327cc6d99969dbadd3f64a7fedc8 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Thu, 31 Jul 2025 10:52:41 +1000 Subject: [PATCH 13/21] cleanup --- .../agent/result/ExecutionTrackingResult.java | 154 ------------------ 1 file changed, 154 deletions(-) delete mode 100644 src/main/java/graphql/agent/result/ExecutionTrackingResult.java diff --git a/src/main/java/graphql/agent/result/ExecutionTrackingResult.java b/src/main/java/graphql/agent/result/ExecutionTrackingResult.java deleted file mode 100644 index 9896da2c1d..0000000000 --- a/src/main/java/graphql/agent/result/ExecutionTrackingResult.java +++ /dev/null @@ -1,154 +0,0 @@ -package graphql.agent.result; - -import graphql.PublicApi; -import graphql.execution.ResultPath; -import org.dataloader.DataLoader; - -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.atomic.AtomicLong; -import java.util.concurrent.atomic.AtomicReference; - -import static graphql.agent.result.ExecutionTrackingResult.DFResultType.PENDING; - -/** - * This is the result of the agent tracking an execution. - * It can be found inside the GraphQLContext after the execution with the key {@link ExecutionTrackingResult#EXECUTION_TRACKING_KEY} - * - * Note: While this is public API, the main goal is temporary debugging to understand an execution better with minimal overhead. - * Therefore this will evolve over time if needed to be performant and reflect the overall execution. - * It is not recommended to have the agent on always or to rely on this class during normal execution - */ -@PublicApi -public class ExecutionTrackingResult { - - public static final String EXECUTION_TRACKING_KEY = "__GJ_AGENT_EXECUTION_TRACKING"; - public final AtomicReference startThread = new AtomicReference<>(); - public final AtomicReference endThread = new AtomicReference<>(); - public final AtomicLong startExecutionTime = new AtomicLong(); - public final AtomicLong endExecutionTime = new AtomicLong(); - public final Map resultPathToDataLoaderUsed = new ConcurrentHashMap<>(); - public final Map dataLoaderToName = new ConcurrentHashMap<>(); - - public final Map timePerPath = new ConcurrentHashMap<>(); - public final Map finishedTimePerPath = new ConcurrentHashMap<>(); - public final Map finishedThreadPerPath = new ConcurrentHashMap<>(); - public final Map startInvocationThreadPerPath = new ConcurrentHashMap<>(); - private final Map dfResultTypes = new ConcurrentHashMap<>(); - public final Map> dataLoaderNameToBatchCall = new ConcurrentHashMap<>(); - - public static class BatchLoadingCall { - public BatchLoadingCall(int keyCount, String threadName) { - this.keyCount = keyCount; - this.threadName = threadName; - } - - public final int keyCount; - public final String threadName; - - } - - - public String print(String executionId) { - StringBuilder s = new StringBuilder(); - s.append("==========================").append("\n"); - s.append("Summary for execution with id ").append(executionId).append("\n"); - s.append("==========================").append("\n"); - s.append("Execution time in ms:").append((endExecutionTime.get() - startExecutionTime.get()) / 1_000_000L).append("\n"); - s.append("Fields count: ").append(timePerPath.keySet().size()).append("\n"); - s.append("Blocking fields count: ").append(dfResultTypes.values().stream().filter(dfResultType -> dfResultType != PENDING).count()).append("\n"); - s.append("Nonblocking fields count: ").append(dfResultTypes.values().stream().filter(dfResultType -> dfResultType == PENDING).count()).append("\n"); - s.append("DataLoaders used: ").append(dataLoaderToName.size()).append("\n"); - s.append("DataLoader names: ").append(dataLoaderToName.values()).append("\n"); - s.append("start execution thread: '").append(startThread.get()).append("'\n"); - s.append("end execution thread: '").append(endThread.get()).append("'\n"); - s.append("BatchLoader calls details: ").append("\n"); - s.append("==========================").append("\n"); - for (String dataLoaderName : dataLoaderNameToBatchCall.keySet()) { - s.append("Batch call: '").append(dataLoaderName).append("' made ").append(dataLoaderNameToBatchCall.get(dataLoaderName).size()).append(" times, ").append("\n"); - for (BatchLoadingCall batchLoadingCall : dataLoaderNameToBatchCall.get(dataLoaderName)) { - s.append("Batch call with ").append(batchLoadingCall.keyCount).append(" keys ").append(" in thread ").append(batchLoadingCall.threadName).append("\n"); - } - List resultPathUsed = new ArrayList<>(); - for (ResultPath resultPath : resultPathToDataLoaderUsed.keySet()) { - if (resultPathToDataLoaderUsed.get(resultPath).equals(dataLoaderName)) { - resultPathUsed.add(resultPath); - } - } - s.append("DataLoader: '").append(dataLoaderName).append("' used in fields: ").append(resultPathUsed).append("\n"); - } - s.append("Field details:").append("\n"); - s.append("===============").append("\n"); - for (ResultPath path : timePerPath.keySet()) { - s.append("Field: '").append(path).append("'\n"); - s.append("invocation time: ").append(timePerPath.get(path)).append(" nano seconds, ").append("\n"); - s.append("completion time: ").append(finishedTimePerPath.get(path)).append(" nano seconds, ").append("\n"); - s.append("Result type: ").append(dfResultTypes.get(path)).append("\n"); - s.append("invoked in thread: ").append(startInvocationThreadPerPath.get(path)).append("\n"); - s.append("finished in thread: ").append(finishedThreadPerPath.get(path)).append("\n"); - s.append("-------------\n"); - } - s.append("==========================").append("\n"); - s.append("==========================").append("\n"); - return s.toString(); - - } - - @Override - public String toString() { - return "ExecutionData{" + - "resultPathToDataLoaderUsed=" + resultPathToDataLoaderUsed + - ", dataLoaderNames=" + dataLoaderToName.values() + - ", timePerPath=" + timePerPath + - ", dfResultTypes=" + dfResultTypes + - '}'; - } - - public enum DFResultType { - DONE_OK, - DONE_EXCEPTIONALLY, - DONE_CANCELLED, - PENDING, - } - - public List getDataLoaderNames() { - return new ArrayList<>(dataLoaderToName.values()); - } - - - public void start(ResultPath path, long startTime) { - timePerPath.put(path, startTime); - } - - public void end(ResultPath path, long endTime) { - timePerPath.put(path, endTime - timePerPath.get(path)); - } - - public int dataFetcherCount() { - return timePerPath.size(); - } - - public long getTime(ResultPath path) { - return timePerPath.get(path); - } - - public long getTime(String path) { - return timePerPath.get(ResultPath.parse(path)); - } - - public void setDfResultTypes(ResultPath resultPath, DFResultType resultTypes) { - dfResultTypes.put(resultPath, resultTypes); - } - - public DFResultType getDfResultTypes(ResultPath resultPath) { - return dfResultTypes.get(resultPath); - } - - public DFResultType getDfResultTypes(String resultPath) { - return dfResultTypes.get(ResultPath.parse(resultPath)); - } - - -} From 623adc13b2d1c80aaac2f5599993525486a7c095 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Thu, 31 Jul 2025 11:01:03 +1000 Subject: [PATCH 14/21] comment out the processor by default --- build.gradle | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 82a9e8d114..718aafea50 100644 --- a/build.gradle +++ b/build.gradle @@ -150,7 +150,9 @@ dependencies { // this is needed for the idea jmh plugin to work correctly jmh 'org.openjdk.jmh:jmh-core:1.37' jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.37' - jmhAnnotationProcessor 'org.openjdk.jmh:jmh-generator-annprocess:1.37' + + // comment this in if you want to run JMH benchmarks from idea +// jmhAnnotationProcessor 'org.openjdk.jmh:jmh-generator-annprocess:1.37' errorprone 'com.uber.nullaway:nullaway:0.12.7' errorprone 'com.google.errorprone:error_prone_core:2.41.0' From 1fc03e374287a959a2527b5de76133a3641fe03f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Thu, 31 Jul 2025 05:01:54 +0000 Subject: [PATCH 15/21] Add performance results for commit 1b2f619e4b944ca224a7296197479e79bc39a9e1 --- ...b944ca224a7296197479e79bc39a9e1-jdk17.json | 1279 +++++++++++++++++ ...b944ca224a7296197479e79bc39a9e1-jdk17.json | 1279 +++++++++++++++++ 2 files changed, 2558 insertions(+) create mode 100644 performance-results/2025-07-31T05:01:36Z-1b2f619e4b944ca224a7296197479e79bc39a9e1-jdk17.json create mode 100644 performance-results/2025-07-31T05:01:42Z-1b2f619e4b944ca224a7296197479e79bc39a9e1-jdk17.json diff --git a/performance-results/2025-07-31T05:01:36Z-1b2f619e4b944ca224a7296197479e79bc39a9e1-jdk17.json b/performance-results/2025-07-31T05:01:36Z-1b2f619e4b944ca224a7296197479e79bc39a9e1-jdk17.json new file mode 100644 index 0000000000..09d80e6758 --- /dev/null +++ b/performance-results/2025-07-31T05:01:36Z-1b2f619e4b944ca224a7296197479e79bc39a9e1-jdk17.json @@ -0,0 +1,1279 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "5" + }, + "primaryMetric" : { + "score" : 3.353482858631146, + "scoreError" : 0.038276186398402176, + "scoreConfidence" : [ + 3.3152066722327436, + 3.391759045029548 + ], + "scorePercentiles" : { + "0.0" : 3.346497691792046, + "50.0" : 3.353255068379298, + "90.0" : 3.3609236059739396, + "95.0" : 3.3609236059739396, + "99.0" : 3.3609236059739396, + "99.9" : 3.3609236059739396, + "99.99" : 3.3609236059739396, + "99.999" : 3.3609236059739396, + "99.9999" : 3.3609236059739396, + "100.0" : 3.3609236059739396 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.3539603211651747, + 3.3609236059739396 + ], + [ + 3.346497691792046, + 3.3525498155934215 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "10" + }, + "primaryMetric" : { + "score" : 1.7020432718910865, + "scoreError" : 0.013755654946980111, + "scoreConfidence" : [ + 1.6882876169441063, + 1.7157989268380667 + ], + "scorePercentiles" : { + "0.0" : 1.6991756177622328, + "50.0" : 1.7023371607273865, + "90.0" : 1.7043231483473402, + "95.0" : 1.7043231483473402, + "99.0" : 1.7043231483473402, + "99.9" : 1.7043231483473402, + "99.99" : 1.7043231483473402, + "99.999" : 1.7043231483473402, + "99.9999" : 1.7043231483473402, + "100.0" : 1.7043231483473402 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.7023445450305896, + 1.7023297764241831 + ], + [ + 1.6991756177622328, + 1.7043231483473402 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "20" + }, + "primaryMetric" : { + "score" : 0.851553165364491, + "scoreError" : 0.037225329252169405, + "scoreConfidence" : [ + 0.8143278361123216, + 0.8887784946166604 + ], + "scorePercentiles" : { + "0.0" : 0.8444278799178012, + "50.0" : 0.852215983388291, + "90.0" : 0.8573528147635805, + "95.0" : 0.8573528147635805, + "99.0" : 0.8573528147635805, + "99.9" : 0.8573528147635805, + "99.99" : 0.8573528147635805, + "99.999" : 0.8573528147635805, + "99.9999" : 0.8573528147635805, + "100.0" : 0.8573528147635805 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.8444278799178012, + 0.8495447139367008 + ], + [ + 0.854887252839881, + 0.8573528147635805 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 16.483937486809797, + "scoreError" : 0.12424298772002351, + "scoreConfidence" : [ + 16.359694499089773, + 16.60818047452982 + ], + "scorePercentiles" : { + "0.0" : 16.440802488419305, + "50.0" : 16.478395945076294, + "90.0" : 16.53481312099235, + "95.0" : 16.53481312099235, + "99.0" : 16.53481312099235, + "99.9" : 16.53481312099235, + "99.99" : 16.53481312099235, + "99.999" : 16.53481312099235, + "99.9999" : 16.53481312099235, + "100.0" : 16.53481312099235 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 16.44343717796621, + 16.448880022547907, + 16.440802488419305 + ], + [ + 16.52778024332833, + 16.53481312099235, + 16.50791186760468 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput_getImmediateFields", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2757.119904801759, + "scoreError" : 288.38943624942414, + "scoreConfidence" : [ + 2468.7304685523345, + 3045.509341051183 + ], + "scorePercentiles" : { + "0.0" : 2661.9909168135537, + "50.0" : 2756.459464719503, + "90.0" : 2852.9335470111214, + "95.0" : 2852.9335470111214, + "99.0" : 2852.9335470111214, + "99.9" : 2852.9335470111214, + "99.99" : 2852.9335470111214, + "99.999" : 2852.9335470111214, + "99.9999" : 2852.9335470111214, + "100.0" : 2852.9335470111214 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2852.9335470111214, + 2848.9655643403053, + 2851.07892392382 + ], + [ + 2663.953365098701, + 2661.9909168135537, + 2663.797111623049 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 76585.05858938322, + "scoreError" : 1266.263550159021, + "scoreConfidence" : [ + 75318.79503922419, + 77851.32213954224 + ], + "scorePercentiles" : { + "0.0" : 76115.07745482646, + "50.0" : 76610.95525768644, + "90.0" : 77000.19535442891, + "95.0" : 77000.19535442891, + "99.0" : 77000.19535442891, + "99.9" : 77000.19535442891, + "99.99" : 77000.19535442891, + "99.999" : 77000.19535442891, + "99.9999" : 77000.19535442891, + "100.0" : 77000.19535442891 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 76177.91179091227, + 76115.07745482646, + 76229.54514109461 + ], + [ + 76992.36537427825, + 77000.19535442891, + 76995.25642075881 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 362.7264432334691, + "scoreError" : 3.5096609700386523, + "scoreConfidence" : [ + 359.21678226343045, + 366.2361042035078 + ], + "scorePercentiles" : { + "0.0" : 361.6276971707852, + "50.0" : 362.2416763776158, + "90.0" : 364.4246887591129, + "95.0" : 364.4246887591129, + "99.0" : 364.4246887591129, + "99.9" : 364.4246887591129, + "99.99" : 364.4246887591129, + "99.999" : 364.4246887591129, + "99.9999" : 364.4246887591129, + "100.0" : 364.4246887591129 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 362.5172587346009, + 364.1464940256564, + 364.4246887591129 + ], + [ + 361.96609402063075, + 361.6276971707852, + 361.67642669002885 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 114.12040759178154, + "scoreError" : 5.587069436645381, + "scoreConfidence" : [ + 108.53333815513616, + 119.70747702842692 + ], + "scorePercentiles" : { + "0.0" : 111.26196446325504, + "50.0" : 114.31630357553416, + "90.0" : 116.01487473534624, + "95.0" : 116.01487473534624, + "99.0" : 116.01487473534624, + "99.9" : 116.01487473534624, + "99.99" : 116.01487473534624, + "99.999" : 116.01487473534624, + "99.9999" : 116.01487473534624, + "100.0" : 116.01487473534624 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 115.96548381306346, + 115.53845946785674, + 116.01487473534624 + ], + [ + 111.26196446325504, + 113.09414768321159, + 112.84751538795616 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.06039248248481773, + "scoreError" : 6.181374848629453E-4, + "scoreConfidence" : [ + 0.059774344999954786, + 0.06101061996968068 + ], + "scorePercentiles" : { + "0.0" : 0.060203173237732305, + "50.0" : 0.060354282456001385, + "90.0" : 0.060750003942628375, + "95.0" : 0.060750003942628375, + "99.0" : 0.060750003942628375, + "99.9" : 0.060750003942628375, + "99.99" : 0.060750003942628375, + "99.999" : 0.060750003942628375, + "99.9999" : 0.060750003942628375, + "100.0" : 0.060750003942628375 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.060481614526254675, + 0.060750003942628375, + 0.06048752949324365 + ], + [ + 0.0602269503857481, + 0.06020562332329922, + 0.060203173237732305 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime_getImmediateFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 3.6682822158171725E-4, + "scoreError" : 4.884083095039461E-5, + "scoreConfidence" : [ + 3.1798739063132263E-4, + 4.156690525321119E-4 + ], + "scorePercentiles" : { + "0.0" : 3.508456336502254E-4, + "50.0" : 3.6679063090814466E-4, + "90.0" : 3.829964732939617E-4, + "95.0" : 3.829964732939617E-4, + "99.0" : 3.829964732939617E-4, + "99.9" : 3.829964732939617E-4, + "99.99" : 3.829964732939617E-4, + "99.999" : 3.829964732939617E-4, + "99.9999" : 3.829964732939617E-4, + "100.0" : 3.829964732939617E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.5094553394315783E-4, + 3.5099667298510163E-4, + 3.508456336502254E-4 + ], + [ + 3.825845888311877E-4, + 3.829964732939617E-4, + 3.826004267866694E-4 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DataLoaderPerformance.executeRequestWithDataLoaders", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.1240012052451922, + "scoreError" : 5.23147068183301E-4, + "scoreConfidence" : [ + 0.1234780581770089, + 0.12452435231337551 + ], + "scorePercentiles" : { + "0.0" : 0.1237848824192011, + "50.0" : 0.12398571541574485, + "90.0" : 0.12425495182773788, + "95.0" : 0.12425495182773788, + "99.0" : 0.12425495182773788, + "99.9" : 0.12425495182773788, + "99.99" : 0.12425495182773788, + "99.999" : 0.12425495182773788, + "99.9999" : 0.12425495182773788, + "100.0" : 0.12425495182773788 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.1237848824192011, + 0.12395541131191433, + 0.12382405558375949 + ], + [ + 0.12425495182773788, + 0.12401601951957539, + 0.12417191080896504 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.013177677040063696, + "scoreError" : 3.375376591257966E-4, + "scoreConfidence" : [ + 0.0128401393809379, + 0.013515214699189492 + ], + "scorePercentiles" : { + "0.0" : 0.01306630065108403, + "50.0" : 0.013166360446818431, + "90.0" : 0.013300087010762298, + "95.0" : 0.013300087010762298, + "99.0" : 0.013300087010762298, + "99.9" : 0.013300087010762298, + "99.99" : 0.013300087010762298, + "99.999" : 0.013300087010762298, + "99.9999" : 0.013300087010762298, + "100.0" : 0.013300087010762298 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.013262698887938408, + 0.013300087010762298, + 0.013297864781053444 + ], + [ + 0.013070022005698453, + 0.01306630065108403, + 0.013069088903845526 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF2Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.9885506742744191, + "scoreError" : 0.0632063612825815, + "scoreConfidence" : [ + 0.9253443129918376, + 1.0517570355570007 + ], + "scorePercentiles" : { + "0.0" : 0.9671989556092844, + "50.0" : 0.9886548614717992, + "90.0" : 1.009485964772383, + "95.0" : 1.009485964772383, + "99.0" : 1.009485964772383, + "99.9" : 1.009485964772383, + "99.99" : 1.009485964772383, + "99.999" : 1.009485964772383, + "99.9999" : 1.009485964772383, + "100.0" : 1.009485964772383 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.9682148281537419, + 0.9685245988766221, + 0.9671989556092844 + ], + [ + 1.008785124066976, + 1.0090945741675075, + 1.009485964772383 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "2" + }, + "primaryMetric" : { + "score" : 0.010733988396759986, + "scoreError" : 0.0010812263513256348, + "scoreConfidence" : [ + 0.009652762045434351, + 0.01181521474808562 + ], + "scorePercentiles" : { + "0.0" : 0.010373753348575506, + "50.0" : 0.010735976162856625, + "90.0" : 0.011094092872896059, + "95.0" : 0.011094092872896059, + "99.0" : 0.011094092872896059, + "99.9" : 0.011094092872896059, + "99.99" : 0.011094092872896059, + "99.999" : 0.011094092872896059, + "99.9999" : 0.011094092872896059, + "100.0" : 0.011094092872896059 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.011094092872896059, + 0.011075956253225796, + 0.011087530743030486 + ], + [ + 0.010395996072487453, + 0.010376601090344618, + 0.010373753348575506 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "10" + }, + "primaryMetric" : { + "score" : 3.0244017929846456, + "scoreError" : 0.02350721394922381, + "scoreConfidence" : [ + 3.000894579035422, + 3.0479090069338692 + ], + "scorePercentiles" : { + "0.0" : 3.0140141271850514, + "50.0" : 3.027378536565311, + "90.0" : 3.033068093389933, + "95.0" : 3.033068093389933, + "99.0" : 3.033068093389933, + "99.9" : 3.033068093389933, + "99.99" : 3.033068093389933, + "99.999" : 3.033068093389933, + "99.9999" : 3.033068093389933, + "100.0" : 3.033068093389933 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.0305397575757578, + 3.033068093389933, + 3.029024942459116 + ], + [ + 3.014031706626506, + 3.025732130671506, + 3.0140141271850514 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2.8081195794171196, + "scoreError" : 0.04451368328698103, + "scoreConfidence" : [ + 2.7636058961301386, + 2.8526332627041007 + ], + "scorePercentiles" : { + "0.0" : 2.7892624670942556, + "50.0" : 2.809088813599385, + "90.0" : 2.824478731996611, + "95.0" : 2.824478731996611, + "99.0" : 2.824478731996611, + "99.9" : 2.824478731996611, + "99.99" : 2.824478731996611, + "99.999" : 2.824478731996611, + "99.9999" : 2.824478731996611, + "100.0" : 2.824478731996611 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.824478731996611, + 2.819786429940795, + 2.822643530906012 + ], + [ + 2.7983911972579745, + 2.794155119307069, + 2.7892624670942556 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkDeepAbstractConcrete", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.17612863827510697, + "scoreError" : 0.0016477289885006518, + "scoreConfidence" : [ + 0.1744809092866063, + 0.17777636726360763 + ], + "scorePercentiles" : { + "0.0" : 0.1756184496601865, + "50.0" : 0.17597844740560853, + "90.0" : 0.17728533952630832, + "95.0" : 0.17728533952630832, + "99.0" : 0.17728533952630832, + "99.9" : 0.17728533952630832, + "99.99" : 0.17728533952630832, + "99.999" : 0.17728533952630832, + "99.9999" : 0.17728533952630832, + "100.0" : 0.17728533952630832 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.17602657610321945, + 0.17605160570744502, + 0.17728533952630832 + ], + [ + 0.17585953994548492, + 0.1759303187079976, + 0.1756184496601865 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.32291559915548146, + "scoreError" : 3.2985694367027133E-4, + "scoreConfidence" : [ + 0.3225857422118112, + 0.32324545609915173 + ], + "scorePercentiles" : { + "0.0" : 0.32278306817081437, + "50.0" : 0.32292217191202494, + "90.0" : 0.3230849756397002, + "95.0" : 0.3230849756397002, + "99.0" : 0.3230849756397002, + "99.9" : 0.3230849756397002, + "99.99" : 0.3230849756397002, + "99.999" : 0.3230849756397002, + "99.9999" : 0.3230849756397002, + "100.0" : 0.3230849756397002 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.32298991101995994, + 0.32279129627836417, + 0.3228915813825837 + ], + [ + 0.3230849756397002, + 0.32278306817081437, + 0.32295276244146615 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.14388199181729064, + "scoreError" : 0.004925840882024297, + "scoreConfidence" : [ + 0.13895615093526634, + 0.14880783269931494 + ], + "scorePercentiles" : { + "0.0" : 0.1413976640178723, + "50.0" : 0.14356822943939596, + "90.0" : 0.14681751623038186, + "95.0" : 0.14681751623038186, + "99.0" : 0.14681751623038186, + "99.9" : 0.14681751623038186, + "99.99" : 0.14681751623038186, + "99.999" : 0.14681751623038186, + "99.9999" : 0.14681751623038186, + "100.0" : 0.14681751623038186 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.1435107920840389, + 0.14361619035788142, + 0.14352026852091046 + ], + [ + 0.14681751623038186, + 0.14442951969265877, + 0.1413976640178723 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.4018423565058164, + "scoreError" : 0.01027690974808848, + "scoreConfidence" : [ + 0.3915654467577279, + 0.4121192662539049 + ], + "scorePercentiles" : { + "0.0" : 0.39786439737417945, + "50.0" : 0.4016776301419805, + "90.0" : 0.4064869786602715, + "95.0" : 0.4064869786602715, + "99.0" : 0.4064869786602715, + "99.9" : 0.4064869786602715, + "99.99" : 0.4064869786602715, + "99.999" : 0.4064869786602715, + "99.9999" : 0.4064869786602715, + "100.0" : 0.4064869786602715 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.39786439737417945, + 0.39879919620354126, + 0.3991162329182631 + ], + [ + 0.404548306512945, + 0.4042390273656979, + 0.4064869786602715 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.16364278704681767, + "scoreError" : 0.02976645612587646, + "scoreConfidence" : [ + 0.1338763309209412, + 0.19340924317269415 + ], + "scorePercentiles" : { + "0.0" : 0.15386256352027078, + "50.0" : 0.16283202349547626, + "90.0" : 0.176492349482007, + "95.0" : 0.176492349482007, + "99.0" : 0.176492349482007, + "99.9" : 0.176492349482007, + "99.99" : 0.176492349482007, + "99.999" : 0.176492349482007, + "99.9999" : 0.176492349482007, + "100.0" : 0.176492349482007 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.1542853183269821, + 0.15386256352027078, + 0.15413900257406207 + ], + [ + 0.176492349482007, + 0.1713787286639704, + 0.17169875971361365 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkRepeatedFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.04661222868382268, + "scoreError" : 0.0017142685469840424, + "scoreConfidence" : [ + 0.04489796013683864, + 0.04832649723080672 + ], + "scorePercentiles" : { + "0.0" : 0.04604029042282831, + "50.0" : 0.04661151299084754, + "90.0" : 0.047195157842077694, + "95.0" : 0.047195157842077694, + "99.0" : 0.047195157842077694, + "99.9" : 0.047195157842077694, + "99.99" : 0.047195157842077694, + "99.999" : 0.047195157842077694, + "99.9999" : 0.047195157842077694, + "100.0" : 0.047195157842077694 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.046073407637941835, + 0.04604029042282831, + 0.04604954747147291 + ], + [ + 0.04714961834375324, + 0.04716535038486209, + 0.047195157842077694 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 8684522.139708702, + "scoreError" : 165967.2367030303, + "scoreConfidence" : [ + 8518554.90300567, + 8850489.376411732 + ], + "scorePercentiles" : { + "0.0" : 8632144.482312338, + "50.0" : 8658058.607342992, + "90.0" : 8781617.052677788, + "95.0" : 8781617.052677788, + "99.0" : 8781617.052677788, + "99.9" : 8781617.052677788, + "99.99" : 8781617.052677788, + "99.999" : 8781617.052677788, + "99.9999" : 8781617.052677788, + "100.0" : 8781617.052677788 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 8649923.417458946, + 8645169.681071738, + 8666193.797227036 + ], + [ + 8781617.052677788, + 8732084.407504363, + 8632144.482312338 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + + diff --git a/performance-results/2025-07-31T05:01:42Z-1b2f619e4b944ca224a7296197479e79bc39a9e1-jdk17.json b/performance-results/2025-07-31T05:01:42Z-1b2f619e4b944ca224a7296197479e79bc39a9e1-jdk17.json new file mode 100644 index 0000000000..a4f31fdcb4 --- /dev/null +++ b/performance-results/2025-07-31T05:01:42Z-1b2f619e4b944ca224a7296197479e79bc39a9e1-jdk17.json @@ -0,0 +1,1279 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "5" + }, + "primaryMetric" : { + "score" : 3.318403365647165, + "scoreError" : 0.020195822723520666, + "scoreConfidence" : [ + 3.2982075429236444, + 3.3385991883706856 + ], + "scorePercentiles" : { + "0.0" : 3.3151508428359695, + "50.0" : 3.318040275916247, + "90.0" : 3.322382067920195, + "95.0" : 3.322382067920195, + "99.0" : 3.322382067920195, + "99.9" : 3.322382067920195, + "99.99" : 3.322382067920195, + "99.999" : 3.322382067920195, + "99.9999" : 3.322382067920195, + "100.0" : 3.322382067920195 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.3151508428359695, + 3.319187084887637 + ], + [ + 3.3168934669448573, + 3.322382067920195 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "10" + }, + "primaryMetric" : { + "score" : 1.6646723633911307, + "scoreError" : 0.05434315514451174, + "scoreConfidence" : [ + 1.610329208246619, + 1.7190155185356424 + ], + "scorePercentiles" : { + "0.0" : 1.6570171460694267, + "50.0" : 1.6646417879500253, + "90.0" : 1.6723887315950448, + "95.0" : 1.6723887315950448, + "99.0" : 1.6723887315950448, + "99.9" : 1.6723887315950448, + "99.99" : 1.6723887315950448, + "99.999" : 1.6723887315950448, + "99.9999" : 1.6723887315950448, + "100.0" : 1.6723887315950448 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.6577853765003463, + 1.6570171460694267 + ], + [ + 1.6723887315950448, + 1.6714981993997042 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "20" + }, + "primaryMetric" : { + "score" : 0.8398016456176536, + "scoreError" : 0.03432004917268803, + "scoreConfidence" : [ + 0.8054815964449655, + 0.8741216947903416 + ], + "scorePercentiles" : { + "0.0" : 0.8320322913729159, + "50.0" : 0.8415760657814932, + "90.0" : 0.8440221595347125, + "95.0" : 0.8440221595347125, + "99.0" : 0.8440221595347125, + "99.9" : 0.8440221595347125, + "99.99" : 0.8440221595347125, + "99.999" : 0.8440221595347125, + "99.9999" : 0.8440221595347125, + "100.0" : 0.8440221595347125 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.8320322913729159, + 0.8418494852989352 + ], + [ + 0.8413026462640512, + 0.8440221595347125 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 16.04832769592115, + "scoreError" : 0.27187067208350196, + "scoreConfidence" : [ + 15.776457023837647, + 16.32019836800465 + ], + "scorePercentiles" : { + "0.0" : 15.894931377249218, + "50.0" : 16.09193448463687, + "90.0" : 16.148261716250115, + "95.0" : 16.148261716250115, + "99.0" : 16.148261716250115, + "99.9" : 16.148261716250115, + "99.99" : 16.148261716250115, + "99.999" : 16.148261716250115, + "99.9999" : 16.148261716250115, + "100.0" : 16.148261716250115 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 15.894931377249218, + 15.964115685485288, + 16.0874696157206 + ], + [ + 16.098788427268538, + 16.09639935355314, + 16.148261716250115 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput_getImmediateFields", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2647.9264001933484, + "scoreError" : 141.246126687054, + "scoreConfidence" : [ + 2506.6802735062943, + 2789.1725268804025 + ], + "scorePercentiles" : { + "0.0" : 2588.698634241166, + "50.0" : 2647.3617284989086, + "90.0" : 2704.505620773411, + "95.0" : 2704.505620773411, + "99.0" : 2704.505620773411, + "99.9" : 2704.505620773411, + "99.99" : 2704.505620773411, + "99.999" : 2704.505620773411, + "99.9999" : 2704.505620773411, + "100.0" : 2704.505620773411 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2618.1870490834576, + 2588.698634241166, + 2603.6292320701937 + ], + [ + 2676.53640791436, + 2704.505620773411, + 2696.0014570775043 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 74665.97443450178, + "scoreError" : 3158.7404424063757, + "scoreConfidence" : [ + 71507.23399209541, + 77824.71487690815 + ], + "scorePercentiles" : { + "0.0" : 73582.99072670742, + "50.0" : 74651.26138451396, + "90.0" : 75772.54357622322, + "95.0" : 75772.54357622322, + "99.0" : 75772.54357622322, + "99.9" : 75772.54357622322, + "99.99" : 75772.54357622322, + "99.999" : 75772.54357622322, + "99.9999" : 75772.54357622322, + "100.0" : 75772.54357622322 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 73740.63996323425, + 73599.30538572317, + 73582.99072670742 + ], + [ + 75772.54357622322, + 75561.88280579365, + 75738.48414932893 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 344.0629998053023, + "scoreError" : 18.94138527021444, + "scoreConfidence" : [ + 325.1216145350879, + 363.0043850755167 + ], + "scorePercentiles" : { + "0.0" : 337.25004844514956, + "50.0" : 343.62889235954134, + "90.0" : 352.3469807290136, + "95.0" : 352.3469807290136, + "99.0" : 352.3469807290136, + "99.9" : 352.3469807290136, + "99.99" : 352.3469807290136, + "99.999" : 352.3469807290136, + "99.9999" : 352.3469807290136, + "100.0" : 352.3469807290136 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 349.29597583092163, + 352.3469807290136, + 348.69201906732917 + ], + [ + 338.22720910764633, + 337.25004844514956, + 338.5657656517535 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 106.35505918929802, + "scoreError" : 9.190780657305664, + "scoreConfidence" : [ + 97.16427853199235, + 115.54583984660368 + ], + "scorePercentiles" : { + "0.0" : 102.85647297148368, + "50.0" : 105.68465179322885, + "90.0" : 112.16757070644547, + "95.0" : 112.16757070644547, + "99.0" : 112.16757070644547, + "99.9" : 112.16757070644547, + "99.99" : 112.16757070644547, + "99.999" : 112.16757070644547, + "99.9999" : 112.16757070644547, + "100.0" : 112.16757070644547 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 105.94208342292123, + 107.62640252596964, + 112.16757070644547 + ], + [ + 105.42722016353646, + 102.85647297148368, + 104.11060534543167 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.06254438412278612, + "scoreError" : 0.0015033842946808585, + "scoreConfidence" : [ + 0.061040999828105263, + 0.06404776841746698 + ], + "scorePercentiles" : { + "0.0" : 0.06179052928200692, + "50.0" : 0.06264674495475323, + "90.0" : 0.06306537395943695, + "95.0" : 0.06306537395943695, + "99.0" : 0.06306537395943695, + "99.9" : 0.06306537395943695, + "99.99" : 0.06306537395943695, + "99.999" : 0.06306537395943695, + "99.9999" : 0.06306537395943695, + "100.0" : 0.06306537395943695 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.06296256803314298, + 0.06306537395943695, + 0.06299236989140294 + ], + [ + 0.06212454169436351, + 0.06179052928200692, + 0.06233092187636346 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime_getImmediateFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 3.9458640404245714E-4, + "scoreError" : 9.70964383767474E-6, + "scoreConfidence" : [ + 3.848767602047824E-4, + 4.042960478801319E-4 + ], + "scorePercentiles" : { + "0.0" : 3.903585827686922E-4, + "50.0" : 3.9492492658870957E-4, + "90.0" : 3.980631731868366E-4, + "95.0" : 3.980631731868366E-4, + "99.0" : 3.980631731868366E-4, + "99.9" : 3.980631731868366E-4, + "99.99" : 3.980631731868366E-4, + "99.999" : 3.980631731868366E-4, + "99.9999" : 3.980631731868366E-4, + "100.0" : 3.980631731868366E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.9257645310684854E-4, + 3.9156388434290256E-4, + 3.903585827686922E-4 + ], + [ + 3.972734000705706E-4, + 3.976829307788922E-4, + 3.980631731868366E-4 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DataLoaderPerformance.executeRequestWithDataLoaders", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.1255006748516653, + "scoreError" : 0.002253001087482237, + "scoreConfidence" : [ + 0.12324767376418307, + 0.12775367593914755 + ], + "scorePercentiles" : { + "0.0" : 0.12461556924783172, + "50.0" : 0.12547914510805042, + "90.0" : 0.1263697855662547, + "95.0" : 0.1263697855662547, + "99.0" : 0.1263697855662547, + "99.9" : 0.1263697855662547, + "99.99" : 0.1263697855662547, + "99.999" : 0.1263697855662547, + "99.9999" : 0.1263697855662547, + "100.0" : 0.1263697855662547 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.1262420374297797, + 0.12605911880751292, + 0.1263697855662547 + ], + [ + 0.12481836665002496, + 0.12489917140858792, + 0.12461556924783172 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.01319577608563824, + "scoreError" : 3.907740862088009E-5, + "scoreConfidence" : [ + 0.01315669867701736, + 0.013234853494259121 + ], + "scorePercentiles" : { + "0.0" : 0.013177232390208935, + "50.0" : 0.013198787004726969, + "90.0" : 0.013212527298022905, + "95.0" : 0.013212527298022905, + "99.0" : 0.013212527298022905, + "99.9" : 0.013212527298022905, + "99.99" : 0.013212527298022905, + "99.999" : 0.013212527298022905, + "99.9999" : 0.013212527298022905, + "100.0" : 0.013212527298022905 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.013212527298022905, + 0.013201464978310288, + 0.01319610903114365 + ], + [ + 0.013181310612631185, + 0.013177232390208935, + 0.013206012203512488 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF2Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.9594635033562505, + "scoreError" : 0.016855352369805343, + "scoreConfidence" : [ + 0.9426081509864452, + 0.9763188557260558 + ], + "scorePercentiles" : { + "0.0" : 0.9520353520228463, + "50.0" : 0.9592794800224103, + "90.0" : 0.9669648454844324, + "95.0" : 0.9669648454844324, + "99.0" : 0.9669648454844324, + "99.9" : 0.9669648454844324, + "99.99" : 0.9669648454844324, + "99.999" : 0.9669648454844324, + "99.9999" : 0.9669648454844324, + "100.0" : 0.9669648454844324 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.9552573530423154, + 0.9553309745892243, + 0.9520353520228463 + ], + [ + 0.9639645095430885, + 0.9632279854555962, + 0.9669648454844324 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "2" + }, + "primaryMetric" : { + "score" : 0.011122006218449066, + "scoreError" : 0.0014124151794276225, + "scoreConfidence" : [ + 0.009709591039021444, + 0.012534421397876689 + ], + "scorePercentiles" : { + "0.0" : 0.010642811646335883, + "50.0" : 0.011116983379102878, + "90.0" : 0.011621793595158018, + "95.0" : 0.011621793595158018, + "99.0" : 0.011621793595158018, + "99.9" : 0.011621793595158018, + "99.99" : 0.011621793595158018, + "99.999" : 0.011621793595158018, + "99.9999" : 0.011621793595158018, + "100.0" : 0.011621793595158018 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.011548253599490044, + 0.011573330450884177, + 0.011621793595158018 + ], + [ + 0.010642811646335883, + 0.010660134860110564, + 0.01068571315871571 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "10" + }, + "primaryMetric" : { + "score" : 3.389075628542314, + "scoreError" : 0.08934401070662355, + "scoreConfidence" : [ + 3.29973161783569, + 3.4784196392489375 + ], + "scorePercentiles" : { + "0.0" : 3.332509489673551, + "50.0" : 3.4006833887686287, + "90.0" : 3.4159558674863386, + "95.0" : 3.4159558674863386, + "99.0" : 3.4159558674863386, + "99.9" : 3.4159558674863386, + "99.99" : 3.4159558674863386, + "99.999" : 3.4159558674863386, + "99.9999" : 3.4159558674863386, + "100.0" : 3.4159558674863386 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.393344762550882, + 3.3728789298718813, + 3.332509489673551 + ], + [ + 3.408022014986376, + 3.4159558674863386, + 3.4117427066848567 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2.92610005753114, + "scoreError" : 0.10223805544992967, + "scoreConfidence" : [ + 2.8238620020812104, + 3.02833811298107 + ], + "scorePercentiles" : { + "0.0" : 2.8899446047385147, + "50.0" : 2.9219609696081195, + "90.0" : 2.980806488822653, + "95.0" : 2.980806488822653, + "99.0" : 2.980806488822653, + "99.9" : 2.980806488822653, + "99.99" : 2.980806488822653, + "99.999" : 2.980806488822653, + "99.9999" : 2.980806488822653, + "100.0" : 2.980806488822653 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.980806488822653, + 2.947704010904804, + 2.942322551632833 + ], + [ + 2.8899446047385147, + 2.901599387583406, + 2.8942233015046295 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkDeepAbstractConcrete", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.18184344814445005, + "scoreError" : 0.0072012532464625694, + "scoreConfidence" : [ + 0.1746421948979875, + 0.18904470139091262 + ], + "scorePercentiles" : { + "0.0" : 0.17927036310345446, + "50.0" : 0.1817668604106166, + "90.0" : 0.18496747709238878, + "95.0" : 0.18496747709238878, + "99.0" : 0.18496747709238878, + "99.9" : 0.18496747709238878, + "99.99" : 0.18496747709238878, + "99.999" : 0.18496747709238878, + "99.9999" : 0.18496747709238878, + "100.0" : 0.18496747709238878 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.17939653808481631, + 0.17927036310345446, + 0.1799786145456509 + ], + [ + 0.18496747709238878, + 0.1835551062755823, + 0.18389258976480757 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.3337631399472168, + "scoreError" : 0.030501669192729765, + "scoreConfidence" : [ + 0.303261470754487, + 0.3642648091399466 + ], + "scorePercentiles" : { + "0.0" : 0.32348158958434414, + "50.0" : 0.33328192560874653, + "90.0" : 0.34450988772908914, + "95.0" : 0.34450988772908914, + "99.0" : 0.34450988772908914, + "99.9" : 0.34450988772908914, + "99.99" : 0.34450988772908914, + "99.999" : 0.34450988772908914, + "99.9999" : 0.34450988772908914, + "100.0" : 0.34450988772908914 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.34450988772908914, + 0.3441212088365851, + 0.3423751785750967 + ], + [ + 0.3239023023157895, + 0.32418867264239637, + 0.32348158958434414 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.15040484837488619, + "scoreError" : 0.0035886436967529182, + "scoreConfidence" : [ + 0.14681620467813328, + 0.1539934920716391 + ], + "scorePercentiles" : { + "0.0" : 0.14919495652563108, + "50.0" : 0.1502442421332506, + "90.0" : 0.15176951359062693, + "95.0" : 0.15176951359062693, + "99.0" : 0.15176951359062693, + "99.9" : 0.15176951359062693, + "99.99" : 0.15176951359062693, + "99.999" : 0.15176951359062693, + "99.9999" : 0.15176951359062693, + "100.0" : 0.15176951359062693 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.15176951359062693, + 0.15174155141647572, + 0.15115383114920117 + ], + [ + 0.1492345844500821, + 0.14933465311730007, + 0.14919495652563108 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.41562631564230706, + "scoreError" : 0.009840468667838151, + "scoreConfidence" : [ + 0.4057858469744689, + 0.42546678431014523 + ], + "scorePercentiles" : { + "0.0" : 0.4124977937548983, + "50.0" : 0.41429262462655747, + "90.0" : 0.42002929736654204, + "95.0" : 0.42002929736654204, + "99.0" : 0.42002929736654204, + "99.9" : 0.42002929736654204, + "99.99" : 0.42002929736654204, + "99.999" : 0.42002929736654204, + "99.9999" : 0.42002929736654204, + "100.0" : 0.42002929736654204 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.4124977937548983, + 0.41304656189335426, + 0.4128038415686274 + ], + [ + 0.42002929736654204, + 0.41984171191065955, + 0.4155386873597607 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.16031556314285697, + "scoreError" : 0.0028330169401163583, + "scoreConfidence" : [ + 0.1574825462027406, + 0.16314858008297334 + ], + "scorePercentiles" : { + "0.0" : 0.15926494830387003, + "50.0" : 0.16029965080255174, + "90.0" : 0.16164282374810074, + "95.0" : 0.16164282374810074, + "99.0" : 0.16164282374810074, + "99.9" : 0.16164282374810074, + "99.99" : 0.16164282374810074, + "99.999" : 0.16164282374810074, + "99.9999" : 0.16164282374810074, + "100.0" : 0.16164282374810074 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.16164282374810074, + 0.15975494800070292, + 0.1592948068431616 + ], + [ + 0.16084435360440055, + 0.15926494830387003, + 0.16109149835690584 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkRepeatedFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.04628224904856556, + "scoreError" : 0.004966382401929507, + "scoreConfidence" : [ + 0.04131586664663605, + 0.05124863145049507 + ], + "scorePercentiles" : { + "0.0" : 0.044660849366274555, + "50.0" : 0.046199723221185846, + "90.0" : 0.04825054774334874, + "95.0" : 0.04825054774334874, + "99.0" : 0.04825054774334874, + "99.9" : 0.04825054774334874, + "99.99" : 0.04825054774334874, + "99.999" : 0.04825054774334874, + "99.9999" : 0.04825054774334874, + "100.0" : 0.04825054774334874 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.044669575807388215, + 0.044660849366274555, + 0.04469663826240089 + ], + [ + 0.04825054774334874, + 0.047713074932010116, + 0.04770280817997081 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 9252879.439628795, + "scoreError" : 627035.8808514815, + "scoreConfidence" : [ + 8625843.558777314, + 9879915.320480276 + ], + "scorePercentiles" : { + "0.0" : 9035202.729900632, + "50.0" : 9197328.971140334, + "90.0" : 9658543.075289575, + "95.0" : 9658543.075289575, + "99.0" : 9658543.075289575, + "99.9" : 9658543.075289575, + "99.99" : 9658543.075289575, + "99.999" : 9658543.075289575, + "99.9999" : 9658543.075289575, + "100.0" : 9658543.075289575 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 9035202.729900632, + 9094981.092727272, + 9183404.227731865 + ], + [ + 9658543.075289575, + 9211253.714548804, + 9333891.797574626 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + + From eb90338eaecf93c6d055d0a53be77f3345cd7c05 Mon Sep 17 00:00:00 2001 From: dondonz <13839920+dondonz@users.noreply.github.com> Date: Thu, 31 Jul 2025 16:18:46 +1000 Subject: [PATCH 16/21] More formatting updates and remove Map.of which is not deterministic in order --- src/main/java/graphql/ProfilerResult.java | 24 ++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/src/main/java/graphql/ProfilerResult.java b/src/main/java/graphql/ProfilerResult.java index 326fcbf62f..8fad8acbed 100644 --- a/src/main/java/graphql/ProfilerResult.java +++ b/src/main/java/graphql/ProfilerResult.java @@ -277,8 +277,8 @@ public Map shortSummaryMap() { result.put("operation", operationType + ":" + operationName); result.put("startTime", startTime); result.put("endTime", endTime); - result.put("totalRunTime", (endTime - startTime) + "(" + (endTime - startTime) / 1_000_000 + "ms)"); - result.put("engineTotalRunningTime", engineTotalRunningTime + "(" + engineTotalRunningTime / 1_000_000 + "ms)"); + result.put("totalRunTimeNs", endTime - startTime); + result.put("engineTotalRunningTimeNs", engineTotalRunningTime); result.put("totalDataFetcherInvocations", totalDataFetcherInvocations); result.put("totalCustomDataFetcherInvocations", getTotalCustomDataFetcherInvocations()); result.put("totalTrivialDataFetcherInvocations", totalTrivialDataFetcherInvocations); @@ -310,11 +310,21 @@ public Map shortSummaryMap() { Assert.assertShouldNeverHappen(); } } - result.put("dataFetcherResultTypes", Map.of( - DataFetcherResultType.COMPLETABLE_FUTURE_COMPLETED.name(), "(count:" + completedCount + ", invocations:" + completedInvokeCount + ")", - DataFetcherResultType.COMPLETABLE_FUTURE_NOT_COMPLETED.name(), "(count:" + notCompletedCount + ", invocations:" + notCompletedInvokeCount + ")", - DataFetcherResultType.MATERIALIZED.name(), "(count:" + materializedCount + ", invocations:" + materializedInvokeCount + ")" - )); + LinkedHashMap dFRTinfo = new LinkedHashMap<>(3); + LinkedHashMap completableFutureCompleted = new LinkedHashMap<>(2); + completableFutureCompleted.put("count", completedCount); + completableFutureCompleted.put("invocations", completedInvokeCount); + LinkedHashMap completableFutureNotCompleted = new LinkedHashMap<>(2); + completableFutureNotCompleted.put("count", notCompletedCount); + completableFutureNotCompleted.put("invocations", notCompletedInvokeCount); + LinkedHashMap materialized = new LinkedHashMap<>(2); + materialized.put("count", materializedCount); + materialized.put("invocations", materializedInvokeCount); + + dFRTinfo.put(DataFetcherResultType.COMPLETABLE_FUTURE_COMPLETED.name(), completableFutureCompleted); + dFRTinfo.put(DataFetcherResultType.COMPLETABLE_FUTURE_NOT_COMPLETED.name(), completableFutureNotCompleted); + dFRTinfo.put(DataFetcherResultType.MATERIALIZED.name(), materialized); + result.put("dataFetcherResultTypes", dFRTinfo); return result; } From fde7f50db60c2c5c5c3153b57cba88fd8a075e27 Mon Sep 17 00:00:00 2001 From: dondonz <13839920+dondonz@users.noreply.github.com> Date: Thu, 31 Jul 2025 17:22:03 +1000 Subject: [PATCH 17/21] Use a helper method instead --- src/main/java/graphql/ProfilerResult.java | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/src/main/java/graphql/ProfilerResult.java b/src/main/java/graphql/ProfilerResult.java index 8fad8acbed..9042fe7305 100644 --- a/src/main/java/graphql/ProfilerResult.java +++ b/src/main/java/graphql/ProfilerResult.java @@ -311,23 +311,19 @@ public Map shortSummaryMap() { } } LinkedHashMap dFRTinfo = new LinkedHashMap<>(3); - LinkedHashMap completableFutureCompleted = new LinkedHashMap<>(2); - completableFutureCompleted.put("count", completedCount); - completableFutureCompleted.put("invocations", completedInvokeCount); - LinkedHashMap completableFutureNotCompleted = new LinkedHashMap<>(2); - completableFutureNotCompleted.put("count", notCompletedCount); - completableFutureNotCompleted.put("invocations", notCompletedInvokeCount); - LinkedHashMap materialized = new LinkedHashMap<>(2); - materialized.put("count", materializedCount); - materialized.put("invocations", materializedInvokeCount); - - dFRTinfo.put(DataFetcherResultType.COMPLETABLE_FUTURE_COMPLETED.name(), completableFutureCompleted); - dFRTinfo.put(DataFetcherResultType.COMPLETABLE_FUTURE_NOT_COMPLETED.name(), completableFutureNotCompleted); - dFRTinfo.put(DataFetcherResultType.MATERIALIZED.name(), materialized); + dFRTinfo.put(DataFetcherResultType.COMPLETABLE_FUTURE_COMPLETED.name(), createCountMap(completedCount, completedInvokeCount)); + dFRTinfo.put(DataFetcherResultType.COMPLETABLE_FUTURE_NOT_COMPLETED.name(), createCountMap(notCompletedCount, notCompletedInvokeCount)); + dFRTinfo.put(DataFetcherResultType.MATERIALIZED.name(), createCountMap(materializedCount, materializedInvokeCount)); result.put("dataFetcherResultTypes", dFRTinfo); return result; } + private LinkedHashMap createCountMap(int count, int invocations) { + LinkedHashMap map = new LinkedHashMap<>(2); + map.put("count", count); + map.put("invocations", invocations); + return map; + } public List> getDispatchEventsAsMap() { List> result = new ArrayList<>(); From 1c76bec6263cfd159d97eb02e38d8ae8825ff26a Mon Sep 17 00:00:00 2001 From: dondonz <13839920+dondonz@users.noreply.github.com> Date: Thu, 31 Jul 2025 17:32:35 +1000 Subject: [PATCH 18/21] Update test and IDE warnings --- src/test/groovy/graphql/ProfilerTest.groovy | 68 ++++++++++----------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/src/test/groovy/graphql/ProfilerTest.groovy b/src/test/groovy/graphql/ProfilerTest.groovy index d7c0f27881..96cc2098c4 100644 --- a/src/test/groovy/graphql/ProfilerTest.groovy +++ b/src/test/groovy/graphql/ProfilerTest.groovy @@ -40,9 +40,9 @@ class ProfilerTest extends Specification { def schema = TestUtil.schema(sdl, [Query: [ hello: { DataFetchingEnvironment dfe -> return "world" } as DataFetcher ]]) - def graphql = GraphQL.newGraphQL(schema).build(); + def graphql = GraphQL.newGraphQL(schema).build() - ExecutionInput ei = ExecutionInput.newExecutionInput() + ExecutionInput ei = newExecutionInput() .query("{ hello }") .profileExecution(true) .build() @@ -69,9 +69,9 @@ class ProfilerTest extends Specification { def schema = TestUtil.schema(sdl, [Query: [ hello: { DataFetchingEnvironment dfe -> return "world" } as DataFetcher ]]) - def graphql = GraphQL.newGraphQL(schema).build(); + def graphql = GraphQL.newGraphQL(schema).build() - ExecutionInput ei = ExecutionInput.newExecutionInput() + ExecutionInput ei = newExecutionInput() .query("{ hello __typename alias:__typename __schema {types{name}} __type(name: \"Query\") {name} }") .profileExecution(true) .build() @@ -99,9 +99,9 @@ class ProfilerTest extends Specification { def schema = TestUtil.schema(sdl, [Query: [ hello: { DataFetchingEnvironment dfe -> return "world" } as DataFetcher ]]) - def graphql = GraphQL.newGraphQL(schema).build(); + def graphql = GraphQL.newGraphQL(schema).build() - ExecutionInput ei = ExecutionInput.newExecutionInput() + ExecutionInput ei = newExecutionInput() .query("{ __schema {types{name}} __type(name: \"Query\") {name} }") .profileExecution(true) .build() @@ -153,9 +153,9 @@ class ProfilerTest extends Specification { dog: dogDf ]] def schema = TestUtil.schema(sdl, dfs) - def graphql = GraphQL.newGraphQL(schema).instrumentation(instrumentation).build(); + def graphql = GraphQL.newGraphQL(schema).instrumentation(instrumentation).build() - ExecutionInput ei = ExecutionInput.newExecutionInput() + ExecutionInput ei = newExecutionInput() .query("{ dog {name age} }") .profileExecution(true) .build() @@ -194,10 +194,10 @@ class ProfilerTest extends Specification { } } - DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader); + DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader) - DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); - dataLoaderRegistry.register("name", nameDataLoader); + DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry() + dataLoaderRegistry.register("name", nameDataLoader) def df1 = { env -> def loader = env.getDataLoader("name") @@ -251,10 +251,10 @@ class ProfilerTest extends Specification { } } - DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader); + DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader) - DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); - dataLoaderRegistry.register("name", nameDataLoader); + DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry() + dataLoaderRegistry.register("name", nameDataLoader) def dogDF = { env -> def loader = env.getDataLoader("name") @@ -307,17 +307,17 @@ class ProfilerTest extends Specification { def schema = TestUtil.schema(sdl, [Query: [ hello: { DataFetchingEnvironment dfe -> return "world" } as DataFetcher ]]) - Instrumentation fooInstrumentation = new Instrumentation() {}; - Instrumentation barInstrumentation = new Instrumentation() {}; + Instrumentation fooInstrumentation = new Instrumentation() {} + Instrumentation barInstrumentation = new Instrumentation() {} ChainedInstrumentation chainedInstrumentation = new ChainedInstrumentation( new ChainedInstrumentation(new SimplePerformantInstrumentation()), new ChainedInstrumentation(fooInstrumentation, barInstrumentation), new SimplePerformantInstrumentation()) - def graphql = GraphQL.newGraphQL(schema).instrumentation(chainedInstrumentation).build(); + def graphql = GraphQL.newGraphQL(schema).instrumentation(chainedInstrumentation).build() - ExecutionInput ei = ExecutionInput.newExecutionInput() + ExecutionInput ei = newExecutionInput() .query("{ hello }") .profileExecution(true) .build() @@ -355,9 +355,9 @@ class ProfilerTest extends Specification { Foo : [ bar: { DataFetchingEnvironment dfe -> dfe.source.id } as DataFetcher ]]) - def graphql = GraphQL.newGraphQL(schema).build(); + def graphql = GraphQL.newGraphQL(schema).build() - ExecutionInput ei = ExecutionInput.newExecutionInput() + ExecutionInput ei = newExecutionInput() .query("{ foo { id bar } }") .profileExecution(true) .build() @@ -392,22 +392,22 @@ class ProfilerTest extends Specification { // blocking the engine for 1ms // so that engineTotalRunningTime time is more than 1ms Thread.sleep(1) - return CompletableFuture.supplyAsync { + return supplyAsync { Thread.sleep(500) "1" } } as DataFetcher], Foo : [ id: { DataFetchingEnvironment dfe -> - return CompletableFuture.supplyAsync { + return supplyAsync { Thread.sleep(500) dfe.source } } as DataFetcher ]]) - def graphql = GraphQL.newGraphQL(schema).build(); + def graphql = GraphQL.newGraphQL(schema).build() - ExecutionInput ei = ExecutionInput.newExecutionInput() + ExecutionInput ei = newExecutionInput() .query("{ foo { id } }") .profileExecution(true) .build() @@ -456,10 +456,10 @@ class ProfilerTest extends Specification { } as DataFetcher ]]) - def graphql = GraphQL.newGraphQL(schema).build(); + def graphql = GraphQL.newGraphQL(schema).build() ExecutionId id = ExecutionId.from("myExecutionId") - ExecutionInput ei = ExecutionInput.newExecutionInput() + ExecutionInput ei = newExecutionInput() .query("{ foo { id name text } foo2: foo { id name text} }") .profileExecution(true) .executionId(id) @@ -480,9 +480,9 @@ class ProfilerTest extends Specification { "/foo2/text": MATERIALIZED, "/foo2" : COMPLETABLE_FUTURE_NOT_COMPLETED, "/foo" : COMPLETABLE_FUTURE_NOT_COMPLETED] - profilerResult.shortSummaryMap().get("dataFetcherResultTypes") == ["COMPLETABLE_FUTURE_COMPLETED" : "(count:2, invocations:4)", - "COMPLETABLE_FUTURE_NOT_COMPLETED": "(count:2, invocations:2)", - "MATERIALIZED" : "(count:2, invocations:4)"] + profilerResult.shortSummaryMap().get("dataFetcherResultTypes") == ["COMPLETABLE_FUTURE_COMPLETED" : ["count":2, "invocations":4], + "COMPLETABLE_FUTURE_NOT_COMPLETED": ["count":2, "invocations":2], + "MATERIALIZED" : ["count":2, "invocations":4]] profilerResult.shortSummaryMap().get("executionId") == "myExecutionId" } @@ -496,9 +496,9 @@ class ProfilerTest extends Specification { def schema = TestUtil.schema(sdl, [Query: [ hello: { DataFetchingEnvironment dfe -> return "world" } as DataFetcher ]]) - def graphql = GraphQL.newGraphQL(schema).build(); + def graphql = GraphQL.newGraphQL(schema).build() - ExecutionInput ei = ExecutionInput.newExecutionInput() + ExecutionInput ei = newExecutionInput() .query("query MyQuery { hello }") .profileExecution(true) .build() @@ -544,10 +544,10 @@ class ProfilerTest extends Specification { } } - DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader); + DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader) - DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); - dataLoaderRegistry.register("name", nameDataLoader); + DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry() + dataLoaderRegistry.register("name", nameDataLoader) def dogDF = { env -> return env.getDataLoader("name").load("Key1").thenCompose { From 7c5e38730c6c6ccd06e6ca2f4d204aeaca01531a Mon Sep 17 00:00:00 2001 From: dondonz <13839920+dondonz@users.noreply.github.com> Date: Fri, 1 Aug 2025 07:26:36 +1000 Subject: [PATCH 19/21] Add a few more tweaks and remove concatenation on operation name --- src/main/java/graphql/ProfilerResult.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/graphql/ProfilerResult.java b/src/main/java/graphql/ProfilerResult.java index 9042fe7305..d512025cfd 100644 --- a/src/main/java/graphql/ProfilerResult.java +++ b/src/main/java/graphql/ProfilerResult.java @@ -274,9 +274,10 @@ public List getInstrumentationClasses() { public Map shortSummaryMap() { Map result = new LinkedHashMap<>(); result.put("executionId", Assert.assertNotNull(executionId).toString()); - result.put("operation", operationType + ":" + operationName); - result.put("startTime", startTime); - result.put("endTime", endTime); + result.put("operationName", operationName); + result.put("operationType", operationType.toString()); + result.put("startTimeNs", startTime); + result.put("endTimeNs", endTime); result.put("totalRunTimeNs", endTime - startTime); result.put("engineTotalRunningTimeNs", engineTotalRunningTime); result.put("totalDataFetcherInvocations", totalDataFetcherInvocations); From 0f22f0793174b0634c9a347b80348890d9cac480 Mon Sep 17 00:00:00 2001 From: dondonz <13839920+dondonz@users.noreply.github.com> Date: Fri, 1 Aug 2025 07:48:06 +1000 Subject: [PATCH 20/21] Add assert --- src/main/java/graphql/ProfilerResult.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/graphql/ProfilerResult.java b/src/main/java/graphql/ProfilerResult.java index d512025cfd..c18533ab7a 100644 --- a/src/main/java/graphql/ProfilerResult.java +++ b/src/main/java/graphql/ProfilerResult.java @@ -275,7 +275,7 @@ public Map shortSummaryMap() { Map result = new LinkedHashMap<>(); result.put("executionId", Assert.assertNotNull(executionId).toString()); result.put("operationName", operationName); - result.put("operationType", operationType.toString()); + result.put("operationType", Assert.assertNotNull(operationType).toString()); result.put("startTimeNs", startTime); result.put("endTimeNs", endTime); result.put("totalRunTimeNs", endTime - startTime); From a9eb7f2dde84ce1005aad4940b99cb47d8b6dffc Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Thu, 31 Jul 2025 22:55:37 +0000 Subject: [PATCH 21/21] Add performance results for commit d61c53a270cff0016e5a0f1f4a43a367f0e76ec8 --- ...0cff0016e5a0f1f4a43a367f0e76ec8-jdk17.json | 1279 +++++++++++++++++ 1 file changed, 1279 insertions(+) create mode 100644 performance-results/2025-07-31T22:55:18Z-d61c53a270cff0016e5a0f1f4a43a367f0e76ec8-jdk17.json diff --git a/performance-results/2025-07-31T22:55:18Z-d61c53a270cff0016e5a0f1f4a43a367f0e76ec8-jdk17.json b/performance-results/2025-07-31T22:55:18Z-d61c53a270cff0016e5a0f1f4a43a367f0e76ec8-jdk17.json new file mode 100644 index 0000000000..ec6df10b4e --- /dev/null +++ b/performance-results/2025-07-31T22:55:18Z-d61c53a270cff0016e5a0f1f4a43a367f0e76ec8-jdk17.json @@ -0,0 +1,1279 @@ +[ + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "5" + }, + "primaryMetric" : { + "score" : 3.3447429434627516, + "scoreError" : 0.03581451591722982, + "scoreConfidence" : [ + 3.308928427545522, + 3.380557459379981 + ], + "scorePercentiles" : { + "0.0" : 3.337836809185784, + "50.0" : 3.345077001097102, + "90.0" : 3.3509809624710187, + "95.0" : 3.3509809624710187, + "99.0" : 3.3509809624710187, + "99.9" : 3.3509809624710187, + "99.99" : 3.3509809624710187, + "99.999" : 3.3509809624710187, + "99.9999" : 3.3509809624710187, + "100.0" : 3.3509809624710187 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.337836809185784, + 3.346708212858601 + ], + [ + 3.343445789335603, + 3.3509809624710187 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "10" + }, + "primaryMetric" : { + "score" : 1.6833351354222796, + "scoreError" : 0.029750920572430017, + "scoreConfidence" : [ + 1.6535842148498496, + 1.7130860559947096 + ], + "scorePercentiles" : { + "0.0" : 1.6779923228996667, + "50.0" : 1.6834081003792578, + "90.0" : 1.6885320180309362, + "95.0" : 1.6885320180309362, + "99.0" : 1.6885320180309362, + "99.9" : 1.6885320180309362, + "99.99" : 1.6885320180309362, + "99.999" : 1.6885320180309362, + "99.9999" : 1.6885320180309362, + "100.0" : 1.6885320180309362 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.6885320180309362, + 1.6854113765992647 + ], + [ + 1.6779923228996667, + 1.6814048241592512 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ComplexQueryPerformance.benchMarkSimpleQueriesThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 2, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "howManyItems" : "20" + }, + "primaryMetric" : { + "score" : 0.8509271113617204, + "scoreError" : 0.01930545126804809, + "scoreConfidence" : [ + 0.8316216600936723, + 0.8702325626297684 + ], + "scorePercentiles" : { + "0.0" : 0.848026120672921, + "50.0" : 0.8503695143478552, + "90.0" : 0.8549432960782498, + "95.0" : 0.8549432960782498, + "99.0" : 0.8549432960782498, + "99.9" : 0.8549432960782498, + "99.99" : 0.8549432960782498, + "99.999" : 0.8549432960782498, + "99.9999" : 0.8549432960782498, + "100.0" : 0.8549432960782498 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.8494726115078388, + 0.8512664171878717 + ], + [ + 0.848026120672921, + 0.8549432960782498 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 16.23359191816515, + "scoreError" : 0.20565572903796425, + "scoreConfidence" : [ + 16.027936189127185, + 16.439247647203114 + ], + "scorePercentiles" : { + "0.0" : 16.146802884674425, + "50.0" : 16.240562669235327, + "90.0" : 16.30811201802358, + "95.0" : 16.30811201802358, + "99.0" : 16.30811201802358, + "99.9" : 16.30811201802358, + "99.99" : 16.30811201802358, + "99.999" : 16.30811201802358, + "99.9999" : 16.30811201802358, + "100.0" : 16.30811201802358 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 16.29560499740361, + 16.294454506118964, + 16.30811201802358 + ], + [ + 16.16990627041862, + 16.18667083235169, + 16.146802884674425 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkThroughput_getImmediateFields", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2742.3468009268727, + "scoreError" : 14.196156095864847, + "scoreConfidence" : [ + 2728.150644831008, + 2756.5429570227375 + ], + "scorePercentiles" : { + "0.0" : 2738.059704068701, + "50.0" : 2739.686991758973, + "90.0" : 2749.215413532476, + "95.0" : 2749.215413532476, + "99.0" : 2749.215413532476, + "99.9" : 2749.215413532476, + "99.99" : 2749.215413532476, + "99.999" : 2749.215413532476, + "99.9999" : 2749.215413532476, + "100.0" : 2749.215413532476 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2749.215413532476, + 2748.4145869528884, + 2738.059704068701 + ], + [ + 2739.1708541459966, + 2739.0171174892253, + 2740.2031293719497 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 75882.37380601972, + "scoreError" : 216.86245467898758, + "scoreConfidence" : [ + 75665.51135134073, + 76099.23626069872 + ], + "scorePercentiles" : { + "0.0" : 75791.66267788902, + "50.0" : 75883.50426015347, + "90.0" : 75960.92447942347, + "95.0" : 75960.92447942347, + "99.0" : 75960.92447942347, + "99.9" : 75960.92447942347, + "99.99" : 75960.92447942347, + "99.999" : 75960.92447942347, + "99.9999" : 75960.92447942347, + "100.0" : 75960.92447942347 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 75818.68947607337, + 75791.66267788902, + 75828.58548661624 + ], + [ + 75960.92447942347, + 75955.95768242556, + 75938.42303369069 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 358.20639413166924, + "scoreError" : 2.503616116668585, + "scoreConfidence" : [ + 355.70277801500066, + 360.7100102483378 + ], + "scorePercentiles" : { + "0.0" : 357.1544925888796, + "50.0" : 358.1230203107281, + "90.0" : 359.6826421832757, + "95.0" : 359.6826421832757, + "99.0" : 359.6826421832757, + "99.9" : 359.6826421832757, + "99.99" : 359.6826421832757, + "99.999" : 359.6826421832757, + "99.9999" : 359.6826421832757, + "100.0" : 359.6826421832757 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 357.9541121441845, + 358.62332116975807, + 359.6826421832757 + ], + [ + 357.1544925888796, + 358.29192847727177, + 357.5318682266461 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationThroughput", + "mode" : "thrpt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 114.45953970685032, + "scoreError" : 8.540372108085162, + "scoreConfidence" : [ + 105.91916759876516, + 122.99991181493549 + ], + "scorePercentiles" : { + "0.0" : 110.93164893203861, + "50.0" : 114.61952880377628, + "90.0" : 117.37124946643245, + "95.0" : 117.37124946643245, + "99.0" : 117.37124946643245, + "99.9" : 117.37124946643245, + "99.99" : 117.37124946643245, + "99.999" : 117.37124946643245, + "99.9999" : 117.37124946643245, + "100.0" : 117.37124946643245 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 117.16683158143142, + 117.09538384235908, + 117.37124946643245 + ], + [ + 110.93164893203861, + 112.14367376519347, + 112.04845065364694 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.06161090972431956, + "scoreError" : 0.001154035149373283, + "scoreConfidence" : [ + 0.06045687457494628, + 0.06276494487369284 + ], + "scorePercentiles" : { + "0.0" : 0.061172217654075545, + "50.0" : 0.06162349173350587, + "90.0" : 0.06210324555193293, + "95.0" : 0.06210324555193293, + "99.0" : 0.06210324555193293, + "99.9" : 0.06210324555193293, + "99.99" : 0.06210324555193293, + "99.999" : 0.06210324555193293, + "99.9999" : 0.06210324555193293, + "100.0" : 0.06210324555193293 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.061172217654075545, + 0.06133272215543889, + 0.06122548204588173 + ], + [ + 0.06191752962701538, + 0.06210324555193293, + 0.06191426131157285 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DFSelectionSetPerformance.benchMarkAvgTime_getImmediateFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 3.759438405070489E-4, + "scoreError" : 1.5227227062947226E-5, + "scoreConfidence" : [ + 3.607166134441017E-4, + 3.911710675699961E-4 + ], + "scorePercentiles" : { + "0.0" : 3.7057527735488406E-4, + "50.0" : 3.7597120138570115E-4, + "90.0" : 3.811299878352407E-4, + "95.0" : 3.811299878352407E-4, + "99.0" : 3.811299878352407E-4, + "99.9" : 3.811299878352407E-4, + "99.99" : 3.811299878352407E-4, + "99.999" : 3.811299878352407E-4, + "99.9999" : 3.811299878352407E-4, + "100.0" : 3.811299878352407E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.811299878352407E-4, + 3.80545023616607E-4, + 3.810010383679906E-4 + ], + [ + 3.7057527735488406E-4, + 3.710143367127759E-4, + 3.7139737915479527E-4 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.DataLoaderPerformance.executeRequestWithDataLoaders", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.12403572272138354, + "scoreError" : 0.0016099867476702095, + "scoreConfidence" : [ + 0.12242573597371333, + 0.12564570946905373 + ], + "scorePercentiles" : { + "0.0" : 0.12342072772937082, + "50.0" : 0.12401077159131019, + "90.0" : 0.12463167110346718, + "95.0" : 0.12463167110346718, + "99.0" : 0.12463167110346718, + "99.9" : 0.12463167110346718, + "99.99" : 0.12463167110346718, + "99.999" : 0.12463167110346718, + "99.9999" : 0.12463167110346718, + "100.0" : 0.12463167110346718 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.12445210571969037, + 0.12463167110346718, + 0.1245808918787607 + ], + [ + 0.12342072772937082, + 0.12356943746293002, + 0.12355950243408209 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF1Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.013001622683439037, + "scoreError" : 3.24255455442878E-4, + "scoreConfidence" : [ + 0.012677367227996159, + 0.013325878138881916 + ], + "scorePercentiles" : { + "0.0" : 0.012887285901516811, + "50.0" : 0.013007222950893977, + "90.0" : 0.01311277812089003, + "95.0" : 0.01311277812089003, + "99.0" : 0.01311277812089003, + "99.9" : 0.01311277812089003, + "99.99" : 0.01311277812089003, + "99.999" : 0.01311277812089003, + "99.9999" : 0.01311277812089003, + "100.0" : 0.01311277812089003 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.012887285901516811, + 0.012890106533732052, + 0.0129117874132664 + ], + [ + 0.013102658488521553, + 0.01311277812089003, + 0.013105119642707372 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENF2Performance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 0.9898452145949371, + "scoreError" : 0.028663340129279874, + "scoreConfidence" : [ + 0.9611818744656573, + 1.018508554724217 + ], + "scorePercentiles" : { + "0.0" : 0.9803023719858851, + "50.0" : 0.9895225049491614, + "90.0" : 0.9996415455817673, + "95.0" : 0.9996415455817673, + "99.0" : 0.9996415455817673, + "99.9" : 0.9996415455817673, + "99.99" : 0.9996415455817673, + "99.999" : 0.9996415455817673, + "99.9999" : 0.9996415455817673, + "100.0" : 0.9996415455817673 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.9996415455817673, + 0.9994696580051969, + 0.9983908891883797 + ], + [ + 0.9806541207099432, + 0.9803023719858851, + 0.9806127020984506 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "2" + }, + "primaryMetric" : { + "score" : 0.010542894109932498, + "scoreError" : 2.009888932115536E-4, + "scoreConfidence" : [ + 0.010341905216720943, + 0.010743883003144052 + ], + "scorePercentiles" : { + "0.0" : 0.01047359392464244, + "50.0" : 0.010543936494095782, + "90.0" : 0.01060966379222543, + "95.0" : 0.01060966379222543, + "99.0" : 0.01060966379222543, + "99.9" : 0.01060966379222543, + "99.99" : 0.01060966379222543, + "99.999" : 0.01060966379222543, + "99.9999" : 0.01060966379222543, + "100.0" : 0.01060966379222543 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.010477509751124726, + 0.01047359392464244, + 0.010481427978794542 + ], + [ + 0.010608724203410832, + 0.01060644500939702, + 0.01060966379222543 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFDeepIntrospectionPerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "5 s", + "measurementBatchSize" : 1, + "params" : { + "howDeep" : "10" + }, + "primaryMetric" : { + "score" : 3.148146948868682, + "scoreError" : 0.26140079187105253, + "scoreConfidence" : [ + 2.8867461569976296, + 3.4095477407397343 + ], + "scorePercentiles" : { + "0.0" : 3.0555105430665854, + "50.0" : 3.149699198716333, + "90.0" : 3.236624098381877, + "95.0" : 3.236624098381877, + "99.0" : 3.236624098381877, + "99.9" : 3.236624098381877, + "99.99" : 3.236624098381877, + "99.999" : 3.236624098381877, + "99.9999" : 3.236624098381877, + "100.0" : 3.236624098381877 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.236624098381877, + 3.232234904330963, + 3.2305329489664083 + ], + [ + 3.0555105430665854, + 3.0688654484662576, + 3.06511375 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.ENFExtraLargePerformance.benchMarkAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "primaryMetric" : { + "score" : 2.8055585408599355, + "scoreError" : 0.06611911919208836, + "scoreConfidence" : [ + 2.7394394216678473, + 2.8716776600520237 + ], + "scorePercentiles" : { + "0.0" : 2.785817532590529, + "50.0" : 2.796373105520504, + "90.0" : 2.84690062852263, + "95.0" : 2.84690062852263, + "99.0" : 2.84690062852263, + "99.9" : 2.84690062852263, + "99.99" : 2.84690062852263, + "99.999" : 2.84690062852263, + "99.9999" : 2.84690062852263, + "100.0" : 2.84690062852263 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.785817532590529, + 2.790505919642857, + 2.789143199386503 + ], + [ + 2.802240291398151, + 2.81874367361894, + 2.84690062852263 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkDeepAbstractConcrete", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.17818622258417713, + "scoreError" : 9.51045486120946E-4, + "scoreConfidence" : [ + 0.1772351770980562, + 0.17913726807029806 + ], + "scorePercentiles" : { + "0.0" : 0.1777865706945901, + "50.0" : 0.17822540837365275, + "90.0" : 0.1786671407514606, + "95.0" : 0.1786671407514606, + "99.0" : 0.1786671407514606, + "99.9" : 0.1786671407514606, + "99.99" : 0.1786671407514606, + "99.999" : 0.1786671407514606, + "99.9999" : 0.1786671407514606, + "100.0" : 0.1786671407514606 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.1786671407514606, + 0.17831284710161724, + 0.1783830009989119 + ], + [ + 0.17782980631279452, + 0.1777865706945901, + 0.17813796964568823 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.3346599006855217, + "scoreError" : 0.010793068198533514, + "scoreConfidence" : [ + 0.32386683248698817, + 0.34545296888405524 + ], + "scorePercentiles" : { + "0.0" : 0.3309993482391103, + "50.0" : 0.3346490690556416, + "90.0" : 0.33853017345971564, + "95.0" : 0.33853017345971564, + "99.0" : 0.33853017345971564, + "99.9" : 0.33853017345971564, + "99.99" : 0.33853017345971564, + "99.999" : 0.33853017345971564, + "99.9999" : 0.33853017345971564, + "100.0" : 0.33853017345971564 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.3310541459595458, + 0.3314079576139188, + 0.3309993482391103 + ], + [ + 0.3378901804973645, + 0.33853017345971564, + 0.33807759834347534 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkNoOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.14282208398860097, + "scoreError" : 0.0023631804398264182, + "scoreConfidence" : [ + 0.14045890354877455, + 0.14518526442842739 + ], + "scorePercentiles" : { + "0.0" : 0.14186982019634548, + "50.0" : 0.14302447002571195, + "90.0" : 0.14356884727366698, + "95.0" : 0.14356884727366698, + "99.0" : 0.14356884727366698, + "99.9" : 0.14356884727366698, + "99.99" : 0.14356884727366698, + "99.999" : 0.14356884727366698, + "99.9999" : 0.14356884727366698, + "100.0" : 0.14356884727366698 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.14356884727366698, + 0.14355641794430088, + 0.14356471303261745 + ], + [ + 0.14249252210712302, + 0.14188018337755204, + 0.14186982019634548 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.40609635142939066, + "scoreError" : 0.005372799986368221, + "scoreConfidence" : [ + 0.4007235514430224, + 0.4114691514157589 + ], + "scorePercentiles" : { + "0.0" : 0.40335263808333, + "50.0" : 0.4059603653504845, + "90.0" : 0.40936235646158253, + "95.0" : 0.40936235646158253, + "99.0" : 0.40936235646158253, + "99.9" : 0.40936235646158253, + "99.99" : 0.40936235646158253, + "99.999" : 0.40936235646158253, + "99.9999" : 0.40936235646158253, + "100.0" : 0.40936235646158253 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.40613637062908664, + 0.4060972901928934, + 0.4058234405080756 + ], + [ + 0.40936235646158253, + 0.4058060127013756, + 0.40335263808333 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkOverlapNoFrag", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.1536626369787302, + "scoreError" : 0.0018848814311616332, + "scoreConfidence" : [ + 0.15177775554756856, + 0.15554751840989184 + ], + "scorePercentiles" : { + "0.0" : 0.15280170508510835, + "50.0" : 0.15367310626538933, + "90.0" : 0.15464760590736876, + "95.0" : 0.15464760590736876, + "99.0" : 0.15464760590736876, + "99.9" : 0.15464760590736876, + "99.99" : 0.15464760590736876, + "99.999" : 0.15464760590736876, + "99.9999" : 0.15464760590736876, + "100.0" : 0.15464760590736876 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.15464760590736876, + 0.1540523418060819, + 0.153907308949596 + ], + [ + 0.15343890358118267, + 0.15280170508510835, + 0.1531279565430435 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.benchmarkRepeatedFields", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 0.04684310548716889, + "scoreError" : 0.003715849866710442, + "scoreConfidence" : [ + 0.04312725562045845, + 0.05055895535387933 + ], + "scorePercentiles" : { + "0.0" : 0.045580877894919165, + "50.0" : 0.04688522018283306, + "90.0" : 0.04809616717487495, + "95.0" : 0.04809616717487495, + "99.0" : 0.04809616717487495, + "99.9" : 0.04809616717487495, + "99.99" : 0.04809616717487495, + "99.999" : 0.04809616717487495, + "99.9999" : 0.04809616717487495, + "100.0" : 0.04809616717487495 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.04809616717487495, + 0.04802994055406665, + 0.04802794923036285 + ], + [ + 0.045742491135303265, + 0.045580877894919165, + 0.04558120693348648 + ] + ] + }, + "secondaryMetrics" : { + } + }, + { + "jmhVersion" : "1.37", + "benchmark" : "performance.OverlappingFieldValidationPerformance.overlappingFieldValidationAvgTime", + "mode" : "avgt", + "threads" : 1, + "forks" : 2, + "jvm" : "/home/ec2-user/.sdkman/candidates/java/17.0.10-amzn/bin/java", + "jvmArgs" : [ + ], + "jdkVersion" : "17.0.10", + "vmName" : "OpenJDK 64-Bit Server VM", + "vmVersion" : "17.0.10+7-LTS", + "warmupIterations" : 2, + "warmupTime" : "5 s", + "warmupBatchSize" : 1, + "measurementIterations" : 3, + "measurementTime" : "10 s", + "measurementBatchSize" : 1, + "params" : { + "size" : "100" + }, + "primaryMetric" : { + "score" : 8650758.197539447, + "scoreError" : 323224.16376427445, + "scoreConfidence" : [ + 8327534.033775172, + 8973982.36130372 + ], + "scorePercentiles" : { + "0.0" : 8534389.760238908, + "50.0" : 8652048.152955076, + "90.0" : 8767666.733567046, + "95.0" : 8767666.733567046, + "99.0" : 8767666.733567046, + "99.9" : 8767666.733567046, + "99.99" : 8767666.733567046, + "99.999" : 8767666.733567046, + "99.9999" : 8767666.733567046, + "100.0" : 8767666.733567046 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 8767666.733567046, + 8760342.227670753, + 8737214.230567686 + ], + [ + 8566882.075342465, + 8538054.15784983, + 8534389.760238908 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + +