From 4ec1d236f212efe66b9325018303ec883fca97d9 Mon Sep 17 00:00:00 2001 From: Josh Carrier Date: Tue, 10 Jun 2025 02:36:13 +0000 Subject: [PATCH 01/14] Merged PR 223498: fix(ExecutionInput): support null query when running APQ request Support null query when running APQ request Full issue described in https://github.com/graphql-java/graphql-java/issues/4008 ---- #### AI description (iteration 1) #### PR Classification Bug fix: Enhance ExecutionInput to properly handle null queries in automatic persisted query (APQ) requests. #### PR Summary This pull request modifies the ExecutionInput logic to return a persisted query marker when a null or empty query is provided along with a persistedQuery extension, ensuring graceful handling of APQ requests. - `src/main/java/graphql/ExecutionInput.java`: Introduces a new static method (`assertQuery`) to check for null/empty queries and returns a persisted query marker if appropriate; also removes the strict non-null assertion in the builder. - `src/test/groovy/graphql/ExecutionInputTest.groovy`: Adds a test case validating that a null query with the persistedQuery extension returns the expected persisted query marker. Related work items: #355548 # Conflicts: # src/test/groovy/graphql/ExecutionInputTest.groovy --- src/main/java/graphql/ExecutionInput.java | 17 ++++++-- .../groovy/graphql/ExecutionInputTest.groovy | 43 +++++++++++++++++++ 2 files changed, 56 insertions(+), 4 deletions(-) diff --git a/src/main/java/graphql/ExecutionInput.java b/src/main/java/graphql/ExecutionInput.java index fa2ffe21ad..dc53ca4d59 100644 --- a/src/main/java/graphql/ExecutionInput.java +++ b/src/main/java/graphql/ExecutionInput.java @@ -3,6 +3,7 @@ import graphql.collect.ImmutableKit; import graphql.execution.ExecutionId; import graphql.execution.RawVariables; +import graphql.execution.preparsed.persisted.PersistedQuerySupport; import org.dataloader.DataLoaderRegistry; import java.util.Locale; @@ -34,7 +35,7 @@ public class ExecutionInput { @Internal private ExecutionInput(Builder builder) { - this.query = assertNotNull(builder.query, () -> "query can't be null"); + this.query = assertQuery(builder); this.operationName = builder.operationName; this.context = builder.context; this.graphQLContext = assertNotNull(builder.graphQLContext); @@ -48,6 +49,14 @@ private ExecutionInput(Builder builder) { this.cancelled = builder.cancelled; } + private static String assertQuery(Builder builder) { + if ((builder.query == null || builder.query.isEmpty()) && builder.extensions.containsKey("persistedQuery")) { + return PersistedQuerySupport.PERSISTED_QUERY_MARKER; + } + + return assertNotNull(builder.query, () -> "query can't be null"); + } + /** * @return the query text */ @@ -252,7 +261,7 @@ GraphQLContext graphQLContext() { } public Builder query(String query) { - this.query = assertNotNull(query, () -> "query can't be null"); + this.query = query; return this; } @@ -312,7 +321,7 @@ public Builder context(Object context) { return this; } - /** + /** * This will give you a builder of {@link GraphQLContext} and any values you set will be copied * into the underlying {@link GraphQLContext} of this execution input * @@ -393,4 +402,4 @@ public ExecutionInput build() { return new ExecutionInput(this); } } -} +} \ No newline at end of file diff --git a/src/test/groovy/graphql/ExecutionInputTest.groovy b/src/test/groovy/graphql/ExecutionInputTest.groovy index 54ff68d735..23c06ea9c7 100644 --- a/src/test/groovy/graphql/ExecutionInputTest.groovy +++ b/src/test/groovy/graphql/ExecutionInputTest.groovy @@ -8,6 +8,7 @@ import graphql.execution.instrumentation.InstrumentationState import graphql.execution.instrumentation.parameters.InstrumentationExecutionStrategyParameters import graphql.execution.instrumentation.parameters.InstrumentationFieldCompleteParameters import graphql.execution.instrumentation.parameters.InstrumentationFieldParameters +import graphql.execution.preparsed.persisted.PersistedQuerySupport import graphql.schema.DataFetcher import graphql.schema.DataFetchingEnvironment import org.dataloader.DataLoaderRegistry @@ -45,6 +46,21 @@ class ExecutionInputTest extends Specification { executionInput.query == query executionInput.locale == Locale.GERMAN executionInput.extensions == [some: "map"] + executionInput.toString() != null + } + + def "build without locale"() { + when: + def executionInput = ExecutionInput.newExecutionInput().query(query) + .dataLoaderRegistry(registry) + .variables(variables) + .root(root) + .graphQLContext({ it.of(["a": "b"]) }) + .locale(null) + .extensions([some: "map"]) + .build() + then: + executionInput.locale == Locale.getDefault() } def "map context build works"() { @@ -314,6 +330,33 @@ class ExecutionInputTest extends Specification { "1000 ms" | plusOrMinus(1000) } + def "uses persisted query marker when query is null"() { + when: + ExecutionInput.newExecutionInput().query(null).build() + then: + thrown(AssertException) + } + + def "uses persisted query marker when query is null and extensions contains persistedQuery"() { + when: + def executionInput = ExecutionInput.newExecutionInput() + .extensions([persistedQuery: "any"]) + .query(null) + .build() + then: + executionInput.query == PersistedQuerySupport.PERSISTED_QUERY_MARKER + } + + def "uses persisted query marker when query is empty and extensions contains persistedQuery"() { + when: + def executionInput = ExecutionInput.newExecutionInput() + .extensions([persistedQuery: "any"]) + .query("") + .build() + then: + executionInput.query == PersistedQuerySupport.PERSISTED_QUERY_MARKER + } + def "can cancel at specific places"() { def sdl = ''' type Query { From b4601546fc8d7f01bc1126f8d6d373cfe80dd3f2 Mon Sep 17 00:00:00 2001 From: Tim Ward Date: Sun, 20 Jul 2025 01:03:42 -0700 Subject: [PATCH 02/14] Add constant, and note on implementation specifics around Apollo Automatic Persisted Query support --- src/main/java/graphql/ExecutionInput.java | 29 +++++++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-) diff --git a/src/main/java/graphql/ExecutionInput.java b/src/main/java/graphql/ExecutionInput.java index dc53ca4d59..f2da73f034 100644 --- a/src/main/java/graphql/ExecutionInput.java +++ b/src/main/java/graphql/ExecutionInput.java @@ -32,6 +32,15 @@ public class ExecutionInput { private final Locale locale; private final AtomicBoolean cancelled; + /** + * In order for {@link #getQuery()} to never be null, use this to mark + * them so that invariant can be satisfied while assuming that the persisted query + * id is elsewhere. + */ + public final static String PERSISTED_QUERY_MARKER = PersistedQuerySupport.PERSISTED_QUERY_MARKER; + + private final static String APOLLO_AUTOMATIC_PERSISTED_QUERY_EXTENSION = "persistedQuery"; + @Internal private ExecutionInput(Builder builder) { @@ -50,13 +59,29 @@ private ExecutionInput(Builder builder) { } private static String assertQuery(Builder builder) { - if ((builder.query == null || builder.query.isEmpty()) && builder.extensions.containsKey("persistedQuery")) { - return PersistedQuerySupport.PERSISTED_QUERY_MARKER; + if ((builder.query == null || builder.query.isEmpty()) && isPersistedQuery(builder)) { + return PERSISTED_QUERY_MARKER; } return assertNotNull(builder.query, () -> "query can't be null"); } + /** + * This is used to determine if this execution input is a persisted query or not. + * + * @implNote The current implementation supports Apollo Persisted Queries (APQ) by checking for + * the extensions property for the persisted query extension. + * See Apollo Persisted Queries for more details. + * + * @param builder the builder to check + * + * @return true if this is a persisted query + */ + private static boolean isPersistedQuery(Builder builder) { + return builder.extensions != null && + builder.extensions.containsKey(APOLLO_AUTOMATIC_PERSISTED_QUERY_EXTENSION); + } + /** * @return the query text */ From b26c7f79d9555258d830934d5dc850acebe7304b Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Mon, 21 Jul 2025 14:58:37 +1000 Subject: [PATCH 03/14] stabilize test by using a separate Thread --- ...etionStageMappingOrderedPublisherTckVerificationTest.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherTckVerificationTest.java b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherTckVerificationTest.java index 03a9a7fe86..b1b8689190 100644 --- a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherTckVerificationTest.java +++ b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherTckVerificationTest.java @@ -10,6 +10,7 @@ import java.time.Duration; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; +import java.util.concurrent.Executors; import java.util.function.Function; /** @@ -31,14 +32,14 @@ public long maxElementsFromPublisher() { @Override public Publisher createPublisher(long elements) { Publisher publisher = Flowable.range(0, (int) elements); - Function> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!"); + Function> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!", Executors.newSingleThreadExecutor()); return new CompletionStageMappingOrderedPublisher<>(publisher, mapper); } @Override public Publisher createFailedPublisher() { Publisher publisher = Flowable.error(() -> new RuntimeException("Bang")); - Function> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!"); + Function> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!", Executors.newSingleThreadExecutor()); return new CompletionStageMappingOrderedPublisher<>(publisher, mapper); } From 3264230556df4a1e112881bda39eb236b6db2bbb Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Mon, 21 Jul 2025 09:02:02 +0000 Subject: [PATCH 04/14] Add performance results for commit 43a54fc9a2e2004d5e6593943deac2988a089bcd --- ...2e2004d5e6593943deac2988a089bcd-jdk17.json | 1279 +++++++++++++++++ 1 file changed, 1279 insertions(+) create mode 100644 performance-results/2025-07-21T09:01:44Z-43a54fc9a2e2004d5e6593943deac2988a089bcd-jdk17.json diff --git a/performance-results/2025-07-21T09:01:44Z-43a54fc9a2e2004d5e6593943deac2988a089bcd-jdk17.json b/performance-results/2025-07-21T09:01:44Z-43a54fc9a2e2004d5e6593943deac2988a089bcd-jdk17.json new file mode 100644 index 0000000000..08d3754fcb --- /dev/null +++ b/performance-results/2025-07-21T09:01:44Z-43a54fc9a2e2004d5e6593943deac2988a089bcd-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.3395296683647198, + "scoreError" : 0.052074839604582555, + "scoreConfidence" : [ + 3.2874548287601373, + 3.3916045079693022 + ], + "scorePercentiles" : { + "0.0" : 3.3300617520363356, + "50.0" : 3.339731628772678, + "90.0" : 3.348593663877187, + "95.0" : 3.348593663877187, + "99.0" : 3.348593663877187, + "99.9" : 3.348593663877187, + "99.99" : 3.348593663877187, + "99.999" : 3.348593663877187, + "99.9999" : 3.348593663877187, + "100.0" : 3.348593663877187 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.343118807600336, + 3.348593663877187 + ], + [ + 3.3300617520363356, + 3.33634444994502 + ] + ] + }, + "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.6841453793729038, + "scoreError" : 0.039986765756976766, + "scoreConfidence" : [ + 1.644158613615927, + 1.7241321451298806 + ], + "scorePercentiles" : { + "0.0" : 1.6772598569488215, + "50.0" : 1.6836510465834902, + "90.0" : 1.6920195673758136, + "95.0" : 1.6920195673758136, + "99.0" : 1.6920195673758136, + "99.9" : 1.6920195673758136, + "99.99" : 1.6920195673758136, + "99.999" : 1.6920195673758136, + "99.9999" : 1.6920195673758136, + "100.0" : 1.6920195673758136 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.6772598569488215, + 1.6820743557923434 + ], + [ + 1.6852277373746372, + 1.6920195673758136 + ] + ] + }, + "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.845445131274986, + "scoreError" : 0.021027380397238386, + "scoreConfidence" : [ + 0.8244177508777476, + 0.8664725116722244 + ], + "scorePercentiles" : { + "0.0" : 0.8425504084557296, + "50.0" : 0.8449012418409492, + "90.0" : 0.849427632962316, + "95.0" : 0.849427632962316, + "99.0" : 0.849427632962316, + "99.9" : 0.849427632962316, + "99.99" : 0.849427632962316, + "99.999" : 0.849427632962316, + "99.9999" : 0.849427632962316, + "100.0" : 0.849427632962316 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.8425504084557296, + 0.8430392026928639 + ], + [ + 0.8467632809890344, + 0.849427632962316 + ] + ] + }, + "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.134890085465816, + "scoreError" : 0.426288903731031, + "scoreConfidence" : [ + 15.708601181734785, + 16.561178989196847 + ], + "scorePercentiles" : { + "0.0" : 15.95100229530205, + "50.0" : 16.135567151530807, + "90.0" : 16.302067481838954, + "95.0" : 16.302067481838954, + "99.0" : 16.302067481838954, + "99.9" : 16.302067481838954, + "99.99" : 16.302067481838954, + "99.999" : 16.302067481838954, + "99.9999" : 16.302067481838954, + "100.0" : 16.302067481838954 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 16.007061610032853, + 16.043527582506, + 15.95100229530205 + ], + [ + 16.227606720555613, + 16.278074822559443, + 16.302067481838954 + ] + ] + }, + "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" : 2665.8740617669464, + "scoreError" : 114.46676969627923, + "scoreConfidence" : [ + 2551.407292070667, + 2780.3408314632256 + ], + "scorePercentiles" : { + "0.0" : 2612.5779056346055, + "50.0" : 2667.119844069909, + "90.0" : 2725.500101763791, + "95.0" : 2725.500101763791, + "99.0" : 2725.500101763791, + "99.9" : 2725.500101763791, + "99.99" : 2725.500101763791, + "99.999" : 2725.500101763791, + "99.9999" : 2725.500101763791, + "100.0" : 2725.500101763791 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2612.5779056346055, + 2648.559111065983, + 2636.9217069611495 + ], + [ + 2686.004968102314, + 2725.500101763791, + 2685.6805770738356 + ] + ] + }, + "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" : 75890.4625431142, + "scoreError" : 1933.2438813452575, + "scoreConfidence" : [ + 73957.21866176894, + 77823.70642445947 + ], + "scorePercentiles" : { + "0.0" : 75171.86796656065, + "50.0" : 75898.53799604665, + "90.0" : 76624.48414828714, + "95.0" : 76624.48414828714, + "99.0" : 76624.48414828714, + "99.9" : 76624.48414828714, + "99.99" : 76624.48414828714, + "99.999" : 76624.48414828714, + "99.9999" : 76624.48414828714, + "100.0" : 76624.48414828714 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 76624.48414828714, + 76521.80172849288, + 76390.02021178631 + ], + [ + 75171.86796656065, + 75407.05578030701, + 75227.54542325121 + ] + ] + }, + "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.7245600605024, + "scoreError" : 24.35427538070495, + "scoreConfidence" : [ + 334.37028467979746, + 383.0788354412074 + ], + "scorePercentiles" : { + "0.0" : 349.08482301369224, + "50.0" : 358.0562225279694, + "90.0" : 368.7800317782533, + "95.0" : 368.7800317782533, + "99.0" : 368.7800317782533, + "99.9" : 368.7800317782533, + "99.99" : 368.7800317782533, + "99.999" : 368.7800317782533, + "99.9999" : 368.7800317782533, + "100.0" : 368.7800317782533 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 366.5370553245632, + 364.12600209537857, + 368.7800317782533 + ], + [ + 349.08482301369224, + 351.9864429605602, + 351.8330051905671 + ] + ] + }, + "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" : 116.64367989581547, + "scoreError" : 1.2034438547428785, + "scoreConfidence" : [ + 115.4402360410726, + 117.84712375055834 + ], + "scorePercentiles" : { + "0.0" : 115.91318028612135, + "50.0" : 116.81532519696273, + "90.0" : 117.02108909877536, + "95.0" : 117.02108909877536, + "99.0" : 117.02108909877536, + "99.9" : 117.02108909877536, + "99.99" : 117.02108909877536, + "99.999" : 117.02108909877536, + "99.9999" : 117.02108909877536, + "100.0" : 117.02108909877536 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 116.75727205747702, + 117.02108909877536, + 115.91318028612135 + ], + [ + 116.34932224927984, + 116.94783734679078, + 116.87337833644843 + ] + ] + }, + "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.06136364903368103, + "scoreError" : 3.025204838736298E-4, + "scoreConfidence" : [ + 0.0610611285498074, + 0.06166616951755466 + ], + "scorePercentiles" : { + "0.0" : 0.06121976743516909, + "50.0" : 0.06140227874427741, + "90.0" : 0.061469299898577, + "95.0" : 0.061469299898577, + "99.0" : 0.061469299898577, + "99.9" : 0.061469299898577, + "99.99" : 0.061469299898577, + "99.999" : 0.061469299898577, + "99.9999" : 0.061469299898577, + "100.0" : 0.061469299898577 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.06123948405349794, + 0.061383857739147514, + 0.0614206997494073 + ], + [ + 0.061469299898577, + 0.06121976743516909, + 0.06144878532628733 + ] + ] + }, + "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.643976712244534E-4, + "scoreError" : 2.468188723939987E-5, + "scoreConfidence" : [ + 3.397157839850535E-4, + 3.8907955846385325E-4 + ], + "scorePercentiles" : { + "0.0" : 3.55307915918976E-4, + "50.0" : 3.641154636049315E-4, + "90.0" : 3.7552256004423304E-4, + "95.0" : 3.7552256004423304E-4, + "99.0" : 3.7552256004423304E-4, + "99.9" : 3.7552256004423304E-4, + "99.99" : 3.7552256004423304E-4, + "99.999" : 3.7552256004423304E-4, + "99.9999" : 3.7552256004423304E-4, + "100.0" : 3.7552256004423304E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.7552256004423304E-4, + 3.6943930681771625E-4, + 3.7150591145516693E-4 + ], + [ + 3.55307915918976E-4, + 3.558187127184809E-4, + 3.5879162039214674E-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.12749728648834927, + "scoreError" : 0.003829018675387292, + "scoreConfidence" : [ + 0.12366826781296197, + 0.13132630516373656 + ], + "scorePercentiles" : { + "0.0" : 0.12600521034991116, + "50.0" : 0.12759610020486023, + "90.0" : 0.1292823132821388, + "95.0" : 0.1292823132821388, + "99.0" : 0.1292823132821388, + "99.9" : 0.1292823132821388, + "99.99" : 0.1292823132821388, + "99.999" : 0.1292823132821388, + "99.9999" : 0.1292823132821388, + "100.0" : 0.1292823132821388 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.12607663913613557, + 0.12600521034991116, + 0.12688650007613053 + ], + [ + 0.1292823132821388, + 0.12830570033358993, + 0.12842735575218966 + ] + ] + }, + "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.013145683190638602, + "scoreError" : 1.8475533071340449E-4, + "scoreConfidence" : [ + 0.012960927859925198, + 0.013330438521352007 + ], + "scorePercentiles" : { + "0.0" : 0.013074028748074876, + "50.0" : 0.013142266174467974, + "90.0" : 0.013234839565532721, + "95.0" : 0.013234839565532721, + "99.0" : 0.013234839565532721, + "99.9" : 0.013234839565532721, + "99.99" : 0.013234839565532721, + "99.999" : 0.013234839565532721, + "99.9999" : 0.013234839565532721, + "100.0" : 0.013234839565532721 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.013089071269073804, + 0.013101755788938588, + 0.013074028748074876 + ], + [ + 0.013182776559997363, + 0.013191627212214271, + 0.013234839565532721 + ] + ] + }, + "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.0327181301780206, + "scoreError" : 0.011641240884108813, + "scoreConfidence" : [ + 1.0210768892939117, + 1.0443593710621295 + ], + "scorePercentiles" : { + "0.0" : 1.0278013557040082, + "50.0" : 1.0331959079865263, + "90.0" : 1.0372554411368116, + "95.0" : 1.0372554411368116, + "99.0" : 1.0372554411368116, + "99.9" : 1.0372554411368116, + "99.99" : 1.0372554411368116, + "99.999" : 1.0372554411368116, + "99.9999" : 1.0372554411368116, + "100.0" : 1.0372554411368116 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 1.031690665015991, + 1.0278013557040082, + 1.0281725106404853 + ], + [ + 1.0372554411368116, + 1.0347011509570616, + 1.036687657613766 + ] + ] + }, + "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.010855624609490862, + "scoreError" : 0.0016129789246444564, + "scoreConfidence" : [ + 0.009242645684846406, + 0.012468603534135318 + ], + "scorePercentiles" : { + "0.0" : 0.01028154978779579, + "50.0" : 0.010858672997300044, + "90.0" : 0.011439420927524428, + "95.0" : 0.011439420927524428, + "99.0" : 0.011439420927524428, + "99.9" : 0.011439420927524428, + "99.99" : 0.011439420927524428, + "99.999" : 0.011439420927524428, + "99.9999" : 0.011439420927524428, + "100.0" : 0.011439420927524428 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.010407942039574201, + 0.010310381006680963, + 0.01028154978779579 + ], + [ + 0.011439420927524428, + 0.011309403955025887, + 0.01138504994034391 + ] + ] + }, + "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.323051102738992, + "scoreError" : 0.22578671324912253, + "scoreConfidence" : [ + 3.0972643894898693, + 3.5488378159881147 + ], + "scorePercentiles" : { + "0.0" : 3.233474136393019, + "50.0" : 3.3344086587187345, + "90.0" : 3.399839808293678, + "95.0" : 3.399839808293678, + "99.0" : 3.399839808293678, + "99.9" : 3.399839808293678, + "99.99" : 3.399839808293678, + "99.999" : 3.399839808293678, + "99.9999" : 3.399839808293678, + "100.0" : 3.399839808293678 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.2794511114754097, + 3.2401548465025907, + 3.233474136393019 + ], + [ + 3.3960205078071963, + 3.3893662059620597, + 3.399839808293678 + ] + ] + }, + "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.8233421626990425, + "scoreError" : 0.09277570281225515, + "scoreConfidence" : [ + 2.7305664598867874, + 2.9161178655112976 + ], + "scorePercentiles" : { + "0.0" : 2.7830908870339455, + "50.0" : 2.826048434893754, + "90.0" : 2.861434471816881, + "95.0" : 2.861434471816881, + "99.0" : 2.861434471816881, + "99.9" : 2.861434471816881, + "99.99" : 2.861434471816881, + "99.999" : 2.861434471816881, + "99.9999" : 2.861434471816881, + "100.0" : 2.861434471816881 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.8418254893435635, + 2.861434471816881, + 2.8524076297775243 + ], + [ + 2.810271380443945, + 2.7830908870339455, + 2.791023117778398 + ] + ] + }, + "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.18183386840603266, + "scoreError" : 0.017888929166994777, + "scoreConfidence" : [ + 0.16394493923903788, + 0.19972279757302744 + ], + "scorePercentiles" : { + "0.0" : 0.17586656111286975, + "50.0" : 0.18103952522767514, + "90.0" : 0.18879722628756984, + "95.0" : 0.18879722628756984, + "99.0" : 0.18879722628756984, + "99.9" : 0.18879722628756984, + "99.99" : 0.18879722628756984, + "99.999" : 0.18879722628756984, + "99.9999" : 0.18879722628756984, + "100.0" : 0.18879722628756984 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.18564282915645652, + 0.18827697247481878, + 0.18879722628756984 + ], + [ + 0.17586656111286975, + 0.17598340010558733, + 0.17643622129889378 + ] + ] + }, + "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.3294255143815663, + "scoreError" : 0.01278462688370167, + "scoreConfidence" : [ + 0.3166408874978646, + 0.342210141265268 + ], + "scorePercentiles" : { + "0.0" : 0.3248514578677235, + "50.0" : 0.32914625044051615, + "90.0" : 0.33575594117647056, + "95.0" : 0.33575594117647056, + "99.0" : 0.33575594117647056, + "99.9" : 0.33575594117647056, + "99.99" : 0.33575594117647056, + "99.999" : 0.33575594117647056, + "99.9999" : 0.33575594117647056, + "100.0" : 0.33575594117647056 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.33575594117647056, + 0.3315880841871415, + 0.33270816088894806 + ], + [ + 0.3267044166938909, + 0.3249450254752234, + 0.3248514578677235 + ] + ] + }, + "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.1462685779301067, + "scoreError" : 0.006878577052161618, + "scoreConfidence" : [ + 0.1393900008779451, + 0.1531471549822683 + ], + "scorePercentiles" : { + "0.0" : 0.14338569941069354, + "50.0" : 0.14655260835111644, + "90.0" : 0.14902003106978406, + "95.0" : 0.14902003106978406, + "99.0" : 0.14902003106978406, + "99.9" : 0.14902003106978406, + "99.99" : 0.14902003106978406, + "99.999" : 0.14902003106978406, + "99.9999" : 0.14902003106978406, + "100.0" : 0.14902003106978406 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.14902003106978406, + 0.1480221387803434, + 0.14824434741617007 + ], + [ + 0.1438561729817596, + 0.14508307792188951, + 0.14338569941069354 + ] + ] + }, + "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.40002628351912356, + "scoreError" : 0.012611016860689536, + "scoreConfidence" : [ + 0.387415266658434, + 0.4126373003798131 + ], + "scorePercentiles" : { + "0.0" : 0.3940947955862069, + "50.0" : 0.3998577084150632, + "90.0" : 0.4057242382343395, + "95.0" : 0.4057242382343395, + "99.0" : 0.4057242382343395, + "99.9" : 0.4057242382343395, + "99.99" : 0.4057242382343395, + "99.999" : 0.4057242382343395, + "99.9999" : 0.4057242382343395, + "100.0" : 0.4057242382343395 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.39708418610283897, + 0.39736543489490206, + 0.3940947955862069 + ], + [ + 0.40353906436122994, + 0.4057242382343395, + 0.4023499819352243 + ] + ] + }, + "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.15236921783977786, + "scoreError" : 0.01105649940733485, + "scoreConfidence" : [ + 0.141312718432443, + 0.16342571724711272 + ], + "scorePercentiles" : { + "0.0" : 0.14852456077528592, + "50.0" : 0.1523615217339061, + "90.0" : 0.15635272212928947, + "95.0" : 0.15635272212928947, + "99.0" : 0.15635272212928947, + "99.9" : 0.15635272212928947, + "99.99" : 0.15635272212928947, + "99.999" : 0.15635272212928947, + "99.9999" : 0.15635272212928947, + "100.0" : 0.15635272212928947 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.14897401303499336, + 0.14852456077528592, + 0.1488345497693109 + ], + [ + 0.15635272212928947, + 0.15578043089696855, + 0.15574903043281885 + ] + ] + }, + "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.04703852858078635, + "scoreError" : 7.881321045162739E-4, + "scoreConfidence" : [ + 0.04625039647627008, + 0.04782666068530263 + ], + "scorePercentiles" : { + "0.0" : 0.046583208736077665, + "50.0" : 0.047166424486323036, + "90.0" : 0.0472888680090226, + "95.0" : 0.0472888680090226, + "99.0" : 0.0472888680090226, + "99.9" : 0.0472888680090226, + "99.99" : 0.0472888680090226, + "99.999" : 0.0472888680090226, + "99.9999" : 0.0472888680090226, + "100.0" : 0.0472888680090226 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.0471998917627957, + 0.046802493777700814, + 0.046583208736077665 + ], + [ + 0.0472888680090226, + 0.04722375198927092, + 0.04713295720985036 + ] + ] + }, + "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" : 8586794.273687998, + "scoreError" : 136819.62220666892, + "scoreConfidence" : [ + 8449974.651481329, + 8723613.895894667 + ], + "scorePercentiles" : { + "0.0" : 8543041.335610589, + "50.0" : 8573917.744420212, + "90.0" : 8668276.213171577, + "95.0" : 8668276.213171577, + "99.0" : 8668276.213171577, + "99.9" : 8668276.213171577, + "99.99" : 8668276.213171577, + "99.999" : 8668276.213171577, + "99.9999" : 8668276.213171577, + "100.0" : 8668276.213171577 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 8668276.213171577, + 8613698.919035314, + 8593692.823883161 + ], + [ + 8547913.685470086, + 8554142.664957264, + 8543041.335610589 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + + From a532f827cbe0fa628a61cba163e47919d7ff42b6 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 23 Jul 2025 16:22:07 +1000 Subject: [PATCH 05/14] fix repeat until failure usage --- src/test/groovy/graphql/ChainedDataLoaderTest.groovy | 9 ++++----- src/test/groovy/graphql/GraphqlErrorHelperTest.groovy | 2 +- .../dataloader/DeferWithDataLoaderTest.groovy | 3 ++- .../dataloader/Issue1178DataLoaderDispatchTest.groovy | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/test/groovy/graphql/ChainedDataLoaderTest.groovy b/src/test/groovy/graphql/ChainedDataLoaderTest.groovy index 391f184a73..67726cb9e5 100644 --- a/src/test/groovy/graphql/ChainedDataLoaderTest.groovy +++ b/src/test/groovy/graphql/ChainedDataLoaderTest.groovy @@ -9,8 +9,8 @@ import org.dataloader.BatchLoader import org.dataloader.DataLoader import org.dataloader.DataLoaderFactory import org.dataloader.DataLoaderRegistry +import spock.lang.RepeatUntilFailure import spock.lang.Specification -import spock.lang.Unroll import java.time.Duration import java.util.concurrent.Executors @@ -86,7 +86,7 @@ class ChainedDataLoaderTest extends Specification { batchLoadCalls == 2 } - @Unroll + @RepeatUntilFailure(maxAttempts = 20, ignoreRest = false) def "parallel different data loaders"() { given: def sdl = ''' @@ -177,8 +177,6 @@ class ChainedDataLoaderTest extends Specification { er.data == [hello: "friendsLunakey1Skipperkey2", helloDelayed: "friendsLunakey1-delayedSkipperkey2-delayed"] batchLoadCalls.get() == 6 - where: - i << (0..20) } @@ -339,7 +337,7 @@ class ChainedDataLoaderTest extends Specification { batchLoadCalls == 3 } - def "chained data loaders with two isolated data loaders"() { + def "chained data loaders with two delayed data loaders"() { given: def sdl = ''' @@ -404,6 +402,7 @@ class ChainedDataLoaderTest extends Specification { batchLoadCalls.get() == 1 } + @spock.lang.Ignore def "executor for delayed dispatching can be configured"() { given: def sdl = ''' diff --git a/src/test/groovy/graphql/GraphqlErrorHelperTest.groovy b/src/test/groovy/graphql/GraphqlErrorHelperTest.groovy index 0736b1671a..a0c4c4e9e3 100644 --- a/src/test/groovy/graphql/GraphqlErrorHelperTest.groovy +++ b/src/test/groovy/graphql/GraphqlErrorHelperTest.groovy @@ -156,7 +156,7 @@ class GraphqlErrorHelperTest extends Specification { } } - @RepeatUntilFailure(maxAttempts = 1_000) + @RepeatUntilFailure(maxAttempts = 1_000, ignoreRest = false) def "can deterministically serialize SourceLocation"() { when: def specMap = GraphqlErrorHelper.toSpecification(new TestError()) diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy index 2978d31c91..9160b3cb0b 100644 --- a/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy +++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy @@ -349,7 +349,8 @@ class DeferWithDataLoaderTest extends Specification { batchCompareDataFetchers.productsForDepartmentsBatchLoaderCounter.get() == 1 } - @RepeatUntilFailure(maxAttempts = 50) + @RepeatUntilFailure(maxAttempts = 50, ignoreRest = false) + // skip until def "dataloader in initial result and chained dataloader inside nested defer block"() { given: def sdl = ''' diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/Issue1178DataLoaderDispatchTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/Issue1178DataLoaderDispatchTest.groovy index 300c3e9371..ff0981bfd4 100644 --- a/src/test/groovy/graphql/execution/instrumentation/dataloader/Issue1178DataLoaderDispatchTest.groovy +++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/Issue1178DataLoaderDispatchTest.groovy @@ -22,7 +22,7 @@ import static graphql.schema.idl.TypeRuntimeWiring.newTypeWiring class Issue1178DataLoaderDispatchTest extends Specification { - @RepeatUntilFailure(maxAttempts = 100) + @RepeatUntilFailure(maxAttempts = 100, ignoreRest = false) def "shouldn't dispatch twice in multithreaded env"() { setup: def sdl = """ From a95016ae849ea94608e534451b6ad4fab5002e45 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 23 Jul 2025 16:24:36 +1000 Subject: [PATCH 06/14] remove wrong ignore annotation --- src/test/groovy/graphql/ChainedDataLoaderTest.groovy | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/groovy/graphql/ChainedDataLoaderTest.groovy b/src/test/groovy/graphql/ChainedDataLoaderTest.groovy index 67726cb9e5..a2f78c9461 100644 --- a/src/test/groovy/graphql/ChainedDataLoaderTest.groovy +++ b/src/test/groovy/graphql/ChainedDataLoaderTest.groovy @@ -402,7 +402,6 @@ class ChainedDataLoaderTest extends Specification { batchLoadCalls.get() == 1 } - @spock.lang.Ignore def "executor for delayed dispatching can be configured"() { given: def sdl = ''' From 677e436f6bc4bf5694b64d3aa8de915cad55777f Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Wed, 23 Jul 2025 17:21:08 +1000 Subject: [PATCH 07/14] simplify delayed dataloader dispatching by not using a batch window --- .../graphql/GraphQLUnusualConfiguration.java | 41 ---------- .../DataLoaderDispatchingContextKeys.java | 45 ----------- .../PerLevelDataLoaderDispatchStrategy.java | 35 +++------ .../graphql/ChainedDataLoaderTest.groovy | 74 +------------------ .../GraphQLUnusualConfigurationTest.groovy | 44 +---------- .../dataloader/DeferWithDataLoaderTest.groovy | 4 - 6 files changed, 12 insertions(+), 231 deletions(-) diff --git a/src/main/java/graphql/GraphQLUnusualConfiguration.java b/src/main/java/graphql/GraphQLUnusualConfiguration.java index 75720d52cd..d7a7eb9fbd 100644 --- a/src/main/java/graphql/GraphQLUnusualConfiguration.java +++ b/src/main/java/graphql/GraphQLUnusualConfiguration.java @@ -1,16 +1,11 @@ package graphql; import graphql.execution.ResponseMapFactory; -import graphql.execution.instrumentation.dataloader.DelayedDataLoaderDispatcherExecutorFactory; import graphql.introspection.GoodFaithIntrospection; import graphql.parser.ParserOptions; import graphql.schema.PropertyDataFetcherHelper; -import java.time.Duration; - import static graphql.Assert.assertNotNull; -import static graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys.DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS; -import static graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys.DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY; import static graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys.ENABLE_DATA_LOADER_CHAINING; /** @@ -364,42 +359,6 @@ public DataloaderConfig enableDataLoaderChaining(boolean enable) { return this; } - /** - * @return the batch window duration size for delayed DataLoaders. - */ - public Duration delayedDataLoaderBatchWindowSize() { - Long d = contextConfig.get(DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS); - return d != null ? Duration.ofNanos(d) : null; - } - - /** - * Sets the batch window duration size for delayed DataLoaders. - * That is for DataLoaders, that are not batched as part of the normal per level - * dispatching, because they were created after the level was already dispatched. - */ - @ExperimentalApi - public DataloaderConfig delayedDataLoaderBatchWindowSize(Duration batchWindowSize) { - contextConfig.put(DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS, batchWindowSize.toNanos()); - return this; - } - - /** - * @return the instance of {@link DelayedDataLoaderDispatcherExecutorFactory} that is used to create the - * {@link java.util.concurrent.ScheduledExecutorService} for the delayed DataLoader dispatching. - */ - public DelayedDataLoaderDispatcherExecutorFactory delayedDataLoaderExecutorFactory() { - return contextConfig.get(DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY); - } - - /** - * Sets the instance of {@link DelayedDataLoaderDispatcherExecutorFactory} that is used to create the - * {@link java.util.concurrent.ScheduledExecutorService} for the delayed DataLoader dispatching. - */ - @ExperimentalApi - public DataloaderConfig delayedDataLoaderExecutorFactory(DelayedDataLoaderDispatcherExecutorFactory delayedDataLoaderDispatcherExecutorFactory) { - contextConfig.put(DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY, delayedDataLoaderDispatcherExecutorFactory); - return this; - } } public static class ResponseMapFactoryConfig extends BaseContextConfig { diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/DataLoaderDispatchingContextKeys.java b/src/main/java/graphql/execution/instrumentation/dataloader/DataLoaderDispatchingContextKeys.java index e85322526c..4fc6284a3b 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/DataLoaderDispatchingContextKeys.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/DataLoaderDispatchingContextKeys.java @@ -5,8 +5,6 @@ import graphql.Internal; import org.jspecify.annotations.NullMarked; -import java.time.Duration; - /** * GraphQLContext keys related to DataLoader dispatching. */ @@ -16,26 +14,6 @@ public final class DataLoaderDispatchingContextKeys { private DataLoaderDispatchingContextKeys() { } - /** - * In nano seconds, the batch window size for delayed DataLoaders. - * That is for DataLoaders, that are not batched as part of the normal per level - * dispatching, because they were created after the level was already dispatched. - *

- * Expect Long values - *

- * Default is 500_000 (0.5 ms) - */ - public static final String DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS = "__GJ_delayed_data_loader_batch_window_size_nano_seconds"; - - /** - * An instance of {@link DelayedDataLoaderDispatcherExecutorFactory} that is used to create the - * {@link java.util.concurrent.ScheduledExecutorService} for the delayed DataLoader dispatching. - *

- * Default is one static executor thread pool with a single thread. - */ - public static final String DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY = "__GJ_delayed_data_loader_dispatching_executor_factory"; - - /** * Enables the ability to chain DataLoader dispatching. *

@@ -57,27 +35,4 @@ public static void setEnableDataLoaderChaining(GraphQLContext graphQLContext, bo } - /** - * Sets nanoseconds the batch window duration size for delayed DataLoaders. - * That is for DataLoaders, that are not batched as part of the normal per level - * dispatching, because they were created after the level was already dispatched. - * - * @param graphQLContext - * @param batchWindowSize - */ - public static void setDelayedDataLoaderBatchWindowSize(GraphQLContext graphQLContext, Duration batchWindowSize) { - graphQLContext.put(DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS, batchWindowSize.toNanos()); - } - - /** - * Sets the instance of {@link DelayedDataLoaderDispatcherExecutorFactory} that is used to create the - * {@link java.util.concurrent.ScheduledExecutorService} for the delayed DataLoader dispatching. - *

- * - * @param graphQLContext - * @param delayedDataLoaderDispatcherExecutorFactory - */ - public static void setDelayedDataLoaderDispatchingExecutorFactory(GraphQLContext graphQLContext, DelayedDataLoaderDispatcherExecutorFactory delayedDataLoaderDispatcherExecutorFactory) { - graphQLContext.put(DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY, delayedDataLoaderDispatcherExecutorFactory); - } } diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java index efc5a98073..e29633aeda 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java @@ -11,7 +11,6 @@ import graphql.execution.incremental.AlternativeCallContext; import graphql.schema.DataFetcher; import graphql.schema.DataFetchingEnvironment; -import graphql.util.InterThreadMemoizedSupplier; import graphql.util.LockKit; import org.dataloader.DataLoader; import org.dataloader.DataLoaderRegistry; @@ -26,9 +25,6 @@ import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Supplier; import java.util.stream.Collectors; @@ -39,13 +35,8 @@ public class PerLevelDataLoaderDispatchStrategy implements DataLoaderDispatchStr private final CallStack initialCallStack; private final ExecutionContext executionContext; - private final long batchWindowNs; private final boolean enableDataLoaderChaining; - private final InterThreadMemoizedSupplier delayedDataLoaderDispatchExecutor; - - static final InterThreadMemoizedSupplier defaultDelayedDLCFBatchWindowScheduler - = new InterThreadMemoizedSupplier<>(() -> Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors())); static final long DEFAULT_BATCH_WINDOW_NANO_SECONDS_DEFAULT = 500_000L; private final Profiler profiler; @@ -209,15 +200,6 @@ public PerLevelDataLoaderDispatchStrategy(ExecutionContext executionContext) { this.executionContext = executionContext; GraphQLContext graphQLContext = executionContext.getGraphQLContext(); - this.batchWindowNs = graphQLContext.getOrDefault(DataLoaderDispatchingContextKeys.DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS, DEFAULT_BATCH_WINDOW_NANO_SECONDS_DEFAULT); - - this.delayedDataLoaderDispatchExecutor = new InterThreadMemoizedSupplier<>(() -> { - DelayedDataLoaderDispatcherExecutorFactory delayedDataLoaderDispatcherExecutorFactory = graphQLContext.get(DataLoaderDispatchingContextKeys.DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY); - if (delayedDataLoaderDispatcherExecutorFactory != null) { - return delayedDataLoaderDispatcherExecutorFactory.createExecutor(executionContext.getExecutionId(), graphQLContext); - } - return defaultDelayedDLCFBatchWindowScheduler.get(); - }); this.enableDataLoaderChaining = graphQLContext.getBoolean(DataLoaderDispatchingContextKeys.ENABLE_DATA_LOADER_CHAINING, false); this.profiler = executionContext.getProfiler(); @@ -607,14 +589,15 @@ public void run() { } private void newDelayedDataLoader(ResultPathWithDataLoader resultPathWithDataLoader, CallStack callStack) { - callStack.lock.runLocked(() -> { - callStack.batchWindowOfDelayedDataLoaderToDispatch.add(resultPathWithDataLoader.resultPath); - if (!callStack.batchWindowOpen) { - callStack.batchWindowOpen = true; - delayedDataLoaderDispatchExecutor.get().schedule(new DispatchDelayedDataloader(callStack), this.batchWindowNs, TimeUnit.NANOSECONDS); - } - - }); + dispatchDLCFImpl(Set.of(resultPathWithDataLoader.resultPath), null, callStack); +// callStack.lock.runLocked(() -> { +// callStack.batchWindowOfDelayedDataLoaderToDispatch.add(resultPathWithDataLoader.resultPath); +// if (!callStack.batchWindowOpen) { +// callStack.batchWindowOpen = true; +// delayedDataLoaderDispatchExecutor.get().schedule(new DispatchDelayedDataloader(callStack), this.batchWindowNs, TimeUnit.NANOSECONDS); +// } +// +// }); } private static class ResultPathWithDataLoader { diff --git a/src/test/groovy/graphql/ChainedDataLoaderTest.groovy b/src/test/groovy/graphql/ChainedDataLoaderTest.groovy index a2f78c9461..38daf71289 100644 --- a/src/test/groovy/graphql/ChainedDataLoaderTest.groovy +++ b/src/test/groovy/graphql/ChainedDataLoaderTest.groovy @@ -1,8 +1,6 @@ package graphql -import graphql.execution.ExecutionId -import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys -import graphql.execution.instrumentation.dataloader.DelayedDataLoaderDispatcherExecutorFactory + import graphql.schema.DataFetcher import org.awaitility.Awaitility import org.dataloader.BatchLoader @@ -12,10 +10,6 @@ import org.dataloader.DataLoaderRegistry import spock.lang.RepeatUntilFailure import spock.lang.Specification -import java.time.Duration -import java.util.concurrent.Executors -import java.util.concurrent.ScheduledExecutorService -import java.util.concurrent.TimeUnit import java.util.concurrent.atomic.AtomicInteger import static graphql.ExecutionInput.newExecutionInput @@ -390,8 +384,6 @@ class ChainedDataLoaderTest extends Specification { def ei = eiBuilder.dataLoaderRegistry(dataLoaderRegistry).build() setEnableDataLoaderChaining(ei.graphQLContext, true); - // make the window 250ms - DataLoaderDispatchingContextKeys.setDelayedDataLoaderBatchWindowSize(ei.graphQLContext, Duration.ofMillis(250)) when: def efCF = graphQL.executeAsync(ei) @@ -399,69 +391,7 @@ class ChainedDataLoaderTest extends Specification { def er = efCF.get() then: er.data == [foo: "fooFirstValue", bar: "barFirstValue"] - batchLoadCalls.get() == 1 - } - - def "executor for delayed dispatching can be configured"() { - given: - def sdl = ''' - - type Query { - foo: String - bar: String - } - ''' - BatchLoader batchLoader = { keys -> - return supplyAsync { - Thread.sleep(250) - return keys; - } - } - - DataLoader nameDataLoader = DataLoaderFactory.newDataLoader(batchLoader); - - DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); - dataLoaderRegistry.register("dl", nameDataLoader); - - def fooDF = { env -> - return supplyAsync { - Thread.sleep(1000) - return "fooFirstValue" - }.thenCompose { - return env.getDataLoader("dl").load(it) - } - } as DataFetcher - - - def fetchers = ["Query": ["foo": fooDF]] - def schema = TestUtil.schema(sdl, fetchers) - def graphQL = GraphQL.newGraphQL(schema).build() - - def query = "{ foo } " - def ei = newExecutionInput(query).dataLoaderRegistry(dataLoaderRegistry).build() - setEnableDataLoaderChaining(ei.graphQLContext, true); - - - ScheduledExecutorService scheduledExecutorService = Mock() - DataLoaderDispatchingContextKeys.setDelayedDataLoaderDispatchingExecutorFactory(ei.getGraphQLContext(), new DelayedDataLoaderDispatcherExecutorFactory() { - @Override - ScheduledExecutorService createExecutor(ExecutionId executionId, GraphQLContext graphQLContext) { - return scheduledExecutorService - } - }) - - - when: - def efCF = graphQL.executeAsync(ei) - Awaitility.await().until { efCF.isDone() } - def er = efCF.get() - - then: - er.data == [foo: "fooFirstValue"] - 1 * scheduledExecutorService.schedule(_ as Runnable, _ as Long, _ as TimeUnit) >> { Runnable runnable, Long delay, TimeUnit timeUnit -> - return Executors.newSingleThreadScheduledExecutor().schedule(runnable, delay, timeUnit) - } - + batchLoadCalls.get() == 1 || batchLoadCalls.get() == 2 // depending on timing, it can be 1 or 2 calls } def "handling of chained DataLoaders is disabled by default"() { diff --git a/src/test/groovy/graphql/config/GraphQLUnusualConfigurationTest.groovy b/src/test/groovy/graphql/config/GraphQLUnusualConfigurationTest.groovy index d526b675f8..6149e9bb75 100644 --- a/src/test/groovy/graphql/config/GraphQLUnusualConfigurationTest.groovy +++ b/src/test/groovy/graphql/config/GraphQLUnusualConfigurationTest.groovy @@ -4,16 +4,13 @@ import graphql.ExecutionInput import graphql.ExperimentalApi import graphql.GraphQL import graphql.GraphQLContext -import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys -import graphql.execution.instrumentation.dataloader.DelayedDataLoaderDispatcherExecutorFactory import graphql.execution.ResponseMapFactory +import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys import graphql.introspection.GoodFaithIntrospection import graphql.parser.ParserOptions import graphql.schema.PropertyDataFetcherHelper import spock.lang.Specification -import java.time.Duration - import static graphql.parser.ParserOptions.newParserOptions class GraphQLUnusualConfigurationTest extends Specification { @@ -146,45 +143,6 @@ class GraphQLUnusualConfigurationTest extends Specification { GraphQL.unusualConfiguration(graphqlContext).dataloaderConfig().isDataLoaderChainingEnabled() } - def "can set data loader chaining config for extra config"() { - when: - def graphqlContext = GraphQLContext.newContext().build() - GraphQL.unusualConfiguration(graphqlContext).dataloaderConfig().delayedDataLoaderBatchWindowSize(Duration.ofMillis(10)) - - then: - graphqlContext.get(DataLoaderDispatchingContextKeys.DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS) == Duration.ofMillis(10).toNanos() - GraphQL.unusualConfiguration(graphqlContext).dataloaderConfig().delayedDataLoaderBatchWindowSize() == Duration.ofMillis(10) - - when: - DelayedDataLoaderDispatcherExecutorFactory factory = {} - graphqlContext = GraphQLContext.newContext().build() - GraphQL.unusualConfiguration(graphqlContext).dataloaderConfig().delayedDataLoaderExecutorFactory(factory) - - then: - graphqlContext.get(DataLoaderDispatchingContextKeys.DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY) == factory - GraphQL.unusualConfiguration(graphqlContext).dataloaderConfig().delayedDataLoaderExecutorFactory() == factory - - when: - graphqlContext = GraphQLContext.newContext().build() - // just to show we we can navigate the DSL - GraphQL.unusualConfiguration(graphqlContext) - .incrementalSupport() - .enableIncrementalSupport(false) - .enableIncrementalSupport(true) - .then() - .dataloaderConfig() - .enableDataLoaderChaining(true) - .then() - .dataloaderConfig() - .delayedDataLoaderBatchWindowSize(Duration.ofMillis(10)) - .delayedDataLoaderExecutorFactory(factory) - - then: - graphqlContext.get(DataLoaderDispatchingContextKeys.ENABLE_DATA_LOADER_CHAINING) == true - graphqlContext.get(DataLoaderDispatchingContextKeys.DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS) == Duration.ofMillis(10).toNanos() - graphqlContext.get(DataLoaderDispatchingContextKeys.DELAYED_DATA_LOADER_DISPATCHING_EXECUTOR_FACTORY) == factory - } - def "we can access via the ExecutionInput"() { when: def eiBuilder = ExecutionInput.newExecutionInput("query q {f}") diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy index 9160b3cb0b..362206f64b 100644 --- a/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy +++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy @@ -14,7 +14,6 @@ import org.dataloader.DataLoaderRegistry import spock.lang.RepeatUntilFailure import spock.lang.Specification -import java.time.Duration import java.util.concurrent.CompletableFuture import static graphql.ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT @@ -350,7 +349,6 @@ class DeferWithDataLoaderTest extends Specification { } @RepeatUntilFailure(maxAttempts = 50, ignoreRest = false) - // skip until def "dataloader in initial result and chained dataloader inside nested defer block"() { given: def sdl = ''' @@ -392,7 +390,6 @@ class DeferWithDataLoaderTest extends Specification { } BatchLoader addressBatchLoader = { List keys -> println "addressBatchLoader called with $keys" - assert keys.size() == 3 return CompletableFuture.completedFuture(keys.collect { it -> if (it == "owner-1") { return "Address 1" @@ -450,7 +447,6 @@ class DeferWithDataLoaderTest extends Specification { def ei = ExecutionInput.newExecutionInput(query).dataLoaderRegistry(dataLoaderRegistry).build() ei.getGraphQLContext().put(ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT, true) ei.getGraphQLContext().put(DataLoaderDispatchingContextKeys.ENABLE_DATA_LOADER_CHAINING, true) - ei.getGraphQLContext().put(DataLoaderDispatchingContextKeys.DELAYED_DATA_LOADER_BATCH_WINDOW_SIZE_NANO_SECONDS, Duration.ofSeconds(1).toNanos()) when: CompletableFuture erCF = graphQL.executeAsync(ei) From 2d19c783f15267c8b76bf917342d0911c9a094c2 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 23 Jul 2025 07:28:54 +0000 Subject: [PATCH 08/14] Add performance results for commit e8028d9097760fa289e0439c0c2ec14b36531832 --- ...7760fa289e0439c0c2ec14b36531832-jdk17.json | 1279 +++++++++++++++++ 1 file changed, 1279 insertions(+) create mode 100644 performance-results/2025-07-23T07:28:34Z-e8028d9097760fa289e0439c0c2ec14b36531832-jdk17.json diff --git a/performance-results/2025-07-23T07:28:34Z-e8028d9097760fa289e0439c0c2ec14b36531832-jdk17.json b/performance-results/2025-07-23T07:28:34Z-e8028d9097760fa289e0439c0c2ec14b36531832-jdk17.json new file mode 100644 index 0000000000..cde2d353c1 --- /dev/null +++ b/performance-results/2025-07-23T07:28:34Z-e8028d9097760fa289e0439c0c2ec14b36531832-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.3210693322577427, + "scoreError" : 0.04412599747722316, + "scoreConfidence" : [ + 3.2769433347805195, + 3.365195329734966 + ], + "scorePercentiles" : { + "0.0" : 3.311714602616375, + "50.0" : 3.323190266743688, + "90.0" : 3.32618219292722, + "95.0" : 3.32618219292722, + "99.0" : 3.32618219292722, + "99.9" : 3.32618219292722, + "99.99" : 3.32618219292722, + "99.999" : 3.32618219292722, + "99.9999" : 3.32618219292722, + "100.0" : 3.32618219292722 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.3202544428868146, + 3.326126090600561 + ], + [ + 3.311714602616375, + 3.32618219292722 + ] + ] + }, + "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.6728462100885109, + "scoreError" : 0.06637088928819275, + "scoreConfidence" : [ + 1.6064753208003182, + 1.7392170993767035 + ], + "scorePercentiles" : { + "0.0" : 1.6614069284180348, + "50.0" : 1.6736975929349045, + "90.0" : 1.6825827260661992, + "95.0" : 1.6825827260661992, + "99.0" : 1.6825827260661992, + "99.9" : 1.6825827260661992, + "99.99" : 1.6825827260661992, + "99.999" : 1.6825827260661992, + "99.9999" : 1.6825827260661992, + "100.0" : 1.6825827260661992 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.6614069284180348, + 1.6670128426393849 + ], + [ + 1.6803823432304243, + 1.6825827260661992 + ] + ] + }, + "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.8403205807665421, + "scoreError" : 0.0409450543545081, + "scoreConfidence" : [ + 0.799375526412034, + 0.8812656351210503 + ], + "scorePercentiles" : { + "0.0" : 0.8346553689345669, + "50.0" : 0.8386182143697944, + "90.0" : 0.8493905253920129, + "95.0" : 0.8493905253920129, + "99.0" : 0.8493905253920129, + "99.9" : 0.8493905253920129, + "99.99" : 0.8493905253920129, + "99.999" : 0.8493905253920129, + "99.9999" : 0.8493905253920129, + "100.0" : 0.8493905253920129 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.8346553689345669, + 0.8389997796000715 + ], + [ + 0.8382366491395175, + 0.8493905253920129 + ] + ] + }, + "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.904028462861662, + "scoreError" : 0.3210965131777212, + "scoreConfidence" : [ + 15.58293194968394, + 16.225124976039382 + ], + "scorePercentiles" : { + "0.0" : 15.772808742468323, + "50.0" : 15.885731976728243, + "90.0" : 16.039565463012917, + "95.0" : 16.039565463012917, + "99.0" : 16.039565463012917, + "99.9" : 16.039565463012917, + "99.99" : 16.039565463012917, + "99.999" : 16.039565463012917, + "99.9999" : 16.039565463012917, + "100.0" : 16.039565463012917 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 15.815260802087998, + 15.827557073905762, + 15.772808742468323 + ], + [ + 16.039565463012917, + 15.943906879550724, + 16.025071816144248 + ] + ] + }, + "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" : 2663.424897868778, + "scoreError" : 316.21383478370404, + "scoreConfidence" : [ + 2347.211063085074, + 2979.638732652482 + ], + "scorePercentiles" : { + "0.0" : 2556.047755010782, + "50.0" : 2664.87683489745, + "90.0" : 2776.4688962236846, + "95.0" : 2776.4688962236846, + "99.0" : 2776.4688962236846, + "99.9" : 2776.4688962236846, + "99.99" : 2776.4688962236846, + "99.999" : 2776.4688962236846, + "99.9999" : 2776.4688962236846, + "100.0" : 2776.4688962236846 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2568.7994825505266, + 2556.047755010782, + 2557.237235957458 + ], + [ + 2776.4688962236846, + 2761.041830225842, + 2760.9541872443733 + ] + ] + }, + "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" : 74369.42246699448, + "scoreError" : 2478.9298893132095, + "scoreConfidence" : [ + 71890.49257768127, + 76848.35235630769 + ], + "scorePercentiles" : { + "0.0" : 73430.44287823535, + "50.0" : 74350.25196964684, + "90.0" : 75243.70201380273, + "95.0" : 75243.70201380273, + "99.0" : 75243.70201380273, + "99.9" : 75243.70201380273, + "99.99" : 75243.70201380273, + "99.999" : 75243.70201380273, + "99.9999" : 75243.70201380273, + "100.0" : 75243.70201380273 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 75206.51453895739, + 75064.75683004271, + 75243.70201380273 + ], + [ + 73430.44287823535, + 73635.37143167769, + 73635.74710925095 + ] + ] + }, + "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" : 345.8325098273844, + "scoreError" : 5.333215622290192, + "scoreConfidence" : [ + 340.4992942050942, + 351.1657254496746 + ], + "scorePercentiles" : { + "0.0" : 343.0816229357919, + "50.0" : 346.2311985247809, + "90.0" : 347.89370235862117, + "95.0" : 347.89370235862117, + "99.0" : 347.89370235862117, + "99.9" : 347.89370235862117, + "99.99" : 347.89370235862117, + "99.999" : 347.89370235862117, + "99.9999" : 347.89370235862117, + "100.0" : 347.89370235862117 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 346.89084187364006, + 347.3717482904487, + 347.89370235862117 + ], + [ + 345.57155517592173, + 343.0816229357919, + 344.1855883298826 + ] + ] + }, + "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.8763820125598, + "scoreError" : 2.1504869059830325, + "scoreConfidence" : [ + 111.72589510657677, + 116.02686891854283 + ], + "scorePercentiles" : { + "0.0" : 112.93312515921971, + "50.0" : 114.02124266844669, + "90.0" : 114.78958134174972, + "95.0" : 114.78958134174972, + "99.0" : 114.78958134174972, + "99.9" : 114.78958134174972, + "99.99" : 114.78958134174972, + "99.999" : 114.78958134174972, + "99.9999" : 114.78958134174972, + "100.0" : 114.78958134174972 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 114.78958134174972, + 114.20290144982496, + 114.47976557550679 + ], + [ + 112.93312515921971, + 113.83958388706841, + 113.0133346619891 + ] + ] + }, + "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.062498624819781384, + "scoreError" : 3.5393198837301905E-4, + "scoreConfidence" : [ + 0.06214469283140837, + 0.06285255680815441 + ], + "scorePercentiles" : { + "0.0" : 0.062321238394376206, + "50.0" : 0.06246576123335251, + "90.0" : 0.06265961065196278, + "95.0" : 0.06265961065196278, + "99.0" : 0.06265961065196278, + "99.9" : 0.06265961065196278, + "99.99" : 0.06265961065196278, + "99.999" : 0.06265961065196278, + "99.9999" : 0.06265961065196278, + "100.0" : 0.06265961065196278 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.06265961065196278, + 0.06263016651844429, + 0.06244921088720001 + ], + [ + 0.062321238394376206, + 0.062479260596291296, + 0.062452261870413736 + ] + ] + }, + "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.82931855293523E-4, + "scoreError" : 4.80534574179295E-5, + "scoreConfidence" : [ + 3.348783978755935E-4, + 4.309853127114525E-4 + ], + "scorePercentiles" : { + "0.0" : 3.6712111417559713E-4, + "50.0" : 3.8238391221777574E-4, + "90.0" : 3.9972883960500013E-4, + "95.0" : 3.9972883960500013E-4, + "99.0" : 3.9972883960500013E-4, + "99.9" : 3.9972883960500013E-4, + "99.99" : 3.9972883960500013E-4, + "99.999" : 3.9972883960500013E-4, + "99.9999" : 3.9972883960500013E-4, + "100.0" : 3.9972883960500013E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.9882352020140645E-4, + 3.9972883960500013E-4, + 3.9711368449191724E-4 + ], + [ + 3.671498333435828E-4, + 3.6712111417559713E-4, + 3.6765413994363424E-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.1280177638901225, + "scoreError" : 0.004624635539129939, + "scoreConfidence" : [ + 0.12339312835099257, + 0.13264239942925246 + ], + "scorePercentiles" : { + "0.0" : 0.12643302672735318, + "50.0" : 0.1279505834810614, + "90.0" : 0.12986649093553582, + "95.0" : 0.12986649093553582, + "99.0" : 0.12986649093553582, + "99.9" : 0.12986649093553582, + "99.99" : 0.12986649093553582, + "99.999" : 0.12986649093553582, + "99.9999" : 0.12986649093553582, + "100.0" : 0.12986649093553582 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.12663277876408763, + 0.12650738700536382, + 0.12643302672735318 + ], + [ + 0.12939851171035946, + 0.12986649093553582, + 0.12926838819803516 + ] + ] + }, + "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.013281114539635106, + "scoreError" : 7.986062210596716E-5, + "scoreConfidence" : [ + 0.013201253917529139, + 0.013360975161741073 + ], + "scorePercentiles" : { + "0.0" : 0.013235320004658772, + "50.0" : 0.013280349961591307, + "90.0" : 0.013316014101480056, + "95.0" : 0.013316014101480056, + "99.0" : 0.013316014101480056, + "99.9" : 0.013316014101480056, + "99.99" : 0.013316014101480056, + "99.999" : 0.013316014101480056, + "99.9999" : 0.013316014101480056, + "100.0" : 0.013316014101480056 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.013235320004658772, + 0.013276786587980696, + 0.01326948811269355 + ], + [ + 0.013316014101480056, + 0.01328391333520192, + 0.013305165095795636 + ] + ] + }, + "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.0165166842574735, + "scoreError" : 0.0352455868899257, + "scoreConfidence" : [ + 0.9812710973675478, + 1.0517622711473993 + ], + "scorePercentiles" : { + "0.0" : 1.0028103538554096, + "50.0" : 1.0171845207526777, + "90.0" : 1.0288915903292182, + "95.0" : 1.0288915903292182, + "99.0" : 1.0288915903292182, + "99.9" : 1.0288915903292182, + "99.99" : 1.0288915903292182, + "99.999" : 1.0288915903292182, + "99.9999" : 1.0288915903292182, + "100.0" : 1.0288915903292182 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 1.026361710591133, + 1.028337266529563, + 1.0288915903292182 + ], + [ + 1.0046918533252964, + 1.0028103538554096, + 1.0080073309142223 + ] + ] + }, + "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.01152877189871051, + "scoreError" : 9.0023643687256E-4, + "scoreConfidence" : [ + 0.010628535461837951, + 0.01242900833558307 + ], + "scorePercentiles" : { + "0.0" : 0.011226953346446085, + "50.0" : 0.011510304062614371, + "90.0" : 0.01185988414373814, + "95.0" : 0.01185988414373814, + "99.0" : 0.01185988414373814, + "99.9" : 0.01185988414373814, + "99.99" : 0.01185988414373814, + "99.999" : 0.01185988414373814, + "99.9999" : 0.01185988414373814, + "100.0" : 0.01185988414373814 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.011830040583159633, + 0.011771952249446143, + 0.01185988414373814 + ], + [ + 0.0112486558757826, + 0.011235145193690455, + 0.011226953346446085 + ] + ] + }, + "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.380113235191704, + "scoreError" : 0.34118619387210386, + "scoreConfidence" : [ + 3.0389270413196003, + 3.7212994290638077 + ], + "scorePercentiles" : { + "0.0" : 3.246664155094095, + "50.0" : 3.3967437457418215, + "90.0" : 3.4949635296995107, + "95.0" : 3.4949635296995107, + "99.0" : 3.4949635296995107, + "99.9" : 3.4949635296995107, + "99.99" : 3.4949635296995107, + "99.999" : 3.4949635296995107, + "99.9999" : 3.4949635296995107, + "100.0" : 3.4949635296995107 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.4928898324022346, + 3.4949635296995107, + 3.478922445757997 + ], + [ + 3.314565045725646, + 3.252674402470741, + 3.246664155094095 + ] + ] + }, + "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.890360681688394, + "scoreError" : 0.09906966435672872, + "scoreConfidence" : [ + 2.791291017331665, + 2.989430346045123 + ], + "scorePercentiles" : { + "0.0" : 2.846870462852263, + "50.0" : 2.900062499935226, + "90.0" : 2.924440034502924, + "95.0" : 2.924440034502924, + "99.0" : 2.924440034502924, + "99.9" : 2.924440034502924, + "99.99" : 2.924440034502924, + "99.999" : 2.924440034502924, + "99.9999" : 2.924440034502924, + "100.0" : 2.924440034502924 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.924440034502924, + 2.9199205772262773, + 2.916818213764946 + ], + [ + 2.8833067861055057, + 2.846870462852263, + 2.8508080156784494 + ] + ] + }, + "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.17554518688559415, + "scoreError" : 0.004750111818234367, + "scoreConfidence" : [ + 0.17079507506735978, + 0.18029529870382852 + ], + "scorePercentiles" : { + "0.0" : 0.17391181494556712, + "50.0" : 0.175523412460851, + "90.0" : 0.17719244254655633, + "95.0" : 0.17719244254655633, + "99.0" : 0.17719244254655633, + "99.9" : 0.17719244254655633, + "99.99" : 0.17719244254655633, + "99.999" : 0.17719244254655633, + "99.9999" : 0.17719244254655633, + "100.0" : 0.17719244254655633 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.17391181494556712, + 0.17397717526096032, + 0.17411743329735 + ], + [ + 0.17714286363877915, + 0.176929391624352, + 0.17719244254655633 + ] + ] + }, + "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.3284708466388047, + "scoreError" : 0.025412264021217428, + "scoreConfidence" : [ + 0.3030585826175873, + 0.35388311066002215 + ], + "scorePercentiles" : { + "0.0" : 0.3199065666986564, + "50.0" : 0.3280011422187443, + "90.0" : 0.33808313735632184, + "95.0" : 0.33808313735632184, + "99.0" : 0.33808313735632184, + "99.9" : 0.33808313735632184, + "99.99" : 0.33808313735632184, + "99.999" : 0.33808313735632184, + "99.9999" : 0.33808313735632184, + "100.0" : 0.33808313735632184 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.33651154667205063, + 0.335530231337024, + 0.33808313735632184 + ], + [ + 0.320321544668311, + 0.3199065666986564, + 0.32047205310046467 + ] + ] + }, + "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.14497358251569623, + "scoreError" : 0.008356850940807696, + "scoreConfidence" : [ + 0.13661673157488852, + 0.15333043345650393 + ], + "scorePercentiles" : { + "0.0" : 0.14197348209037863, + "50.0" : 0.1449930684363192, + "90.0" : 0.14793544317223628, + "95.0" : 0.14793544317223628, + "99.0" : 0.14793544317223628, + "99.9" : 0.14793544317223628, + "99.99" : 0.14793544317223628, + "99.999" : 0.14793544317223628, + "99.9999" : 0.14793544317223628, + "100.0" : 0.14793544317223628 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.14197348209037863, + 0.1422311287299104, + 0.14258538193483994 + ], + [ + 0.14793544317223628, + 0.14771530422901372, + 0.14740075493779847 + ] + ] + }, + "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.41140711342600295, + "scoreError" : 0.019916798435813315, + "scoreConfidence" : [ + 0.3914903149901896, + 0.4313239118618163 + ], + "scorePercentiles" : { + "0.0" : 0.4047791495992876, + "50.0" : 0.41058531593608677, + "90.0" : 0.4196176641910037, + "95.0" : 0.4196176641910037, + "99.0" : 0.4196176641910037, + "99.9" : 0.4196176641910037, + "99.99" : 0.4196176641910037, + "99.999" : 0.4196176641910037, + "99.9999" : 0.4196176641910037, + "100.0" : 0.4196176641910037 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.4051201206400648, + 0.4051212531901965, + 0.4047791495992876 + ], + [ + 0.4196176641910037, + 0.41775511425348816, + 0.41604937868197706 + ] + ] + }, + "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.16088846584649133, + "scoreError" : 0.012547586364348488, + "scoreConfidence" : [ + 0.14834087948214283, + 0.17343605221083983 + ], + "scorePercentiles" : { + "0.0" : 0.15652884564934963, + "50.0" : 0.16068996562679355, + "90.0" : 0.16583116544507828, + "95.0" : 0.16583116544507828, + "99.0" : 0.16583116544507828, + "99.9" : 0.16583116544507828, + "99.99" : 0.16583116544507828, + "99.999" : 0.16583116544507828, + "99.9999" : 0.16583116544507828, + "100.0" : 0.16583116544507828 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.1572895279258875, + 0.15652884564934963, + 0.1567057351876518 + ], + [ + 0.16583116544507828, + 0.1648851175432811, + 0.16409040332769964 + ] + ] + }, + "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.04837959948905729, + "scoreError" : 0.0037902092083928873, + "scoreConfidence" : [ + 0.0445893902806644, + 0.05216980869745018 + ], + "scorePercentiles" : { + "0.0" : 0.04707020434809212, + "50.0" : 0.04836821901307904, + "90.0" : 0.04966591475952083, + "95.0" : 0.04966591475952083, + "99.0" : 0.04966591475952083, + "99.9" : 0.04966591475952083, + "99.99" : 0.04966591475952083, + "99.999" : 0.04966591475952083, + "99.9999" : 0.04966591475952083, + "100.0" : 0.04966591475952083 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.04954455266769388, + 0.04966591475952083, + 0.049626549759811026 + ], + [ + 0.04719188535846421, + 0.04717849004076164, + 0.04707020434809212 + ] + ] + }, + "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" : 9043415.83336745, + "scoreError" : 434704.9609345177, + "scoreConfidence" : [ + 8608710.872432932, + 9478120.794301968 + ], + "scorePercentiles" : { + "0.0" : 8834682.399293287, + "50.0" : 9060342.61479463, + "90.0" : 9223578.02764977, + "95.0" : 9223578.02764977, + "99.0" : 9223578.02764977, + "99.9" : 9223578.02764977, + "99.99" : 9223578.02764977, + "99.999" : 9223578.02764977, + "99.9999" : 9223578.02764977, + "100.0" : 9223578.02764977 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 8989382.492362984, + 8834682.399293287, + 8911410.376669634 + ], + [ + 9223578.02764977, + 9131302.737226278, + 9170138.96700275 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + + From 1dbd50e581c4eeba94cd55fbad795b5c55cb7741 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Thu, 24 Jul 2025 21:53:16 +1000 Subject: [PATCH 09/14] simplify delayed dataloader dispatching by not using a batch window --- src/main/java/graphql/Profiler.java | 4 +- src/main/java/graphql/ProfilerImpl.java | 16 +- src/main/java/graphql/ProfilerResult.java | 36 +--- .../PerLevelDataLoaderDispatchStrategy.java | 155 ++++++++---------- .../graphql/schema/DataLoaderWithContext.java | 2 +- .../graphql/ChainedDataLoaderTest.groovy | 2 +- src/test/groovy/graphql/ProfilerTest.groovy | 58 +++++-- 7 files changed, 130 insertions(+), 143 deletions(-) diff --git a/src/main/java/graphql/Profiler.java b/src/main/java/graphql/Profiler.java index 6ac692a2fa..cdfed60638 100644 --- a/src/main/java/graphql/Profiler.java +++ b/src/main/java/graphql/Profiler.java @@ -46,10 +46,10 @@ default void oldStrategyDispatchingAll(int level) { default void batchLoadedOldStrategy(String name, int level, int count) { - } - default void batchLoadedNewStrategy(String dataLoaderName, @Nullable Integer level, int count) { + + default void batchLoadedNewStrategy(String dataLoaderName, Integer level, int count, boolean delayed, boolean chained) { } diff --git a/src/main/java/graphql/ProfilerImpl.java b/src/main/java/graphql/ProfilerImpl.java index 5c2e284dd5..1f42c6781d 100644 --- a/src/main/java/graphql/ProfilerImpl.java +++ b/src/main/java/graphql/ProfilerImpl.java @@ -147,12 +147,22 @@ public void oldStrategyDispatchingAll(int level) { @Override public void batchLoadedOldStrategy(String name, int level, int count) { - profilerResult.addDispatchEvent(name, level, count, ProfilerResult.DispatchEventType.STRATEGY_DISPATCH); + profilerResult.addDispatchEvent(name, level, count, ProfilerResult.DispatchEventType.LEVEL_STRATEGY_DISPATCH); } @Override - public void batchLoadedNewStrategy(String dataLoaderName, @Nullable Integer level, int count) { - profilerResult.addDispatchEvent(dataLoaderName, level, count, ProfilerResult.DispatchEventType.STRATEGY_DISPATCH); + public void batchLoadedNewStrategy(String dataLoaderName, Integer level, int count, boolean delayed, boolean chained) { + ProfilerResult.DispatchEventType dispatchEventType = null; + if (delayed && !chained) { + dispatchEventType = ProfilerResult.DispatchEventType.DELAYED_DISPATCH; + } else if (delayed) { + dispatchEventType = ProfilerResult.DispatchEventType.CHAINED_DELAYED_DISPATCH; + } else if (!chained) { + dispatchEventType = ProfilerResult.DispatchEventType.LEVEL_STRATEGY_DISPATCH; + } else { + dispatchEventType = ProfilerResult.DispatchEventType.CHAINED_STRATEGY_DISPATCH; + } + profilerResult.addDispatchEvent(dataLoaderName, level, count, dispatchEventType); } @Override diff --git a/src/main/java/graphql/ProfilerResult.java b/src/main/java/graphql/ProfilerResult.java index a10e55c8a1..bf5159dce9 100644 --- a/src/main/java/graphql/ProfilerResult.java +++ b/src/main/java/graphql/ProfilerResult.java @@ -64,17 +64,20 @@ public void setInstrumentationClasses(List instrumentationClasses) { public enum DispatchEventType { - STRATEGY_DISPATCH, + LEVEL_STRATEGY_DISPATCH, + CHAINED_STRATEGY_DISPATCH, + DELAYED_DISPATCH, + CHAINED_DELAYED_DISPATCH, MANUAL_DISPATCH, } public static class DispatchEvent { final String dataLoaderName; - final @Nullable Integer level; // is null for delayed dispatching + final Integer level; // is null for delayed dispatching final int keyCount; // how many final DispatchEventType type; - public DispatchEvent(String dataLoaderName, @Nullable Integer level, int keyCount, DispatchEventType type) { + public DispatchEvent(String dataLoaderName, Integer level, int keyCount, DispatchEventType type) { this.dataLoaderName = dataLoaderName; this.level = level; this.keyCount = keyCount; @@ -85,7 +88,7 @@ public String getDataLoaderName() { return dataLoaderName; } - public @Nullable Integer getLevel() { + public Integer getLevel() { return level; } @@ -175,7 +178,7 @@ void oldStrategyDispatchingAll(int level) { } - void addDispatchEvent(String dataLoaderName, @Nullable Integer level, int count, DispatchEventType type) { + void addDispatchEvent(String dataLoaderName, Integer level, int count, DispatchEventType type) { dispatchEvents.add(new DispatchEvent(dataLoaderName, level, count, type)); } @@ -316,34 +319,13 @@ public Map shortSummaryMap() { } - private String printDispatchEvents() { - if (dispatchEvents.isEmpty()) { - return "[]"; - } - StringBuilder sb = new StringBuilder(); - sb.append("["); - int i = 0; - for (DispatchEvent event : dispatchEvents) { - sb.append("dataLoader=") - .append(event.getDataLoaderName()) - .append(", level=") - .append(event.getLevel()) - .append(", count=").append(event.getKeyCount()); - if (i++ < dispatchEvents.size() - 1) { - sb.append("; "); - } - } - sb.append("]"); - return sb.toString(); - } - public List> getDispatchEventsAsMap() { List> result = new ArrayList<>(); for (DispatchEvent event : dispatchEvents) { Map eventMap = new LinkedHashMap<>(); eventMap.put("type", event.getType().name()); eventMap.put("dataLoader", event.getDataLoaderName()); - eventMap.put("level", event.getLevel() != null ? event.getLevel() : "delayed"); + eventMap.put("level", event.getLevel()); eventMap.put("keyCount", event.getKeyCount()); result.add(eventMap); } diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java index e29633aeda..7b82dec120 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java @@ -25,9 +25,7 @@ import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.atomic.AtomicReference; import java.util.function.Supplier; -import java.util.stream.Collectors; @Internal @NullMarked @@ -38,7 +36,6 @@ public class PerLevelDataLoaderDispatchStrategy implements DataLoaderDispatchStr private final boolean enableDataLoaderChaining; - static final long DEFAULT_BATCH_WINDOW_NANO_SECONDS_DEFAULT = 500_000L; private final Profiler profiler; private final Map deferredCallStackMap = new ConcurrentHashMap<>(); @@ -94,15 +91,15 @@ private static class CallStack { // all levels that are ready to be dispatched private int highestReadyLevel; - private final List allResultPathWithDataLoader = Collections.synchronizedList(new ArrayList<>()); - private final Map> levelToResultPathWithDataLoader = new ConcurrentHashMap<>(); - + /** + * Data for chained dispatching. + * A result path is used to identify a DataFetcher. + */ + private final List allDataLoaderInvocations = Collections.synchronizedList(new ArrayList<>()); + private final Map> levelToDataLoaderInvocation = new ConcurrentHashMap<>(); private final Set dispatchingStartedPerLevel = ConcurrentHashMap.newKeySet(); private final Set dispatchingFinishedPerLevel = ConcurrentHashMap.newKeySet(); - // Set of ResultPath - private final Set batchWindowOfDelayedDataLoaderToDispatch = ConcurrentHashMap.newKeySet(); - - private boolean batchWindowOpen; + private final Set currentlyDelayedDispatchingLevels = ConcurrentHashMap.newKeySet(); private final List deferredFragmentRootFieldsFetched = new ArrayList<>(); @@ -113,8 +110,8 @@ public CallStack() { expectedExecuteObjectCallsPerLevel.set(0, 1); } - public void addResultPathWithDataLoader(int level, ResultPathWithDataLoader resultPathWithDataLoader) { - levelToResultPathWithDataLoader.computeIfAbsent(level, k -> new LinkedHashSet<>()).add(resultPathWithDataLoader); + public void addDataLoaderInvocationForLevel(int level, DataLoaderInvocation dataLoaderInvocation) { + levelToDataLoaderInvocation.computeIfAbsent(level, k -> new LinkedHashSet<>()).add(dataLoaderInvocation); } @@ -328,12 +325,9 @@ private void resetCallStack(CallStack callStack) { callStack.clearHappenedExecuteObjectCalls(); callStack.clearHappenedOnFieldValueCalls(); callStack.expectedExecuteObjectCallsPerLevel.set(0, 1); - callStack.dispatchingFinishedPerLevel.clear(); - callStack.dispatchingStartedPerLevel.clear(); - callStack.allResultPathWithDataLoader.clear(); - callStack.batchWindowOfDelayedDataLoaderToDispatch.clear(); - callStack.batchWindowOpen = false; - callStack.levelToResultPathWithDataLoader.clear(); + callStack.currentlyDelayedDispatchingLevels.clear(); + callStack.allDataLoaderInvocations.clear(); + callStack.levelToDataLoaderInvocation.clear(); callStack.highestReadyLevel = 0; }); } @@ -475,16 +469,12 @@ void dispatch(int level, CallStack callStack) { dispatchAll(dataLoaderRegistry, level); return; } - Set resultPathWithDataLoaders = callStack.levelToResultPathWithDataLoader.get(level); - if (resultPathWithDataLoaders != null) { - Set resultPathToDispatch = callStack.lock.callLocked(() -> { + Set dataLoaderInvocations = callStack.levelToDataLoaderInvocation.get(level); + if (dataLoaderInvocations != null) { + callStack.lock.runLocked(() -> { callStack.dispatchingStartedPerLevel.add(level); - return resultPathWithDataLoaders - .stream() - .map(resultPathWithDataLoader -> resultPathWithDataLoader.resultPath) - .collect(Collectors.toSet()); }); - dispatchDLCFImpl(resultPathToDispatch, level, callStack); + dispatchDLCFImpl(level, callStack, false, false); } else { callStack.lock.runLocked(() -> { callStack.dispatchingStartedPerLevel.add(level); @@ -504,110 +494,93 @@ private void dispatchAll(DataLoaderRegistry dataLoaderRegistry, int level) { } } - private void dispatchDLCFImpl(Set resultPathsToDispatch, @Nullable Integer level, CallStack callStack) { + private void dispatchDLCFImpl(Integer level, CallStack callStack, boolean delayed, boolean chained) { - // filter out all DataLoaderCFS that are matching the fields we want to dispatch - List relevantResultPathWithDataLoader = new ArrayList<>(); - // we need to copy the list because the callStack.allResultPathWithDataLoader can be modified concurrently - // while iterating over it - ArrayList resultPathWithDataLoaders = new ArrayList<>(callStack.allResultPathWithDataLoader); - for (ResultPathWithDataLoader resultPathWithDataLoader : resultPathWithDataLoaders) { - if (resultPathsToDispatch.contains(resultPathWithDataLoader.resultPath)) { - relevantResultPathWithDataLoader.add(resultPathWithDataLoader); + List relevantDataLoaderInvocations = callStack.lock.callLocked(() -> { + List result = new ArrayList<>(); + for (DataLoaderInvocation dataLoaderInvocation : callStack.allDataLoaderInvocations) { + if (dataLoaderInvocation.level == level) { + result.add(dataLoaderInvocation); + } } - } - // we are cleaning up the list of all DataLoadersCFs - callStack.allResultPathWithDataLoader.removeAll(relevantResultPathWithDataLoader); - - // means we are all done dispatching the fields - if (relevantResultPathWithDataLoader.size() == 0) { - if (level != null) { + callStack.allDataLoaderInvocations.removeAll(result); + if (result.size() > 0) { + return result; + } + if (delayed) { + callStack.currentlyDelayedDispatchingLevels.remove(level); + } else { callStack.dispatchingFinishedPerLevel.add(level); } + return result; + }); + if (relevantDataLoaderInvocations.size() == 0) { return; } List allDispatchedCFs = new ArrayList<>(); - for (ResultPathWithDataLoader resultPathWithDataLoader : relevantResultPathWithDataLoader) { - CompletableFuture dispatch = resultPathWithDataLoader.dataLoader.dispatch(); + for (DataLoaderInvocation dataLoaderInvocation : relevantDataLoaderInvocations) { + CompletableFuture dispatch = dataLoaderInvocation.dataLoader.dispatch(); allDispatchedCFs.add(dispatch); dispatch.whenComplete((objects, throwable) -> { if (objects != null && objects.size() > 0) { - profiler.batchLoadedNewStrategy(resultPathWithDataLoader.name, level, objects.size()); + profiler.batchLoadedNewStrategy(dataLoaderInvocation.name, level, objects.size(), delayed, chained); } }); } CompletableFuture.allOf(allDispatchedCFs.toArray(new CompletableFuture[0])) .whenComplete((unused, throwable) -> { - dispatchDLCFImpl(resultPathsToDispatch, level, callStack); + dispatchDLCFImpl(level, callStack, delayed, true); } ); } - public void newDataLoaderLoadCall(String resultPath, int level, DataLoader dataLoader, String - dataLoaderName, Object key, @Nullable AlternativeCallContext alternativeCallContext) { + public void newDataLoaderInvocation(String resultPath, + int level, + DataLoader dataLoader, + String dataLoaderName, + Object key, + @Nullable AlternativeCallContext alternativeCallContext) { if (!enableDataLoaderChaining) { return; } - ResultPathWithDataLoader resultPathWithDataLoader = new ResultPathWithDataLoader(resultPath, level, dataLoader, dataLoaderName, key); + DataLoaderInvocation dataLoaderInvocation = new DataLoaderInvocation(resultPath, level, dataLoader, dataLoaderName, key); CallStack callStack = getCallStack(alternativeCallContext); - boolean levelFinished = callStack.lock.callLocked(() -> { + boolean startNewDelayedDispatching = callStack.lock.callLocked(() -> { + callStack.allDataLoaderInvocations.add(dataLoaderInvocation); + + boolean started = callStack.dispatchingStartedPerLevel.contains(level); + if (!started) { + callStack.addDataLoaderInvocationForLevel(level, dataLoaderInvocation); + } boolean finished = callStack.dispatchingFinishedPerLevel.contains(level); - callStack.allResultPathWithDataLoader.add(resultPathWithDataLoader); - // only add to the list of DataLoader for this level if we are not already dispatching - if (!callStack.dispatchingStartedPerLevel.contains(level)) { - callStack.addResultPathWithDataLoader(level, resultPathWithDataLoader); + // we need to start a new delayed dispatching if + // the normal dispatching is finished and there is no currently delayed dispatching for this level + boolean newDelayedInvocation = finished && !callStack.currentlyDelayedDispatchingLevels.contains(level); + if (newDelayedInvocation) { + callStack.currentlyDelayedDispatchingLevels.add(level); } - return finished; + return newDelayedInvocation; }); - if (levelFinished) { - newDelayedDataLoader(resultPathWithDataLoader, callStack); + if (startNewDelayedDispatching) { + dispatchDLCFImpl(level, callStack, true, false); } } - class DispatchDelayedDataloader implements Runnable { - - private final CallStack callStack; - - public DispatchDelayedDataloader(CallStack callStack) { - this.callStack = callStack; - } - - @Override - public void run() { - AtomicReference> resultPathToDispatch = new AtomicReference<>(); - callStack.lock.runLocked(() -> { - resultPathToDispatch.set(new LinkedHashSet<>(callStack.batchWindowOfDelayedDataLoaderToDispatch)); - callStack.batchWindowOfDelayedDataLoaderToDispatch.clear(); - callStack.batchWindowOpen = false; - }); - dispatchDLCFImpl(Assert.assertNotNull(resultPathToDispatch.get()), null, callStack); - } - } - - private void newDelayedDataLoader(ResultPathWithDataLoader resultPathWithDataLoader, CallStack callStack) { - dispatchDLCFImpl(Set.of(resultPathWithDataLoader.resultPath), null, callStack); -// callStack.lock.runLocked(() -> { -// callStack.batchWindowOfDelayedDataLoaderToDispatch.add(resultPathWithDataLoader.resultPath); -// if (!callStack.batchWindowOpen) { -// callStack.batchWindowOpen = true; -// delayedDataLoaderDispatchExecutor.get().schedule(new DispatchDelayedDataloader(callStack), this.batchWindowNs, TimeUnit.NANOSECONDS); -// } -// -// }); - } - - private static class ResultPathWithDataLoader { + /** + * A single data loader invocation. + */ + private static class DataLoaderInvocation { final String resultPath; final int level; final DataLoader dataLoader; final String name; final Object key; - public ResultPathWithDataLoader(String resultPath, int level, DataLoader dataLoader, String name, Object key) { + public DataLoaderInvocation(String resultPath, int level, DataLoader dataLoader, String name, Object key) { this.resultPath = resultPath; this.level = level; this.dataLoader = dataLoader; diff --git a/src/main/java/graphql/schema/DataLoaderWithContext.java b/src/main/java/graphql/schema/DataLoaderWithContext.java index b985a8eafc..92403dfdd8 100644 --- a/src/main/java/graphql/schema/DataLoaderWithContext.java +++ b/src/main/java/graphql/schema/DataLoaderWithContext.java @@ -36,7 +36,7 @@ public CompletableFuture load(@NonNull K key, @Nullable Object keyContext) { AlternativeCallContext alternativeCallContext = dfeInternalState.getDeferredCallContext(); int level = dfe.getExecutionStepInfo().getPath().getLevel(); String path = dfe.getExecutionStepInfo().getPath().toString(); - ((PerLevelDataLoaderDispatchStrategy) dfeInternalState.dataLoaderDispatchStrategy).newDataLoaderLoadCall(path, level, delegate, dataLoaderName, key, alternativeCallContext); + ((PerLevelDataLoaderDispatchStrategy) dfeInternalState.dataLoaderDispatchStrategy).newDataLoaderInvocation(path, level, delegate, dataLoaderName, key, alternativeCallContext); } return result; } diff --git a/src/test/groovy/graphql/ChainedDataLoaderTest.groovy b/src/test/groovy/graphql/ChainedDataLoaderTest.groovy index 38daf71289..1a2e77f8cd 100644 --- a/src/test/groovy/graphql/ChainedDataLoaderTest.groovy +++ b/src/test/groovy/graphql/ChainedDataLoaderTest.groovy @@ -264,7 +264,7 @@ class ChainedDataLoaderTest extends Specification { } - def "chained data loaders with an isolated data loader"() { + def "chained data loaders with an delayed data loader"() { given: def sdl = ''' diff --git a/src/test/groovy/graphql/ProfilerTest.groovy b/src/test/groovy/graphql/ProfilerTest.groovy index 25b58a6068..1498417c3e 100644 --- a/src/test/groovy/graphql/ProfilerTest.groovy +++ b/src/test/groovy/graphql/ProfilerTest.groovy @@ -288,7 +288,7 @@ class ProfilerTest extends Specification { batchLoadCalls.get() == 1 then: profilerResult.getDataLoaderLoadInvocations().get("name") == 4 - profilerResult.getDispatchEvents()[0].type == ProfilerResult.DispatchEventType.STRATEGY_DISPATCH + profilerResult.getDispatchEvents()[0].type == ProfilerResult.DispatchEventType.LEVEL_STRATEGY_DISPATCH profilerResult.getDispatchEvents()[0].dataLoaderName == "name" profilerResult.getDispatchEvents()[0].keyCount == 1 profilerResult.getDispatchEvents()[0].level == 1 @@ -529,9 +529,16 @@ class ProfilerTest extends Specification { return supplyAsync { batchLoadCalls++ Thread.sleep(250) - println "BatchLoader called with keys: $keys" - assert keys.size() == 2 - return ["Luna", "Tiger"] + println "BatchLoader called with keys: $keys thread: ${Thread.currentThread().name}" + return keys.collect { key -> + if (key == "Key1") { + return "Luna" + } else if (key == "Key2") { + return "Tiger" + } else { + return key + } + } } } @@ -540,7 +547,7 @@ class ProfilerTest extends Specification { DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); dataLoaderRegistry.register("name", nameDataLoader); - def df1 = { env -> + def dogDF = { env -> return env.getDataLoader("name").load("Key1").thenCompose { result -> { @@ -549,16 +556,21 @@ class ProfilerTest extends Specification { } } as DataFetcher - def df2 = { env -> - return env.getDataLoader("name").load("Key2").thenCompose { - result -> - { - return env.getDataLoader("name").load(result) - } + def catDF = { env -> + return supplyAsync { + Thread.sleep(1500) + return "foo" + }.thenCompose { + return env.getDataLoader("name").load("Key2").thenCompose { + result -> + { + return env.getDataLoader("name").load(result) + } + } } } as DataFetcher - def fetchers = ["Query": ["dogName": df1, "catName": df2]] + def fetchers = ["Query": ["dogName": dogDF, "catName": catDF]] def schema = TestUtil.schema(sdl, fetchers) def graphQL = GraphQL.newGraphQL(schema).build() @@ -573,16 +585,26 @@ class ProfilerTest extends Specification { def profilerResult = ei.getGraphQLContext().get(ProfilerResult.PROFILER_CONTEXT_KEY) as ProfilerResult then: er.data == [dogName: "Luna", catName: "Tiger"] - batchLoadCalls == 2 + batchLoadCalls == 4 profilerResult.isDataLoaderChainingEnabled() profilerResult.getDataLoaderLoadInvocations() == [name: 4] - profilerResult.getDispatchEvents().size() == 2 + profilerResult.getDispatchEvents().size() == 4 + + profilerResult.getDispatchEvents()[0].type == ProfilerResult.DispatchEventType.LEVEL_STRATEGY_DISPATCH profilerResult.getDispatchEvents()[0].dataLoaderName == "name" profilerResult.getDispatchEvents()[0].level == 1 - profilerResult.getDispatchEvents()[0].keyCount == 2 - profilerResult.getDispatchEvents()[1].dataLoaderName == "name" - profilerResult.getDispatchEvents()[1].level == 1 - profilerResult.getDispatchEvents()[1].keyCount == 2 + profilerResult.getDispatchEvents()[0].keyCount == 1 + + profilerResult.getDispatchEvents()[2].type == ProfilerResult.DispatchEventType.DELAYED_DISPATCH + profilerResult.getDispatchEvents()[2].dataLoaderName == "name" + profilerResult.getDispatchEvents()[2].level == 1 + profilerResult.getDispatchEvents()[2].keyCount == 1 + + profilerResult.getDispatchEvents()[3].type == ProfilerResult.DispatchEventType.CHAINED_DELAYED_DISPATCH + profilerResult.getDispatchEvents()[3].dataLoaderName == "name" + profilerResult.getDispatchEvents()[3].level == 1 + profilerResult.getDispatchEvents()[3].keyCount == 1 + } From a970753f64c1e216815d8abfe70ab39c2b551273 Mon Sep 17 00:00:00 2001 From: Davide Angelocola Date: Thu, 24 Jul 2025 20:42:09 +0200 Subject: [PATCH 10/14] Possibility to run JMH benchmarks without JAR build It is very handy to start a benchmark directly from within IntelliJ. --- build.gradle | 1 + 1 file changed, 1 insertion(+) diff --git a/build.gradle b/build.gradle index c0313eba89..58fb67f900 100644 --- a/build.gradle +++ b/build.gradle @@ -150,6 +150,7 @@ 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' errorprone 'com.uber.nullaway:nullaway:0.12.7' errorprone 'com.google.errorprone:error_prone_core:2.40.0' From ab92243ccbe6f0bba0ad608274e3752e3f33bbc4 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Fri, 25 Jul 2025 00:33:27 +0000 Subject: [PATCH 11/14] Add performance results for commit 378eb2b1ff6cadd27994b2e8fa23fba57c6286ab --- ...f6cadd27994b2e8fa23fba57c6286ab-jdk17.json | 1279 +++++++++++++++++ 1 file changed, 1279 insertions(+) create mode 100644 performance-results/2025-07-25T00:33:09Z-378eb2b1ff6cadd27994b2e8fa23fba57c6286ab-jdk17.json diff --git a/performance-results/2025-07-25T00:33:09Z-378eb2b1ff6cadd27994b2e8fa23fba57c6286ab-jdk17.json b/performance-results/2025-07-25T00:33:09Z-378eb2b1ff6cadd27994b2e8fa23fba57c6286ab-jdk17.json new file mode 100644 index 0000000000..0fcb044cd0 --- /dev/null +++ b/performance-results/2025-07-25T00:33:09Z-378eb2b1ff6cadd27994b2e8fa23fba57c6286ab-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.3066775275726714, + "scoreError" : 0.033919743261016475, + "scoreConfidence" : [ + 3.272757784311655, + 3.3405972708336877 + ], + "scorePercentiles" : { + "0.0" : 3.301072458041701, + "50.0" : 3.306422217105671, + "90.0" : 3.3127932180376423, + "95.0" : 3.3127932180376423, + "99.0" : 3.3127932180376423, + "99.9" : 3.3127932180376423, + "99.99" : 3.3127932180376423, + "99.999" : 3.3127932180376423, + "99.9999" : 3.3127932180376423, + "100.0" : 3.3127932180376423 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.3038039283157077, + 3.3127932180376423 + ], + [ + 3.301072458041701, + 3.3090405058956347 + ] + ] + }, + "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.6814308976912047, + "scoreError" : 0.022089312539861548, + "scoreConfidence" : [ + 1.6593415851513431, + 1.7035202102310663 + ], + "scorePercentiles" : { + "0.0" : 1.6785182901910285, + "50.0" : 1.6807376668985228, + "90.0" : 1.6857299667767454, + "95.0" : 1.6857299667767454, + "99.0" : 1.6857299667767454, + "99.9" : 1.6857299667767454, + "99.99" : 1.6857299667767454, + "99.999" : 1.6857299667767454, + "99.9999" : 1.6857299667767454, + "100.0" : 1.6857299667767454 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.6788496992175892, + 1.6785182901910285 + ], + [ + 1.6826256345794561, + 1.6857299667767454 + ] + ] + }, + "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.8381848165625602, + "scoreError" : 0.04411699408186375, + "scoreConfidence" : [ + 0.7940678224806964, + 0.8823018106444239 + ], + "scorePercentiles" : { + "0.0" : 0.8299295997776214, + "50.0" : 0.838692253199008, + "90.0" : 0.8454251600746033, + "95.0" : 0.8454251600746033, + "99.0" : 0.8454251600746033, + "99.9" : 0.8454251600746033, + "99.99" : 0.8454251600746033, + "99.999" : 0.8454251600746033, + "99.9999" : 0.8454251600746033, + "100.0" : 0.8454251600746033 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.8299295997776214, + 0.8454251600746033 + ], + [ + 0.8356308875372876, + 0.8417536188607282 + ] + ] + }, + "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.004961566280702, + "scoreError" : 0.1528592055047278, + "scoreConfidence" : [ + 15.852102360775975, + 16.15782077178543 + ], + "scorePercentiles" : { + "0.0" : 15.955488873780125, + "50.0" : 15.988206082006558, + "90.0" : 16.10950939067394, + "95.0" : 16.10950939067394, + "99.0" : 16.10950939067394, + "99.9" : 16.10950939067394, + "99.99" : 16.10950939067394, + "99.999" : 16.10950939067394, + "99.9999" : 16.10950939067394, + "100.0" : 16.10950939067394 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 15.955488873780125, + 16.10950939067394, + 15.991094934683712 + ], + [ + 15.985317229329404, + 15.975892928959603, + 16.01246604025744 + ] + ] + }, + "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" : 2582.118025703376, + "scoreError" : 188.36873932962732, + "scoreConfidence" : [ + 2393.749286373749, + 2770.4867650330034 + ], + "scorePercentiles" : { + "0.0" : 2519.5276419027423, + "50.0" : 2576.4650052428824, + "90.0" : 2663.3688734556135, + "95.0" : 2663.3688734556135, + "99.0" : 2663.3688734556135, + "99.9" : 2663.3688734556135, + "99.99" : 2663.3688734556135, + "99.999" : 2663.3688734556135, + "99.9999" : 2663.3688734556135, + "100.0" : 2663.3688734556135 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2526.3379058760356, + 2519.5276419027423, + 2519.592969574141 + ], + [ + 2626.592104609729, + 2663.3688734556135, + 2637.2886588019974 + ] + ] + }, + "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" : 75929.43713956332, + "scoreError" : 1795.725219760547, + "scoreConfidence" : [ + 74133.71191980278, + 77725.16235932386 + ], + "scorePercentiles" : { + "0.0" : 75254.86153805364, + "50.0" : 75898.6036985468, + "90.0" : 76573.93021625052, + "95.0" : 76573.93021625052, + "99.0" : 76573.93021625052, + "99.9" : 76573.93021625052, + "99.99" : 76573.93021625052, + "99.999" : 76573.93021625052, + "99.9999" : 76573.93021625052, + "100.0" : 76573.93021625052 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 76389.67320304408, + 76573.93021625052, + 76563.3402721159 + ], + [ + 75407.53419404951, + 75387.28341386627, + 75254.86153805364 + ] + ] + }, + "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" : 336.6049353290876, + "scoreError" : 16.489521506150968, + "scoreConfidence" : [ + 320.1154138229366, + 353.0944568352386 + ], + "scorePercentiles" : { + "0.0" : 331.32458413008754, + "50.0" : 335.20008333375665, + "90.0" : 347.06334480071985, + "95.0" : 347.06334480071985, + "99.0" : 347.06334480071985, + "99.9" : 347.06334480071985, + "99.99" : 347.06334480071985, + "99.999" : 347.06334480071985, + "99.9999" : 347.06334480071985, + "100.0" : 347.06334480071985 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 332.05922428946457, + 333.42823124036664, + 331.32458413008754 + ], + [ + 336.9719354271467, + 338.78229208674026, + 347.06334480071985 + ] + ] + }, + "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" : 107.60582690655242, + "scoreError" : 11.173389818839349, + "scoreConfidence" : [ + 96.43243708771307, + 118.77921672539178 + ], + "scorePercentiles" : { + "0.0" : 102.11801195009656, + "50.0" : 108.69010971957573, + "90.0" : 111.67494993512767, + "95.0" : 111.67494993512767, + "99.0" : 111.67494993512767, + "99.9" : 111.67494993512767, + "99.99" : 111.67494993512767, + "99.999" : 111.67494993512767, + "99.9999" : 111.67494993512767, + "100.0" : 111.67494993512767 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 102.11801195009656, + 103.77459901875596, + 106.93163472430241 + ], + [ + 110.68718109618288, + 110.44858471484906, + 111.67494993512767 + ] + ] + }, + "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.06257742894897945, + "scoreError" : 4.616417683000458E-4, + "scoreConfidence" : [ + 0.06211578718067941, + 0.0630390707172795 + ], + "scorePercentiles" : { + "0.0" : 0.0623212224264935, + "50.0" : 0.0625570274063876, + "90.0" : 0.06276186021991263, + "95.0" : 0.06276186021991263, + "99.0" : 0.06276186021991263, + "99.9" : 0.06276186021991263, + "99.99" : 0.06276186021991263, + "99.999" : 0.06276186021991263, + "99.9999" : 0.06276186021991263, + "100.0" : 0.06276186021991263 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.06256933182543407, + 0.0623212224264935, + 0.06275283901655392 + ], + [ + 0.06251459721814147, + 0.06254472298734114, + 0.06276186021991263 + ] + ] + }, + "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.804979073315174E-4, + "scoreError" : 3.1290959030715905E-5, + "scoreConfidence" : [ + 3.492069483008015E-4, + 4.117888663622333E-4 + ], + "scorePercentiles" : { + "0.0" : 3.686052191223459E-4, + "50.0" : 3.805710213074775E-4, + "90.0" : 3.9295602562939327E-4, + "95.0" : 3.9295602562939327E-4, + "99.0" : 3.9295602562939327E-4, + "99.9" : 3.9295602562939327E-4, + "99.99" : 3.9295602562939327E-4, + "99.999" : 3.9295602562939327E-4, + "99.9999" : 3.9295602562939327E-4, + "100.0" : 3.9295602562939327E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.7203306319338707E-4, + 3.706584066808534E-4, + 3.686052191223459E-4 + ], + [ + 3.89108979421568E-4, + 3.8962574994155693E-4, + 3.9295602562939327E-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.12677889442068035, + "scoreError" : 0.008951730346661569, + "scoreConfidence" : [ + 0.11782716407401879, + 0.13573062476734193 + ], + "scorePercentiles" : { + "0.0" : 0.12342886066403357, + "50.0" : 0.12693422320553238, + "90.0" : 0.12988056201052017, + "95.0" : 0.12988056201052017, + "99.0" : 0.12988056201052017, + "99.9" : 0.12988056201052017, + "99.99" : 0.12988056201052017, + "99.999" : 0.12988056201052017, + "99.9999" : 0.12988056201052017, + "100.0" : 0.12988056201052017 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.12956015696943785, + 0.12988056201052017, + 0.12959982908685622 + ], + [ + 0.12430828944162689, + 0.12389566835160751, + 0.12342886066403357 + ] + ] + }, + "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.013185124640204576, + "scoreError" : 9.870438880579569E-5, + "scoreConfidence" : [ + 0.01308642025139878, + 0.013283829029010373 + ], + "scorePercentiles" : { + "0.0" : 0.013149310564282202, + "50.0" : 0.01317385008032829, + "90.0" : 0.013235472953066414, + "95.0" : 0.013235472953066414, + "99.0" : 0.013235472953066414, + "99.9" : 0.013235472953066414, + "99.99" : 0.013235472953066414, + "99.999" : 0.013235472953066414, + "99.9999" : 0.013235472953066414, + "100.0" : 0.013235472953066414 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.013149310564282202, + 0.013156921266151537, + 0.013176660858920927 + ], + [ + 0.013171039301735651, + 0.013221342897070722, + 0.013235472953066414 + ] + ] + }, + "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.0354221684983729, + "scoreError" : 0.027954869197301387, + "scoreConfidence" : [ + 1.0074672993010716, + 1.0633770376956742 + ], + "scorePercentiles" : { + "0.0" : 1.025096790692907, + "50.0" : 1.034103071230585, + "90.0" : 1.047773467993714, + "95.0" : 1.047773467993714, + "99.0" : 1.047773467993714, + "99.9" : 1.047773467993714, + "99.99" : 1.047773467993714, + "99.999" : 1.047773467993714, + "99.9999" : 1.047773467993714, + "100.0" : 1.047773467993714 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 1.047773467993714, + 1.0442930651629072, + 1.0407120288271412 + ], + [ + 1.025096790692907, + 1.0271635446795397, + 1.0274941136340285 + ] + ] + }, + "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.01068772594921502, + "scoreError" : 1.462473792761726E-4, + "scoreConfidence" : [ + 0.010541478569938846, + 0.010833973328491193 + ], + "scorePercentiles" : { + "0.0" : 0.010607628229144347, + "50.0" : 0.01068450706691373, + "90.0" : 0.01077134530715823, + "95.0" : 0.01077134530715823, + "99.0" : 0.01077134530715823, + "99.9" : 0.01077134530715823, + "99.99" : 0.01077134530715823, + "99.999" : 0.01077134530715823, + "99.9999" : 0.01077134530715823, + "100.0" : 0.01077134530715823 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.010607628229144347, + 0.010680124086609009, + 0.01068332102292151 + ], + [ + 0.01068569311090595, + 0.010698243938551072, + 0.01077134530715823 + ] + ] + }, + "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.279232238968176, + "scoreError" : 0.12999334086418882, + "scoreConfidence" : [ + 3.149238898103987, + 3.4092255798323645 + ], + "scorePercentiles" : { + "0.0" : 3.228267479018722, + "50.0" : 3.278079688598224, + "90.0" : 3.338102288192128, + "95.0" : 3.338102288192128, + "99.0" : 3.338102288192128, + "99.9" : 3.338102288192128, + "99.99" : 3.338102288192128, + "99.999" : 3.338102288192128, + "99.9999" : 3.338102288192128, + "100.0" : 3.338102288192128 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.252843413524057, + 3.235263989003881, + 3.228267479018722 + ], + [ + 3.303315963672391, + 3.338102288192128, + 3.317600300397878 + ] + ] + }, + "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.942751566759662, + "scoreError" : 0.033475477865511326, + "scoreConfidence" : [ + 2.909276088894151, + 2.9762270446251735 + ], + "scorePercentiles" : { + "0.0" : 2.9285283704245972, + "50.0" : 2.9419997167171643, + "90.0" : 2.95762009668835, + "95.0" : 2.95762009668835, + "99.0" : 2.95762009668835, + "99.9" : 2.95762009668835, + "99.99" : 2.95762009668835, + "99.999" : 2.95762009668835, + "99.9999" : 2.95762009668835, + "100.0" : 2.95762009668835 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.9285283704245972, + 2.95762009668835, + 2.9320072486074467 + ], + [ + 2.9463571843888072, + 2.9543542514032497, + 2.9376422490455214 + ] + ] + }, + "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.1780843687883823, + "scoreError" : 0.00337053557336736, + "scoreConfidence" : [ + 0.17471383321501494, + 0.18145490436174966 + ], + "scorePercentiles" : { + "0.0" : 0.17633287293694455, + "50.0" : 0.17868748060792106, + "90.0" : 0.17911248701461527, + "95.0" : 0.17911248701461527, + "99.0" : 0.17911248701461527, + "99.9" : 0.17911248701461527, + "99.99" : 0.17911248701461527, + "99.999" : 0.17911248701461527, + "99.9999" : 0.17911248701461527, + "100.0" : 0.17911248701461527 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.17858500491097737, + 0.1767861157211802, + 0.17633287293694455 + ], + [ + 0.17889977584171168, + 0.17878995630486474, + 0.17911248701461527 + ] + ] + }, + "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.3334283231280681, + "scoreError" : 0.018617853315637842, + "scoreConfidence" : [ + 0.3148104698124302, + 0.35204617644370595 + ], + "scorePercentiles" : { + "0.0" : 0.32690004857637867, + "50.0" : 0.33342136438463, + "90.0" : 0.33975365040429434, + "95.0" : 0.33975365040429434, + "99.0" : 0.33975365040429434, + "99.9" : 0.33975365040429434, + "99.99" : 0.33975365040429434, + "99.999" : 0.33975365040429434, + "99.9999" : 0.33975365040429434, + "100.0" : 0.33975365040429434 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.32787988878688523, + 0.32690004857637867, + 0.3273588003142595 + ], + [ + 0.3389628399823747, + 0.33971471070421577, + 0.33975365040429434 + ] + ] + }, + "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.14758968251906296, + "scoreError" : 0.003533857499484376, + "scoreConfidence" : [ + 0.1440558250195786, + 0.15112354001854733 + ], + "scorePercentiles" : { + "0.0" : 0.14604092429685447, + "50.0" : 0.14751047342677978, + "90.0" : 0.14905529530041287, + "95.0" : 0.14905529530041287, + "99.0" : 0.14905529530041287, + "99.9" : 0.14905529530041287, + "99.99" : 0.14905529530041287, + "99.999" : 0.14905529530041287, + "99.9999" : 0.14905529530041287, + "100.0" : 0.14905529530041287 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.14905529530041287, + 0.1482887649099914, + 0.14874505205931787 + ], + [ + 0.14673218194356816, + 0.14667587660423298, + 0.14604092429685447 + ] + ] + }, + "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.4102380454104919, + "scoreError" : 0.01905155753606237, + "scoreConfidence" : [ + 0.39118648787442956, + 0.42928960294655427 + ], + "scorePercentiles" : { + "0.0" : 0.40432925112198276, + "50.0" : 0.40806549427284267, + "90.0" : 0.4200787366210199, + "95.0" : 0.4200787366210199, + "99.0" : 0.4200787366210199, + "99.9" : 0.4200787366210199, + "99.99" : 0.4200787366210199, + "99.999" : 0.4200787366210199, + "99.9999" : 0.4200787366210199, + "100.0" : 0.4200787366210199 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.40432925112198276, + 0.40499237293969953, + 0.4045022773126239 + ], + [ + 0.4200787366210199, + 0.41638701886163965, + 0.41113861560598586 + ] + ] + }, + "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.15779309849350384, + "scoreError" : 0.004036259275626001, + "scoreConfidence" : [ + 0.15375683921787783, + 0.16182935776912985 + ], + "scorePercentiles" : { + "0.0" : 0.156635180784412, + "50.0" : 0.15725132103513056, + "90.0" : 0.16036106122416255, + "95.0" : 0.16036106122416255, + "99.0" : 0.16036106122416255, + "99.9" : 0.16036106122416255, + "99.99" : 0.16036106122416255, + "99.999" : 0.16036106122416255, + "99.9999" : 0.16036106122416255, + "100.0" : 0.16036106122416255 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.156635180784412, + 0.15675691365959182, + 0.1568912394728585 + ], + [ + 0.16036106122416255, + 0.15850279322259558, + 0.1576114025974026 + ] + ] + }, + "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.046463276420450415, + "scoreError" : 0.0018381035938579088, + "scoreConfidence" : [ + 0.04462517282659251, + 0.04830138001430832 + ], + "scorePercentiles" : { + "0.0" : 0.04589555564530564, + "50.0" : 0.04632686305658129, + "90.0" : 0.047575926943680596, + "95.0" : 0.047575926943680596, + "99.0" : 0.047575926943680596, + "99.9" : 0.047575926943680596, + "99.99" : 0.047575926943680596, + "99.999" : 0.047575926943680596, + "99.9999" : 0.047575926943680596, + "100.0" : 0.047575926943680596 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.04594306312941047, + 0.04589555564530564, + 0.04599624998045195 + ], + [ + 0.047575926943680596, + 0.04671138669114316, + 0.046657476132710624 + ] + ] + }, + "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" : 9459466.352530636, + "scoreError" : 635263.0245088574, + "scoreConfidence" : [ + 8824203.328021778, + 1.0094729377039494E7 + ], + "scorePercentiles" : { + "0.0" : 9219518.085714286, + "50.0" : 9453558.55638749, + "90.0" : 9734180.823929962, + "95.0" : 9734180.823929962, + "99.0" : 9734180.823929962, + "99.9" : 9734180.823929962, + "99.99" : 9734180.823929962, + "99.999" : 9734180.823929962, + "99.9999" : 9734180.823929962, + "100.0" : 9734180.823929962 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 9219518.085714286, + 9287835.073351903, + 9263195.210185185 + ], + [ + 9632786.882579403, + 9619282.039423076, + 9734180.823929962 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + + From 86e9e4d209e5cf76742fed9ba7d2d632ab9c697c Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Fri, 25 Jul 2025 15:33:23 +1000 Subject: [PATCH 12/14] removes the java agent --- agent-test/build.gradle | 57 ---- .../src/main/java/graphql/GraphQLApp.java | 40 --- .../src/test/java/graphql/test/AgentTest.java | 72 ----- .../src/test/java/graphql/test/LoadAgent.java | 15 - .../graphql/test/StartAgentOnStartupTest.java | 23 -- .../src/test/java/graphql/test/TestQuery.java | 102 ------ agent/build.gradle | 124 -------- .../java/graphql/agent/GraphQLJavaAgent.java | 301 ------------------ settings.gradle | 1 - 9 files changed, 735 deletions(-) delete mode 100644 agent-test/build.gradle delete mode 100644 agent-test/src/main/java/graphql/GraphQLApp.java delete mode 100644 agent-test/src/test/java/graphql/test/AgentTest.java delete mode 100644 agent-test/src/test/java/graphql/test/LoadAgent.java delete mode 100644 agent-test/src/test/java/graphql/test/StartAgentOnStartupTest.java delete mode 100644 agent-test/src/test/java/graphql/test/TestQuery.java delete mode 100644 agent/build.gradle delete mode 100644 agent/src/main/java/graphql/agent/GraphQLJavaAgent.java diff --git a/agent-test/build.gradle b/agent-test/build.gradle deleted file mode 100644 index 9b028d8f91..0000000000 --- a/agent-test/build.gradle +++ /dev/null @@ -1,57 +0,0 @@ -plugins { - id 'java' -} - -dependencies { - implementation(rootProject) - implementation("net.bytebuddy:byte-buddy-agent:1.17.6") - - testImplementation 'org.junit.jupiter:junit-jupiter:5.13.3' - testRuntimeOnly 'org.junit.platform:junit-platform-launcher' - - testImplementation("org.assertj:assertj-core:3.27.3") - -} - -java { - toolchain { - languageVersion = JavaLanguageVersion.of(11) - } -} - -tasks.named('test', Test) { - dependsOn(':agent:shadowJar') - useJUnitPlatform() - - maxHeapSize = '4G' - - testLogging { - events "passed" - } -} - - -repositories { - mavenCentral() - mavenLocal() -} - - -java { - toolchain { - languageVersion = JavaLanguageVersion.of(11) - } -} - - -jar { - manifest { - attributes( - 'Agent-Class': 'graphql.agent.GraphQLJavaAgent', - 'Can-Redefine-Classes': 'true', - 'Can-Retransform-Classes': 'true', - 'Premain-Class': 'graphql.agent.GraphQLJavaAgent' - ) - } -} - diff --git a/agent-test/src/main/java/graphql/GraphQLApp.java b/agent-test/src/main/java/graphql/GraphQLApp.java deleted file mode 100644 index 9d12bfdb15..0000000000 --- a/agent-test/src/main/java/graphql/GraphQLApp.java +++ /dev/null @@ -1,40 +0,0 @@ -package graphql; - -import graphql.agent.result.ExecutionTrackingResult; -import graphql.schema.GraphQLSchema; -import graphql.schema.idl.RuntimeWiring; -import graphql.schema.idl.SchemaGenerator; -import graphql.schema.idl.SchemaParser; -import graphql.schema.idl.TypeDefinitionRegistry; - -/** - * Used for testing loading the agent on startup. - * See StartAgentOnStartupTest - */ -public class GraphQLApp { - - public static void main(String[] args) { - String schema = "type Query { hello: String }"; - TypeDefinitionRegistry typeDefinitionRegistry = new SchemaParser().parse(schema); - RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring() - .type("Query", builder -> builder.dataFetcher("hello", environment -> "world")) - .build(); - GraphQLSchema graphQLSchema = new SchemaGenerator().makeExecutableSchema(typeDefinitionRegistry, runtimeWiring); - GraphQL graphQL = GraphQL.newGraphQL(graphQLSchema).build(); - ExecutionInput executionInput = ExecutionInput.newExecutionInput().query("{ hello alias: hello alias2: hello }").build(); - GraphQLContext graphQLContext = executionInput.getGraphQLContext(); - ExecutionResult executionResult = graphQL.execute(executionInput); - System.out.println(executionResult.getData().toString()); - ExecutionTrackingResult executionTrackingResult = graphQLContext.get(ExecutionTrackingResult.EXECUTION_TRACKING_KEY); - if (executionTrackingResult == null) { - System.out.println("No tracking data found"); - System.exit(1); - } - if (executionTrackingResult.timePerPath.size() != 3) { - System.out.println("Expected 3 paths, got " + executionTrackingResult.timePerPath.size()); - System.exit(1); - } - System.out.println("Successfully tracked execution"); - System.exit(0); - } -} diff --git a/agent-test/src/test/java/graphql/test/AgentTest.java b/agent-test/src/test/java/graphql/test/AgentTest.java deleted file mode 100644 index a0add765c2..0000000000 --- a/agent-test/src/test/java/graphql/test/AgentTest.java +++ /dev/null @@ -1,72 +0,0 @@ -package graphql.test; - -import graphql.agent.result.ExecutionTrackingResult; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; - -import java.util.Collections; -import java.util.List; -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; - -public class AgentTest { - - @BeforeAll - static void init() { - LoadAgent.loadIntoCurrentJVM(); - } - - @AfterAll - static void cleanup() { - } - - @Test - void test() { - ExecutionTrackingResult executionTrackingResult = TestQuery.executeQuery(); - assertThat(executionTrackingResult.dataFetcherCount()).isEqualTo(5); - assertThat(executionTrackingResult.getTime("/issues")).isGreaterThan(100); - assertThat(executionTrackingResult.getDfResultTypes("/issues")) - .isEqualTo(ExecutionTrackingResult.DFResultType.DONE_OK); - - verifyAgentDataIsEmpty(); - - } - - @Test - void testBatchLoader() { - ExecutionTrackingResult executionTrackingResult = TestQuery.executeBatchedQuery(); - assertThat(executionTrackingResult.dataFetcherCount()).isEqualTo(9); - assertThat(executionTrackingResult.getTime("/issues")).isGreaterThan(100); - assertThat(executionTrackingResult.getDfResultTypes("/issues[0]/author")) - .isEqualTo(ExecutionTrackingResult.DFResultType.PENDING); - assertThat(executionTrackingResult.getDfResultTypes("/issues[1]/author")) - .isEqualTo(ExecutionTrackingResult.DFResultType.PENDING); - - assertThat(executionTrackingResult.getDataLoaderNames()).isEqualTo(Collections.singletonList("userLoader")); - - assertThat(executionTrackingResult.dataLoaderNameToBatchCall).hasSize(1); - List userLoaderCalls = executionTrackingResult.dataLoaderNameToBatchCall.get("userLoader"); - assertThat(userLoaderCalls).hasSize(1); - ExecutionTrackingResult.BatchLoadingCall batchLoadingCall = userLoaderCalls.get(0); - - assertThat(batchLoadingCall.keyCount).isEqualTo(2); - - verifyAgentDataIsEmpty(); - } - - private void verifyAgentDataIsEmpty() { - try { - Class agent = Class.forName("graphql.agent.GraphQLJavaAgent"); - Map executionIdToData = (Map) agent.getField("executionIdToData").get(null); - Map dataLoaderToExecutionId = (Map) agent.getField("dataLoaderToExecutionId").get(null); - assertThat(executionIdToData).isEmpty(); - assertThat(dataLoaderToExecutionId).isEmpty(); - - } catch (Exception e) { - throw new RuntimeException(e); - } - - } -} diff --git a/agent-test/src/test/java/graphql/test/LoadAgent.java b/agent-test/src/test/java/graphql/test/LoadAgent.java deleted file mode 100644 index 90ec46a078..0000000000 --- a/agent-test/src/test/java/graphql/test/LoadAgent.java +++ /dev/null @@ -1,15 +0,0 @@ -package graphql.test; - -import net.bytebuddy.agent.ByteBuddyAgent; - -import java.io.File; - - -public class LoadAgent { - - - public static void loadIntoCurrentJVM() { - ByteBuddyAgent.attach(new File("../agent/build/libs/agent.jar"), String.valueOf(ProcessHandle.current().pid())); - } - -} diff --git a/agent-test/src/test/java/graphql/test/StartAgentOnStartupTest.java b/agent-test/src/test/java/graphql/test/StartAgentOnStartupTest.java deleted file mode 100644 index e4c8c3add6..0000000000 --- a/agent-test/src/test/java/graphql/test/StartAgentOnStartupTest.java +++ /dev/null @@ -1,23 +0,0 @@ -package graphql.test; - -import org.junit.jupiter.api.Test; - -import java.io.IOException; - -import static org.assertj.core.api.Assertions.assertThat; - -public class StartAgentOnStartupTest { - - - @Test - void testAgentCanBeLoadedAtStartup() throws IOException, InterruptedException { - // we use the classpath of the current test - String classPath = System.getProperty("java.class.path"); - ProcessBuilder processBuilder = new ProcessBuilder("java", "-javaagent:../agent/build/libs/agent.jar", "-classpath", classPath, "graphql.GraphQLApp"); - Process process = processBuilder.start(); - process.getErrorStream().transferTo(System.err); - process.getInputStream().transferTo(System.out); - int i = process.waitFor(); - assertThat(i).isZero(); - } -} diff --git a/agent-test/src/test/java/graphql/test/TestQuery.java b/agent-test/src/test/java/graphql/test/TestQuery.java deleted file mode 100644 index 2755cf230f..0000000000 --- a/agent-test/src/test/java/graphql/test/TestQuery.java +++ /dev/null @@ -1,102 +0,0 @@ -package graphql.test; - -import graphql.ExecutionInput; -import graphql.ExecutionResult; -import graphql.GraphQL; -import graphql.agent.result.ExecutionTrackingResult; -import graphql.schema.DataFetcher; -import graphql.schema.GraphQLSchema; -import graphql.schema.idl.RuntimeWiring; -import graphql.schema.idl.SchemaGenerator; -import graphql.schema.idl.SchemaParser; -import graphql.schema.idl.TypeDefinitionRegistry; -import org.assertj.core.api.Assertions; -import org.dataloader.BatchLoader; -import org.dataloader.DataLoader; -import org.dataloader.DataLoaderFactory; -import org.dataloader.DataLoaderRegistry; - -import java.util.List; -import java.util.Map; -import java.util.concurrent.CompletableFuture; - -public class TestQuery { - - - static ExecutionTrackingResult executeQuery() { - String sdl = "type Query{issues: [Issue]} type Issue {id: ID, title: String}"; - TypeDefinitionRegistry typeDefinitionRegistry = new SchemaParser().parse(sdl); - DataFetcher issuesDF = (env) -> { - return List.of( - Map.of("id", "1", "title", "issue-1"), - Map.of("id", "2", "title", "issue-2")); - }; - - RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring() - .type("Query", builder -> builder.dataFetcher("issues", issuesDF)) - .build(); - GraphQLSchema graphQLSchema = new SchemaGenerator().makeExecutableSchema(typeDefinitionRegistry, runtimeWiring); - - GraphQL graphQL = GraphQL.newGraphQL(graphQLSchema).build(); - - ExecutionInput executionInput = ExecutionInput.newExecutionInput().query("{issues{id title}}").build(); - ExecutionResult result = graphQL.execute(executionInput); - Assertions.assertThat(result.getErrors()).isEmpty(); - ExecutionTrackingResult trackingResult = executionInput.getGraphQLContext().get(ExecutionTrackingResult.EXECUTION_TRACKING_KEY); - return trackingResult; - } - - static ExecutionTrackingResult executeBatchedQuery() { - String sdl = "type Query{issues: [Issue]} " + - "type Issue {id: ID, author: User}" + - "type User {id: ID, name: String}"; - - DataFetcher issuesDF = (env) -> List.of( - Map.of("id", "1", "title", "issue-1", "authorId", "user-1"), - Map.of("id", "2", "title", "issue-2", "authorId", "user-2")); - - BatchLoader userBatchLoader = keys -> { - // System.out.println("batch users with keys: " + keys); - return CompletableFuture.supplyAsync(() -> { - try { - Thread.sleep(100); - } catch (InterruptedException e) { - throw new RuntimeException(e); - } - return List.of( - Map.of("id", "user-1", "name", "Foo-1"), - Map.of("id", "user-2", "name", "Foo-2") - ); - }); - }; - DataLoaderRegistry dataLoaderRegistry = new DataLoaderRegistry(); - dataLoaderRegistry.register("userLoader", DataLoaderFactory.newDataLoader(userBatchLoader)); - - DataFetcher> authorDF = (env) -> { - DataLoader userLoader = env.getDataLoader("userLoader"); - // System.out.println("author id: " + (String) ((Map) env.getSource()).get("authorId")); - return userLoader.load((String) ((Map) env.getSource()).get("authorId")); - }; - TypeDefinitionRegistry typeDefinitionRegistry = new SchemaParser().parse(sdl); - - RuntimeWiring runtimeWiring = RuntimeWiring.newRuntimeWiring() - .type("Query", builder -> builder.dataFetcher("issues", issuesDF)) - .type("Issue", builder -> builder.dataFetcher("author", authorDF)) - .build(); - GraphQLSchema graphQLSchema = new SchemaGenerator().makeExecutableSchema(typeDefinitionRegistry, runtimeWiring); - - GraphQL graphQL = GraphQL.newGraphQL(graphQLSchema).build(); - String query = "{issues" + - "{id author {id name}}" + - "}"; - ExecutionInput executionInput = ExecutionInput.newExecutionInput() - .dataLoaderRegistry(dataLoaderRegistry) - .query(query).build(); - ExecutionResult result = graphQL.execute(executionInput); - Assertions.assertThat(result.getErrors()).isEmpty(); - ExecutionTrackingResult trackingResult = executionInput.getGraphQLContext().get(ExecutionTrackingResult.EXECUTION_TRACKING_KEY); - return trackingResult; - } - - -} diff --git a/agent/build.gradle b/agent/build.gradle deleted file mode 100644 index 1c42010043..0000000000 --- a/agent/build.gradle +++ /dev/null @@ -1,124 +0,0 @@ -plugins { - id 'java' - id 'java-library' - id 'maven-publish' - id "com.gradleup.shadow" version "8.3.8" -} - -dependencies { - implementation("net.bytebuddy:byte-buddy:1.17.6") - // graphql-java itself - implementation(rootProject) -} - -repositories { - mavenCentral() - mavenLocal() -} - - -java { - toolchain { - languageVersion = JavaLanguageVersion.of(11) - } -} - -shadowJar { - minimize() - archiveClassifier.set('') - configurations = [project.configurations.compileClasspath] - dependencies { - exclude(dependency(rootProject)) - } - manifest { - attributes( - 'Agent-Class': 'graphql.agent.GraphQLJavaAgent', - 'Premain-Class': 'graphql.agent.GraphQLJavaAgent', - 'Can-Redefine-Classes': 'true', - 'Can-Retransform-Classes': 'true', - ) - } -} - -task sourcesJar(type: Jar) { - dependsOn classes - archiveClassifier = 'sources' - from sourceSets.main.allSource -} - -task javadocJar(type: Jar, dependsOn: javadoc) { - archiveClassifier = 'javadoc' - from javadoc.destinationDir -} - -publishing { - - publications { - - agent(MavenPublication) { - version rootProject.version - group rootProject.group - artifactId 'graphql-java-agent' - from components.java - - artifact sourcesJar { - archiveClassifier = "sources" - } - artifact javadocJar { - archiveClassifier = "javadoc" - } - pom.withXml { - // removing the shaded dependencies from the pom - def pomNode = asNode() - pomNode.dependencies.'*'.findAll() { - it.artifactId.text() == 'graphql-java' || it.artifactId.text() == 'byte-buddy' - }.each() { - it.parent().remove(it) - } - pomNode.children().last() + { - resolveStrategy = Closure.DELEGATE_FIRST - name 'graphql-java-agent' - description 'GraphqL Java Agent' - url "https://github.com/graphql-java/graphql-java" - scm { - url "https://github.com/graphql-java/graphql-java" - connection "https://github.com/graphql-java/graphql-java" - developerConnection "https://github.com/graphql-java/graphql-java" - } - licenses { - license { - name 'MIT' - url 'https://github.com/graphql-java/graphql-java/blob/master/LICENSE.md' - distribution 'repo' - } - } - developers { - developer { - id 'andimarek' - name 'Andreas Marek' - } - } - } - } - } - } -} - -signing { - required { !project.hasProperty('publishToMavenLocal') } - def signingKey = System.env.MAVEN_CENTRAL_PGP_KEY - useInMemoryPgpKeys(signingKey, "") - sign publishing.publications -} - - -// all publish tasks depend on the build task -tasks.withType(PublishToMavenRepository) { - dependsOn build -} - -// Only publish Maven POM, disable default Gradle modules file -tasks.withType(GenerateModuleMetadata) { - enabled = false -} - diff --git a/agent/src/main/java/graphql/agent/GraphQLJavaAgent.java b/agent/src/main/java/graphql/agent/GraphQLJavaAgent.java deleted file mode 100644 index 6169e2e7bd..0000000000 --- a/agent/src/main/java/graphql/agent/GraphQLJavaAgent.java +++ /dev/null @@ -1,301 +0,0 @@ -package graphql.agent; - -import graphql.agent.result.ExecutionTrackingResult; -import graphql.execution.ExecutionContext; -import graphql.execution.ExecutionId; -import graphql.execution.ExecutionStrategyParameters; -import graphql.execution.ResultPath; -import graphql.schema.DataFetchingEnvironment; -import net.bytebuddy.agent.builder.AgentBuilder; -import net.bytebuddy.asm.Advice; -import net.bytebuddy.implementation.bytecode.assign.Assigner; -import org.dataloader.DataLoader; -import org.dataloader.DataLoaderRegistry; -import org.dataloader.DispatchResult; - -import java.lang.instrument.Instrumentation; -import java.lang.reflect.Field; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ConcurrentHashMap; -import java.util.function.BiConsumer; - -import static graphql.agent.result.ExecutionTrackingResult.DFResultType.DONE_CANCELLED; -import static graphql.agent.result.ExecutionTrackingResult.DFResultType.DONE_EXCEPTIONALLY; -import static graphql.agent.result.ExecutionTrackingResult.DFResultType.DONE_OK; -import static graphql.agent.result.ExecutionTrackingResult.DFResultType.PENDING; -import static graphql.agent.result.ExecutionTrackingResult.EXECUTION_TRACKING_KEY; -import static net.bytebuddy.matcher.ElementMatchers.nameMatches; -import static net.bytebuddy.matcher.ElementMatchers.named; -import static net.bytebuddy.matcher.ElementMatchers.takesArguments; - -public class GraphQLJavaAgent { - - - public static final Map executionIdToData = new ConcurrentHashMap<>(); - public static final Map dataLoaderToExecutionId = new ConcurrentHashMap<>(); - - public static void premain(String agentArgs, Instrumentation inst) { - agentmain(agentArgs, inst); - } - - - public static void agentmain(String agentArgs, Instrumentation inst) { - System.out.println("GraphQL Java Agent is starting"); - new AgentBuilder.Default() - .type(named("graphql.execution.Execution")) - .transform((builder, typeDescription, classLoader, module, protectionDomain) -> { - return builder - .visit(Advice.to(ExecutionAdvice.class).on(nameMatches("executeOperation"))); - - }) - .type(named("graphql.execution.ExecutionStrategy")) - .transform((builder, typeDescription, classLoader, module, protectionDomain) -> { - return builder - .visit(Advice.to(DataFetcherInvokeAdvice.class).on(nameMatches("invokeDataFetcher"))); - }) - .type(named("org.dataloader.DataLoaderRegistry")) - .transform((builder, typeDescription, classLoader, module, protectionDomain) -> { - return builder - .visit(Advice.to(DataLoaderRegistryAdvice.class).on(nameMatches("dispatchAll"))); - }) - .type(named("org.dataloader.DataLoader")) - .transform((builder, typeDescription, classLoader, module, protectionDomain) -> { - return builder - .visit(Advice.to(DataLoaderLoadAdvice.class).on(nameMatches("load"))); - }) - .type(named("org.dataloader.DataLoaderHelper")) - .transform((builder, typeDescription, classLoader, module, protectionDomain) -> { - return builder - .visit(Advice.to(DataLoaderHelperDispatchAdvice.class).on(nameMatches("dispatch"))) - .visit(Advice.to(DataLoaderHelperInvokeBatchLoaderAdvice.class) - .on(nameMatches("invokeLoader").and(takesArguments(List.class, List.class, List.class)))); - }) - .type(named("graphql.schema.DataFetchingEnvironmentImpl")) - .transform((builder, typeDescription, classLoader, module, protectionDomain) -> { - return builder - .visit(Advice.to(DataFetchingEnvironmentAdvice.class).on(nameMatches("getDataLoader"))); - }) - .disableClassFormatChanges() - .installOn(inst); - - } - - public static class ExecutionAdvice { - - public static class AfterExecutionHandler implements BiConsumer { - - private final ExecutionContext executionContext; - - public AfterExecutionHandler(ExecutionContext executionContext) { - this.executionContext = executionContext; - } - - public void accept(Object o, Throwable throwable) { - ExecutionId executionId = executionContext.getExecutionId(); - ExecutionTrackingResult executionTrackingResult = GraphQLJavaAgent.executionIdToData.get(executionId); - executionTrackingResult.endExecutionTime.set(System.nanoTime()); - executionTrackingResult.endThread.set(Thread.currentThread().getName()); - executionContext.getGraphQLContext().put(EXECUTION_TRACKING_KEY, executionTrackingResult); - // cleanup - for (DataLoader dataLoader : executionTrackingResult.dataLoaderToName.keySet()) { - dataLoaderToExecutionId.remove(dataLoader); - } - executionIdToData.remove(executionId); - - } - - } - - - @Advice.OnMethodEnter - public static void executeOperationEnter(@Advice.Argument(0) ExecutionContext executionContext) { - ExecutionTrackingResult executionTrackingResult = new ExecutionTrackingResult(); - executionTrackingResult.startExecutionTime.set(System.nanoTime()); - executionTrackingResult.startThread.set(Thread.currentThread().getName()); - executionContext.getGraphQLContext().put(EXECUTION_TRACKING_KEY, new ExecutionTrackingResult()); - - GraphQLJavaAgent.executionIdToData.put(executionContext.getExecutionId(), executionTrackingResult); - - DataLoaderRegistry dataLoaderRegistry = executionContext.getDataLoaderRegistry(); - for (String name : dataLoaderRegistry.getDataLoadersMap().keySet()) { - DataLoader dataLoader = dataLoaderRegistry.getDataLoader(name); - GraphQLJavaAgent.dataLoaderToExecutionId.put(dataLoader, executionContext.getExecutionId()); - executionTrackingResult.dataLoaderToName.put(dataLoader, name); - } - } - - @Advice.OnMethodExit - public static void executeOperationExit(@Advice.Argument(0) ExecutionContext executionContext, - @Advice.Return(typing = Assigner.Typing.DYNAMIC) CompletableFuture result) { - - result.whenComplete(new AfterExecutionHandler(executionContext)); - } - } - - public static class DataFetcherInvokeAdvice { - - public static class DataFetcherFinishedHandler implements BiConsumer { - - private final ExecutionContext executionContext; - private final ExecutionStrategyParameters parameters; - private final long startTime; - - public DataFetcherFinishedHandler(ExecutionContext executionContext, ExecutionStrategyParameters parameters, long startTime) { - this.executionContext = executionContext; - this.parameters = parameters; - this.startTime = startTime; - } - - @Override - public void accept(Object o, Throwable throwable) { - ExecutionId executionId = executionContext.getExecutionId(); - ExecutionTrackingResult executionTrackingResult = GraphQLJavaAgent.executionIdToData.get(executionId); - ResultPath path = parameters.getPath(); - executionTrackingResult.finishedTimePerPath.put(path, System.nanoTime() - startTime); - executionTrackingResult.finishedThreadPerPath.put(path, Thread.currentThread().getName()); - } - } - - @Advice.OnMethodEnter - public static void invokeDataFetcherEnter(@Advice.Argument(0) ExecutionContext executionContext, - @Advice.Argument(1) ExecutionStrategyParameters parameters) { - ExecutionTrackingResult executionTrackingResult = GraphQLJavaAgent.executionIdToData.get(executionContext.getExecutionId()); - executionTrackingResult.start(parameters.getPath(), System.nanoTime()); - executionTrackingResult.startInvocationThreadPerPath.put(parameters.getPath(), Thread.currentThread().getName()); - } - - @Advice.OnMethodExit - public static void invokeDataFetcherExit(@Advice.Argument(0) ExecutionContext executionContext, - @Advice.Argument(1) ExecutionStrategyParameters parameters, - @Advice.Return(readOnly = false) Object cfOrObject) { - // ExecutionTrackingResult executionTrackingResult = executionContext.getGraphQLContext().get(EXECUTION_TRACKING_KEY); - ExecutionTrackingResult executionTrackingResult = GraphQLJavaAgent.executionIdToData.get(executionContext.getExecutionId()); - ResultPath path = parameters.getPath(); - long startTime = executionTrackingResult.timePerPath.get(path); - executionTrackingResult.end(path, System.nanoTime()); - if (cfOrObject instanceof CompletableFuture) { - CompletableFuture result = (CompletableFuture) cfOrObject; - if (result.isDone()) { - if (result.isCancelled()) { - executionTrackingResult.setDfResultTypes(path, DONE_CANCELLED); - } else if (result.isCompletedExceptionally()) { - executionTrackingResult.setDfResultTypes(path, DONE_EXCEPTIONALLY); - } else { - executionTrackingResult.setDfResultTypes(path, DONE_OK); - } - } else { - executionTrackingResult.setDfResultTypes(path, PENDING); - } - // overriding the result to make sure the finished handler is called first when the DF is finished - // otherwise it is a completion tree instead of chain - cfOrObject = result.whenComplete(new DataFetcherFinishedHandler(executionContext, parameters, startTime)); - } else { - // materialized value - not a CF - executionTrackingResult.setDfResultTypes(path, DONE_OK); - new DataFetcherFinishedHandler(executionContext, parameters, startTime).accept(cfOrObject, null); - } - } - - } - - - public static class DataLoaderHelperInvokeBatchLoaderAdvice { - - @Advice.OnMethodEnter - public static void invokeLoader(@Advice.Argument(0) List keys, - @Advice.Argument(1) List keysContext, - @Advice.Argument(2) List queuedFutures, - @Advice.This(typing = Assigner.Typing.DYNAMIC) Object dataLoaderHelper) { - DataLoader dataLoader = getDataLoaderForHelper(dataLoaderHelper); - ExecutionId executionId = GraphQLJavaAgent.dataLoaderToExecutionId.get(dataLoader); - ExecutionTrackingResult executionTrackingResult = GraphQLJavaAgent.executionIdToData.get(executionId); - String dataLoaderName = executionTrackingResult.dataLoaderToName.get(dataLoader); - - synchronized (executionTrackingResult.dataLoaderNameToBatchCall) { - executionTrackingResult.dataLoaderNameToBatchCall.putIfAbsent(dataLoaderName, new ArrayList<>()); - executionTrackingResult.dataLoaderNameToBatchCall.get(dataLoaderName) - .add(new ExecutionTrackingResult.BatchLoadingCall(keys.size(), Thread.currentThread().getName())); - } - - } - } - - public static class DataLoaderHelperDispatchAdvice { - - @Advice.OnMethodExit - public static void dispatch(@Advice.This(typing = Assigner.Typing.DYNAMIC) Object dataLoaderHelper, - @Advice.Return(typing = Assigner.Typing.DYNAMIC) DispatchResult dispatchResult) { - try { - // System.out.println("dataloader helper Dispatch " + dataLoaderHelper + " load for execution " + dispatchResult); - // DataLoader dataLoader = getDataLoaderForHelper(dataLoaderHelper); - // // System.out.println("dataLoader: " + dataLoader); - // ExecutionId executionId = GraphQLJavaAgent.dataLoaderToExecutionId.get(dataLoader); - // ExecutionTrackingResult ExecutionTrackingResult = GraphQLJavaAgent.executionIdToData.get(executionId); - // String dataLoaderName = ExecutionTrackingResult.dataLoaderToName.get(dataLoader); - // - // ExecutionTrackingResult.dataLoaderNameToBatchCall.putIfAbsent(dataLoaderName, new ArrayList<>()); - // ExecutionTrackingResult.dataLoaderNameToBatchCall.get(dataLoaderName).add(new ExecutionTrackingResult.BatchLoadingCall(dispatchResult.getKeysCount())); - - } catch (Exception e) { - e.printStackTrace(); - } - - } - - } - - public static DataLoader getDataLoaderForHelper(Object dataLoaderHelper) { - try { - Field field = dataLoaderHelper.getClass().getDeclaredField("dataLoader"); - field.setAccessible(true); - return (DataLoader) field.get(dataLoaderHelper); - } catch (Exception e) { - e.printStackTrace(); - throw new RuntimeException(e); - } - } - - -} - -class DataFetchingEnvironmentAdvice { - - - @Advice.OnMethodExit - public static void getDataLoader(@Advice.Argument(0) String dataLoaderName, - @Advice.This(typing = Assigner.Typing.DYNAMIC) DataFetchingEnvironment dataFetchingEnvironment, - @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) DataLoader dataLoader) { - ExecutionTrackingResult executionTrackingResult = GraphQLJavaAgent.executionIdToData.get(dataFetchingEnvironment.getExecutionId()); - ResultPath resultPath = dataFetchingEnvironment.getExecutionStepInfo().getPath(); - executionTrackingResult.resultPathToDataLoaderUsed.put(resultPath, dataLoaderName); - - } - -} - - -class DataLoaderLoadAdvice { - - @Advice.OnMethodEnter - public static void load(@Advice.This(typing = Assigner.Typing.DYNAMIC) Object dataLoader) { - ExecutionId executionId = GraphQLJavaAgent.dataLoaderToExecutionId.get(dataLoader); - String dataLoaderName = GraphQLJavaAgent.executionIdToData.get(executionId).dataLoaderToName.get(dataLoader); - } - -} - -class DataLoaderRegistryAdvice { - - @Advice.OnMethodEnter - public static void dispatchAll(@Advice.This(typing = Assigner.Typing.DYNAMIC) Object dataLoaderRegistry) { - List> dataLoaders = ((DataLoaderRegistry) dataLoaderRegistry).getDataLoaders(); - ExecutionId executionId = GraphQLJavaAgent.dataLoaderToExecutionId.get(dataLoaders.get(0)); - } - -} - - - diff --git a/settings.gradle b/settings.gradle index 4667568288..b4870c3fc3 100644 --- a/settings.gradle +++ b/settings.gradle @@ -17,4 +17,3 @@ plugins { } rootProject.name = 'graphql-java' -include("agent", "agent-test") From 8e6a1aa6dcd145d7727c37a5b347614055589f9a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 27 Jul 2025 09:24:43 +0000 Subject: [PATCH 13/14] Add performance results for commit b09381df9d22c7e0cf40fbec37c0c31777cd1f1c --- ...d22c7e0cf40fbec37c0c31777cd1f1c-jdk17.json | 1279 +++++++++++++++++ 1 file changed, 1279 insertions(+) create mode 100644 performance-results/2025-07-27T09:24:22Z-b09381df9d22c7e0cf40fbec37c0c31777cd1f1c-jdk17.json diff --git a/performance-results/2025-07-27T09:24:22Z-b09381df9d22c7e0cf40fbec37c0c31777cd1f1c-jdk17.json b/performance-results/2025-07-27T09:24:22Z-b09381df9d22c7e0cf40fbec37c0c31777cd1f1c-jdk17.json new file mode 100644 index 0000000000..2bfb72f2d0 --- /dev/null +++ b/performance-results/2025-07-27T09:24:22Z-b09381df9d22c7e0cf40fbec37c0c31777cd1f1c-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.3480527247230194, + "scoreError" : 0.012743480511871318, + "scoreConfidence" : [ + 3.3353092442111483, + 3.3607962052348905 + ], + "scorePercentiles" : { + "0.0" : 3.3455154146994603, + "50.0" : 3.3483735517415854, + "90.0" : 3.349948380709445, + "95.0" : 3.349948380709445, + "99.0" : 3.349948380709445, + "99.9" : 3.349948380709445, + "99.99" : 3.349948380709445, + "99.999" : 3.349948380709445, + "99.9999" : 3.349948380709445, + "100.0" : 3.349948380709445 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.3455154146994603, + 3.3492190810125106 + ], + [ + 3.3475280224706605, + 3.349948380709445 + ] + ] + }, + "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.6899168268853022, + "scoreError" : 0.07319984246382837, + "scoreConfidence" : [ + 1.616716984421474, + 1.7631166693491305 + ], + "scorePercentiles" : { + "0.0" : 1.6758231560635783, + "50.0" : 1.692186231166425, + "90.0" : 1.6994716891447805, + "95.0" : 1.6994716891447805, + "99.0" : 1.6994716891447805, + "99.9" : 1.6994716891447805, + "99.99" : 1.6994716891447805, + "99.999" : 1.6994716891447805, + "99.9999" : 1.6994716891447805, + "100.0" : 1.6994716891447805 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.698694951104173, + 1.6994716891447805 + ], + [ + 1.6758231560635783, + 1.6856775112286773 + ] + ] + }, + "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.8496055007675353, + "scoreError" : 0.024271144244446485, + "scoreConfidence" : [ + 0.8253343565230888, + 0.8738766450119817 + ], + "scorePercentiles" : { + "0.0" : 0.8460206409848652, + "50.0" : 0.8487520857991151, + "90.0" : 0.8548971904870462, + "95.0" : 0.8548971904870462, + "99.0" : 0.8548971904870462, + "99.9" : 0.8548971904870462, + "99.99" : 0.8548971904870462, + "99.999" : 0.8548971904870462, + "99.9999" : 0.8548971904870462, + "100.0" : 0.8548971904870462 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.8486731288187406, + 0.8548971904870462 + ], + [ + 0.8460206409848652, + 0.8488310427794895 + ] + ] + }, + "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.375572927204825, + "scoreError" : 0.32121140463545256, + "scoreConfidence" : [ + 16.054361522569373, + 16.696784331840277 + ], + "scorePercentiles" : { + "0.0" : 16.223867171282226, + "50.0" : 16.385003305280673, + "90.0" : 16.48545098231728, + "95.0" : 16.48545098231728, + "99.0" : 16.48545098231728, + "99.9" : 16.48545098231728, + "99.99" : 16.48545098231728, + "99.999" : 16.48545098231728, + "99.9999" : 16.48545098231728, + "100.0" : 16.48545098231728 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 16.303640931884864, + 16.223867171282226, + 16.29530655026829 + ], + [ + 16.466365678676482, + 16.47880624879981, + 16.48545098231728 + ] + ] + }, + "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" : 2752.0578556027504, + "scoreError" : 123.19634072686533, + "scoreConfidence" : [ + 2628.861514875885, + 2875.2541963296158 + ], + "scorePercentiles" : { + "0.0" : 2710.2566488690954, + "50.0" : 2752.0432644794128, + "90.0" : 2792.8334573625502, + "95.0" : 2792.8334573625502, + "99.0" : 2792.8334573625502, + "99.9" : 2792.8334573625502, + "99.99" : 2792.8334573625502, + "99.999" : 2792.8334573625502, + "99.9999" : 2792.8334573625502, + "100.0" : 2792.8334573625502 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2712.841558289169, + 2710.2566488690954, + 2712.7954990856365 + ], + [ + 2792.3749993403962, + 2792.8334573625502, + 2791.244970669656 + ] + ] + }, + "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" : 75688.79805559274, + "scoreError" : 6403.278749229374, + "scoreConfidence" : [ + 69285.51930636336, + 82092.0768048221 + ], + "scorePercentiles" : { + "0.0" : 73588.24872656632, + "50.0" : 75665.19656631522, + "90.0" : 77812.64230236896, + "95.0" : 77812.64230236896, + "99.0" : 77812.64230236896, + "99.9" : 77812.64230236896, + "99.99" : 77812.64230236896, + "99.999" : 77812.64230236896, + "99.9999" : 77812.64230236896, + "100.0" : 77812.64230236896 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 77700.82911163302, + 77812.64230236896, + 77805.41060635136 + ], + [ + 73588.24872656632, + 73629.56402099741, + 73596.09356563933 + ] + ] + }, + "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" : 365.8627288594442, + "scoreError" : 10.42048602500302, + "scoreConfidence" : [ + 355.4422428344412, + 376.2832148844472 + ], + "scorePercentiles" : { + "0.0" : 362.15098246615713, + "50.0" : 365.84617795527276, + "90.0" : 369.81297960361985, + "95.0" : 369.81297960361985, + "99.0" : 369.81297960361985, + "99.9" : 369.81297960361985, + "99.99" : 369.81297960361985, + "99.999" : 369.81297960361985, + "99.9999" : 369.81297960361985, + "100.0" : 369.81297960361985 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 368.7153027027884, + 369.16429250997413, + 369.81297960361985 + ], + [ + 362.15098246615713, + 362.3557626663687, + 362.9770532077572 + ] + ] + }, + "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.74427882855461, + "scoreError" : 1.9491424437607001, + "scoreConfidence" : [ + 111.7951363847939, + 115.69342127231532 + ], + "scorePercentiles" : { + "0.0" : 112.58434260275494, + "50.0" : 113.79067030125663, + "90.0" : 114.69661771144031, + "95.0" : 114.69661771144031, + "99.0" : 114.69661771144031, + "99.9" : 114.69661771144031, + "99.99" : 114.69661771144031, + "99.999" : 114.69661771144031, + "99.9999" : 114.69661771144031, + "100.0" : 114.69661771144031 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 114.07493084756696, + 113.52844120705214, + 114.69661771144031 + ], + [ + 112.58434260275494, + 113.82990878972608, + 113.75143181278719 + ] + ] + }, + "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.06162743718018923, + "scoreError" : 3.591914278173167E-4, + "scoreConfidence" : [ + 0.061268245752371914, + 0.06198662860800655 + ], + "scorePercentiles" : { + "0.0" : 0.061477613267922025, + "50.0" : 0.06161646286462216, + "90.0" : 0.06180226438578818, + "95.0" : 0.06180226438578818, + "99.0" : 0.06180226438578818, + "99.9" : 0.06180226438578818, + "99.99" : 0.06180226438578818, + "99.999" : 0.06180226438578818, + "99.9999" : 0.06180226438578818, + "100.0" : 0.06180226438578818 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.06180226438578818, + 0.061477613267922025, + 0.0616938086468879 + ], + [ + 0.06153911708235642, + 0.06171760130468861, + 0.061534218393492254 + ] + ] + }, + "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.707365752780934E-4, + "scoreError" : 1.3112036792635523E-5, + "scoreConfidence" : [ + 3.5762453848545785E-4, + 3.838486120707289E-4 + ], + "scorePercentiles" : { + "0.0" : 3.661568925578196E-4, + "50.0" : 3.7081394770288687E-4, + "90.0" : 3.7513296348639264E-4, + "95.0" : 3.7513296348639264E-4, + "99.0" : 3.7513296348639264E-4, + "99.9" : 3.7513296348639264E-4, + "99.99" : 3.7513296348639264E-4, + "99.999" : 3.7513296348639264E-4, + "99.9999" : 3.7513296348639264E-4, + "100.0" : 3.7513296348639264E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.747989706723821E-4, + 3.750661881631323E-4, + 3.7513296348639264E-4 + ], + [ + 3.668289247333916E-4, + 3.661568925578196E-4, + 3.664355120554419E-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.12515975337827603, + "scoreError" : 0.0018819369363948916, + "scoreConfidence" : [ + 0.12327781644188114, + 0.1270416903146709 + ], + "scorePercentiles" : { + "0.0" : 0.12451498170906329, + "50.0" : 0.125113702460143, + "90.0" : 0.12585044662161313, + "95.0" : 0.12585044662161313, + "99.0" : 0.12585044662161313, + "99.9" : 0.12585044662161313, + "99.99" : 0.12585044662161313, + "99.999" : 0.12585044662161313, + "99.9999" : 0.12585044662161313, + "100.0" : 0.12585044662161313 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.12461622089024026, + 0.12452751233422577, + 0.12451498170906329 + ], + [ + 0.12583817468446815, + 0.12585044662161313, + 0.12561118403004573 + ] + ] + }, + "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.01298828611601984, + "scoreError" : 2.2829858274778095E-4, + "scoreConfidence" : [ + 0.012759987533272059, + 0.01321658469876762 + ], + "scorePercentiles" : { + "0.0" : 0.012909820407557303, + "50.0" : 0.012986902508766352, + "90.0" : 0.013068841367296184, + "95.0" : 0.013068841367296184, + "99.0" : 0.013068841367296184, + "99.9" : 0.013068841367296184, + "99.99" : 0.013068841367296184, + "99.999" : 0.013068841367296184, + "99.9999" : 0.013068841367296184, + "100.0" : 0.013068841367296184 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.013068841367296184, + 0.013054219633024649, + 0.013064214315854932 + ], + [ + 0.012919585384508055, + 0.012913035587877911, + 0.012909820407557303 + ] + ] + }, + "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.9570497101032437, + "scoreError" : 0.06870793812974671, + "scoreConfidence" : [ + 0.888341771973497, + 1.0257576482329904 + ], + "scorePercentiles" : { + "0.0" : 0.9341369757145526, + "50.0" : 0.9572804363022998, + "90.0" : 0.9797242170846395, + "95.0" : 0.9797242170846395, + "99.0" : 0.9797242170846395, + "99.9" : 0.9797242170846395, + "99.99" : 0.9797242170846395, + "99.999" : 0.9797242170846395, + "99.9999" : 0.9797242170846395, + "100.0" : 0.9797242170846395 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.9341369757145526, + 0.9346130296261682, + 0.935307234006734 + ], + [ + 0.9792631655895025, + 0.9797242170846395, + 0.9792536385978655 + ] + ] + }, + "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.010662369221472366, + "scoreError" : 3.6261902408499366E-4, + "scoreConfidence" : [ + 0.010299750197387372, + 0.01102498824555736 + ], + "scorePercentiles" : { + "0.0" : 0.010541451729808362, + "50.0" : 0.01066228605668934, + "90.0" : 0.010782180810757776, + "95.0" : 0.010782180810757776, + "99.0" : 0.010782180810757776, + "99.9" : 0.010782180810757776, + "99.99" : 0.010782180810757776, + "99.999" : 0.010782180810757776, + "99.9999" : 0.010782180810757776, + "100.0" : 0.010782180810757776 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.010780964613447408, + 0.010778053849453465, + 0.010782180810757776 + ], + [ + 0.010545046061441968, + 0.010546518263925215, + 0.010541451729808362 + ] + ] + }, + "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.088338168746136, + "scoreError" : 0.0692484451009362, + "scoreConfidence" : [ + 3.0190897236452, + 3.157586613847072 + ], + "scorePercentiles" : { + "0.0" : 3.060924018971848, + "50.0" : 3.092390426173913, + "90.0" : 3.1151917391033623, + "95.0" : 3.1151917391033623, + "99.0" : 3.1151917391033623, + "99.9" : 3.1151917391033623, + "99.99" : 3.1151917391033623, + "99.999" : 3.1151917391033623, + "99.9999" : 3.1151917391033623, + "100.0" : 3.1151917391033623 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.1151917391033623, + 3.1066782043478263, + 3.1080917582349286 + ], + [ + 3.0610406438188495, + 3.078102648, + 3.060924018971848 + ] + ] + }, + "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.7125927608610696, + "scoreError" : 0.12439364757781035, + "scoreConfidence" : [ + 2.588199113283259, + 2.83698640843888 + ], + "scorePercentiles" : { + "0.0" : 2.6691942740859353, + "50.0" : 2.71111360511988, + "90.0" : 2.7617167856945595, + "95.0" : 2.7617167856945595, + "99.0" : 2.7617167856945595, + "99.9" : 2.7617167856945595, + "99.99" : 2.7617167856945595, + "99.999" : 2.7617167856945595, + "99.9999" : 2.7617167856945595, + "100.0" : 2.7617167856945595 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.6741723772727273, + 2.6737596859128576, + 2.6691942740859353 + ], + [ + 2.7617167856945595, + 2.748054832967033, + 2.748658609233306 + ] + ] + }, + "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.17593930609518574, + "scoreError" : 0.012829140597269412, + "scoreConfidence" : [ + 0.16311016549791632, + 0.18876844669245516 + ], + "scorePercentiles" : { + "0.0" : 0.17177691756703367, + "50.0" : 0.1754336300504918, + "90.0" : 0.18198033134371816, + "95.0" : 0.18198033134371816, + "99.0" : 0.18198033134371816, + "99.9" : 0.18198033134371816, + "99.99" : 0.18198033134371816, + "99.999" : 0.18198033134371816, + "99.9999" : 0.18198033134371816, + "100.0" : 0.18198033134371816 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.18198033134371816, + 0.17908566701885711, + 0.17892025329206326 + ], + [ + 0.17194700680892036, + 0.17177691756703367, + 0.17192566054052194 + ] + ] + }, + "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.3285984612365002, + "scoreError" : 0.010586300929319519, + "scoreConfidence" : [ + 0.3180121603071807, + 0.3391847621658197 + ], + "scorePercentiles" : { + "0.0" : 0.32475763852174194, + "50.0" : 0.32874220721812786, + "90.0" : 0.33208890107262645, + "95.0" : 0.33208890107262645, + "99.0" : 0.33208890107262645, + "99.9" : 0.33208890107262645, + "99.99" : 0.33208890107262645, + "99.999" : 0.33208890107262645, + "99.9999" : 0.33208890107262645, + "100.0" : 0.33208890107262645 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.33208890107262645, + 0.3320516788192715, + 0.3319720958372062 + ], + [ + 0.32551231859904955, + 0.3252081345691057, + 0.32475763852174194 + ] + ] + }, + "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.14286089464430035, + "scoreError" : 0.001063750751637408, + "scoreConfidence" : [ + 0.14179714389266293, + 0.14392464539593777 + ], + "scorePercentiles" : { + "0.0" : 0.14241141853576567, + "50.0" : 0.1429526327523724, + "90.0" : 0.14326526219879088, + "95.0" : 0.14326526219879088, + "99.0" : 0.14326526219879088, + "99.9" : 0.14326526219879088, + "99.99" : 0.14326526219879088, + "99.999" : 0.14326526219879088, + "99.9999" : 0.14326526219879088, + "100.0" : 0.14326526219879088 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.14326526219879088, + 0.14314880849997852, + 0.14314305923190335 + ], + [ + 0.14276220627284147, + 0.14243461312652225, + 0.14241141853576567 + ] + ] + }, + "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.40193088818342976, + "scoreError" : 0.005279078413821035, + "scoreConfidence" : [ + 0.39665180976960873, + 0.4072099665972508 + ], + "scorePercentiles" : { + "0.0" : 0.3989974169326524, + "50.0" : 0.40267258137708883, + "90.0" : 0.40403318698234414, + "95.0" : 0.40403318698234414, + "99.0" : 0.40403318698234414, + "99.9" : 0.40403318698234414, + "99.99" : 0.40403318698234414, + "99.999" : 0.40403318698234414, + "99.9999" : 0.40403318698234414, + "100.0" : 0.40403318698234414 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.40403318698234414, + 0.400304297454167, + 0.3989974169326524 + ], + [ + 0.4026699213609825, + 0.4026752413931951, + 0.402905264977237 + ] + ] + }, + "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.15779688562509273, + "scoreError" : 0.007626460758325325, + "scoreConfidence" : [ + 0.1501704248667674, + 0.16542334638341805 + ], + "scorePercentiles" : { + "0.0" : 0.155282176878882, + "50.0" : 0.15775205581729318, + "90.0" : 0.16046199895701288, + "95.0" : 0.16046199895701288, + "99.0" : 0.16046199895701288, + "99.9" : 0.16046199895701288, + "99.99" : 0.16046199895701288, + "99.999" : 0.16046199895701288, + "99.9999" : 0.16046199895701288, + "100.0" : 0.16046199895701288 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.155282176878882, + 0.1553703675714308, + 0.1552961208497686 + ], + [ + 0.16013374406315553, + 0.16046199895701288, + 0.16023690543030653 + ] + ] + }, + "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.04733881393774781, + "scoreError" : 1.6565757249014737E-4, + "scoreConfidence" : [ + 0.047173156365257665, + 0.047504471510237956 + ], + "scorePercentiles" : { + "0.0" : 0.04728205182978724, + "50.0" : 0.047333661675769204, + "90.0" : 0.0474455739499267, + "95.0" : 0.0474455739499267, + "99.0" : 0.0474455739499267, + "99.9" : 0.0474455739499267, + "99.99" : 0.0474455739499267, + "99.999" : 0.0474455739499267, + "99.9999" : 0.0474455739499267, + "100.0" : 0.0474455739499267 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.04735047274543784, + 0.047335008023174904, + 0.04733231532836351 + ], + [ + 0.04728205182978724, + 0.047287461749796665, + 0.0474455739499267 + ] + ] + }, + "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" : 8692433.674385035, + "scoreError" : 67675.5941264889, + "scoreConfidence" : [ + 8624758.080258546, + 8760109.268511524 + ], + "scorePercentiles" : { + "0.0" : 8656142.101211073, + "50.0" : 8697235.26347826, + "90.0" : 8717519.744773518, + "95.0" : 8717519.744773518, + "99.0" : 8717519.744773518, + "99.9" : 8717519.744773518, + "99.99" : 8717519.744773518, + "99.999" : 8717519.744773518, + "99.9999" : 8717519.744773518, + "100.0" : 8717519.744773518 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 8714644.011324042, + 8717519.744773518, + 8696311.950434783 + ], + [ + 8698158.57652174, + 8656142.101211073, + 8671825.662045062 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + + From e04fe4173425ac67197ce7b1ce7fbf80375cd594 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 27 Jul 2025 23:52:52 +0000 Subject: [PATCH 14/14] Add performance results for commit 72fb3d09a570c0bd653b66257fcfac5a8cb603c2 --- ...570c0bd653b66257fcfac5a8cb603c2-jdk17.json | 1279 +++++++++++++++++ 1 file changed, 1279 insertions(+) create mode 100644 performance-results/2025-07-27T23:52:34Z-72fb3d09a570c0bd653b66257fcfac5a8cb603c2-jdk17.json diff --git a/performance-results/2025-07-27T23:52:34Z-72fb3d09a570c0bd653b66257fcfac5a8cb603c2-jdk17.json b/performance-results/2025-07-27T23:52:34Z-72fb3d09a570c0bd653b66257fcfac5a8cb603c2-jdk17.json new file mode 100644 index 0000000000..08183a5cd3 --- /dev/null +++ b/performance-results/2025-07-27T23:52:34Z-72fb3d09a570c0bd653b66257fcfac5a8cb603c2-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.3381787744528983, + "scoreError" : 0.052908944469568946, + "scoreConfidence" : [ + 3.2852698299833296, + 3.391087718922467 + ], + "scorePercentiles" : { + "0.0" : 3.3273248563057742, + "50.0" : 3.339745418065334, + "90.0" : 3.345899405375152, + "95.0" : 3.345899405375152, + "99.0" : 3.345899405375152, + "99.9" : 3.345899405375152, + "99.99" : 3.345899405375152, + "99.999" : 3.345899405375152, + "99.9999" : 3.345899405375152, + "100.0" : 3.345899405375152 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 3.3366801497940215, + 3.345899405375152 + ], + [ + 3.3273248563057742, + 3.342810686336647 + ] + ] + }, + "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.684586894404262, + "scoreError" : 0.053426960880809275, + "scoreConfidence" : [ + 1.6311599335234526, + 1.7380138552850712 + ], + "scorePercentiles" : { + "0.0" : 1.6756625743866254, + "50.0" : 1.6843055253887116, + "90.0" : 1.6940739524529989, + "95.0" : 1.6940739524529989, + "99.0" : 1.6940739524529989, + "99.9" : 1.6940739524529989, + "99.99" : 1.6940739524529989, + "99.999" : 1.6940739524529989, + "99.9999" : 1.6940739524529989, + "100.0" : 1.6940739524529989 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 1.6885047806877211, + 1.6940739524529989 + ], + [ + 1.6756625743866254, + 1.680106270089702 + ] + ] + }, + "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.8487724778959634, + "scoreError" : 0.010759981800526824, + "scoreConfidence" : [ + 0.8380124960954366, + 0.8595324596964903 + ], + "scorePercentiles" : { + "0.0" : 0.8468391144089067, + "50.0" : 0.8486759279560974, + "90.0" : 0.8508989412627525, + "95.0" : 0.8508989412627525, + "99.0" : 0.8508989412627525, + "99.9" : 0.8508989412627525, + "99.99" : 0.8508989412627525, + "99.999" : 0.8508989412627525, + "99.9999" : 0.8508989412627525, + "100.0" : 0.8508989412627525 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 0.8468391144089067, + 0.8488164274018315 + ], + [ + 0.8485354285103631, + 0.8508989412627525 + ] + ] + }, + "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.30642368772897, + "scoreError" : 0.0764152475644141, + "scoreConfidence" : [ + 16.230008440164557, + 16.382838935293382 + ], + "scorePercentiles" : { + "0.0" : 16.26766054704475, + "50.0" : 16.313080658309325, + "90.0" : 16.33602976449483, + "95.0" : 16.33602976449483, + "99.0" : 16.33602976449483, + "99.9" : 16.33602976449483, + "99.99" : 16.33602976449483, + "99.999" : 16.33602976449483, + "99.9999" : 16.33602976449483, + "100.0" : 16.33602976449483 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 16.323152150890056, + 16.30300916572859, + 16.33602976449483 + ], + [ + 16.32707940886456, + 16.26766054704475, + 16.281611089351014 + ] + ] + }, + "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" : 2667.4873988008935, + "scoreError" : 217.89883159883343, + "scoreConfidence" : [ + 2449.58856720206, + 2885.386230399727 + ], + "scorePercentiles" : { + "0.0" : 2594.679516462749, + "50.0" : 2667.548815857057, + "90.0" : 2741.5360445700167, + "95.0" : 2741.5360445700167, + "99.0" : 2741.5360445700167, + "99.9" : 2741.5360445700167, + "99.99" : 2741.5360445700167, + "99.999" : 2741.5360445700167, + "99.9999" : 2741.5360445700167, + "100.0" : 2741.5360445700167 + }, + "scoreUnit" : "ops/ms", + "rawData" : [ + [ + 2594.679516462749, + 2595.014748203577, + 2600.1054418880676 + ], + [ + 2741.5360445700167, + 2734.992189826047, + 2738.5964518549044 + ] + ] + }, + "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" : 75876.55191802412, + "scoreError" : 1318.6896735964767, + "scoreConfidence" : [ + 74557.86224442764, + 77195.24159162061 + ], + "scorePercentiles" : { + "0.0" : 75433.44483697362, + "50.0" : 75868.92013544834, + "90.0" : 76341.06389809935, + "95.0" : 76341.06389809935, + "99.0" : 76341.06389809935, + "99.9" : 76341.06389809935, + "99.99" : 76341.06389809935, + "99.999" : 76341.06389809935, + "99.9999" : 76341.06389809935, + "100.0" : 76341.06389809935 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 75442.0607811654, + 75468.16307212332, + 75433.44483697362 + ], + [ + 76269.67719877334, + 76304.90172100966, + 76341.06389809935 + ] + ] + }, + "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" : 361.23399785959253, + "scoreError" : 12.615174785571135, + "scoreConfidence" : [ + 348.6188230740214, + 373.84917264516366 + ], + "scorePercentiles" : { + "0.0" : 356.41651299599584, + "50.0" : 361.15588964219916, + "90.0" : 366.1894802917049, + "95.0" : 366.1894802917049, + "99.0" : 366.1894802917049, + "99.9" : 366.1894802917049, + "99.99" : 366.1894802917049, + "99.999" : 366.1894802917049, + "99.9999" : 366.1894802917049, + "100.0" : 366.1894802917049 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 364.99490730833463, + 366.1894802917049, + 364.70989061673146 + ], + [ + 357.60188866766686, + 357.4913072771214, + 356.41651299599584 + ] + ] + }, + "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" : 115.52427543965842, + "scoreError" : 5.10604691303488, + "scoreConfidence" : [ + 110.41822852662355, + 120.6303223526933 + ], + "scorePercentiles" : { + "0.0" : 113.53031875737602, + "50.0" : 115.54220750898128, + "90.0" : 117.35603432208174, + "95.0" : 117.35603432208174, + "99.0" : 117.35603432208174, + "99.9" : 117.35603432208174, + "99.99" : 117.35603432208174, + "99.999" : 117.35603432208174, + "99.9999" : 117.35603432208174, + "100.0" : 117.35603432208174 + }, + "scoreUnit" : "ops/s", + "rawData" : [ + [ + 117.35603432208174, + 116.92626534996757, + 117.23162852130869 + ], + [ + 114.15814966799498, + 113.9432560192216, + 113.53031875737602 + ] + ] + }, + "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.061462049003638615, + "scoreError" : 9.829962077341746E-4, + "scoreConfidence" : [ + 0.06047905279590444, + 0.06244504521137279 + ], + "scorePercentiles" : { + "0.0" : 0.061129893672557445, + "50.0" : 0.06139802352929069, + "90.0" : 0.06188336952418671, + "95.0" : 0.06188336952418671, + "99.0" : 0.06188336952418671, + "99.9" : 0.06188336952418671, + "99.99" : 0.06188336952418671, + "99.999" : 0.06188336952418671, + "99.9999" : 0.06188336952418671, + "100.0" : 0.06188336952418671 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.06118066556135403, + 0.061147478030108476, + 0.061129893672557445 + ], + [ + 0.06181550573639769, + 0.06161538149722735, + 0.06188336952418671 + ] + ] + }, + "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.6742406229967224E-4, + "scoreError" : 3.252810535800362E-5, + "scoreConfidence" : [ + 3.3489595694166863E-4, + 3.9995216765767585E-4 + ], + "scorePercentiles" : { + "0.0" : 3.5652459844805456E-4, + "50.0" : 3.6744417209059305E-4, + "90.0" : 3.7819231221456487E-4, + "95.0" : 3.7819231221456487E-4, + "99.0" : 3.7819231221456487E-4, + "99.9" : 3.7819231221456487E-4, + "99.99" : 3.7819231221456487E-4, + "99.999" : 3.7819231221456487E-4, + "99.9999" : 3.7819231221456487E-4, + "100.0" : 3.7819231221456487E-4 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.5702991159574125E-4, + 3.5652459844805456E-4, + 3.5695507345340216E-4 + ], + [ + 3.7798404550082554E-4, + 3.7785843258544485E-4, + 3.7819231221456487E-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.1244396962610237, + "scoreError" : 0.003998894076406452, + "scoreConfidence" : [ + 0.12044080218461725, + 0.12843859033743016 + ], + "scorePercentiles" : { + "0.0" : 0.1231189042893726, + "50.0" : 0.12431504513525693, + "90.0" : 0.12608096121841747, + "95.0" : 0.12608096121841747, + "99.0" : 0.12608096121841747, + "99.9" : 0.12608096121841747, + "99.99" : 0.12608096121841747, + "99.999" : 0.12608096121841747, + "99.9999" : 0.12608096121841747, + "100.0" : 0.12608096121841747 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.1231727407284238, + 0.12316184676585054, + 0.1231189042893726 + ], + [ + 0.12608096121841747, + 0.1256463750219877, + 0.12545734954209006 + ] + ] + }, + "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.013228661642077283, + "scoreError" : 2.1192761188391186E-4, + "scoreConfidence" : [ + 0.01301673403019337, + 0.013440589253961195 + ], + "scorePercentiles" : { + "0.0" : 0.013141296478179167, + "50.0" : 0.013232700958132924, + "90.0" : 0.01329895060170304, + "95.0" : 0.01329895060170304, + "99.0" : 0.01329895060170304, + "99.9" : 0.01329895060170304, + "99.99" : 0.01329895060170304, + "99.999" : 0.01329895060170304, + "99.9999" : 0.01329895060170304, + "100.0" : 0.01329895060170304 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.01329895060170304, + 0.013298824676145045, + 0.013293067834753897 + ], + [ + 0.013167496180170596, + 0.013172334081511953, + 0.013141296478179167 + ] + ] + }, + "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.0042422484438465, + "scoreError" : 0.060493074322720886, + "scoreConfidence" : [ + 0.9437491741211256, + 1.0647353227665675 + ], + "scorePercentiles" : { + "0.0" : 0.983829284800787, + "50.0" : 1.0044252953689092, + "90.0" : 1.024237226136829, + "95.0" : 1.024237226136829, + "99.0" : 1.024237226136829, + "99.9" : 1.024237226136829, + "99.99" : 1.024237226136829, + "99.999" : 1.024237226136829, + "99.9999" : 1.024237226136829, + "100.0" : 1.024237226136829 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.983829284800787, + 0.9846654595313116, + 0.9851671281520883 + ], + [ + 1.0236834625857303, + 1.024237226136829, + 1.0238709294563326 + ] + ] + }, + "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.01097491510325437, + "scoreError" : 2.1227888608834453E-4, + "scoreConfidence" : [ + 0.010762636217166026, + 0.011187193989342715 + ], + "scorePercentiles" : { + "0.0" : 0.010899842078760068, + "50.0" : 0.010974946828584149, + "90.0" : 0.011050464476961463, + "95.0" : 0.011050464476961463, + "99.0" : 0.011050464476961463, + "99.9" : 0.011050464476961463, + "99.99" : 0.011050464476961463, + "99.999" : 0.011050464476961463, + "99.9999" : 0.011050464476961463, + "100.0" : 0.011050464476961463 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.011038484160168841, + 0.011042598043740876, + 0.011050464476961463 + ], + [ + 0.010906692362895522, + 0.010911409496999454, + 0.010899842078760068 + ] + ] + }, + "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.2075394143939917, + "scoreError" : 0.08543657729638544, + "scoreConfidence" : [ + 3.1221028370976063, + 3.292975991690377 + ], + "scorePercentiles" : { + "0.0" : 3.1772210565438375, + "50.0" : 3.207404272871176, + "90.0" : 3.238036270550162, + "95.0" : 3.238036270550162, + "99.0" : 3.238036270550162, + "99.9" : 3.238036270550162, + "99.99" : 3.238036270550162, + "99.999" : 3.238036270550162, + "99.9999" : 3.238036270550162, + "100.0" : 3.238036270550162 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 3.2351129288486415, + 3.238036270550162, + 3.232667912790698 + ], + [ + 3.1772210565438375, + 3.1821406329516537, + 3.180057684678957 + ] + ] + }, + "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.8013710442343194, + "scoreError" : 0.09908869720702473, + "scoreConfidence" : [ + 2.7022823470272948, + 2.900459741441344 + ], + "scorePercentiles" : { + "0.0" : 2.7667862246196404, + "50.0" : 2.7997444810839576, + "90.0" : 2.838148126276958, + "95.0" : 2.838148126276958, + "99.0" : 2.838148126276958, + "99.9" : 2.838148126276958, + "99.99" : 2.838148126276958, + "99.999" : 2.838148126276958, + "99.9999" : 2.838148126276958, + "100.0" : 2.838148126276958 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 2.838148126276958, + 2.8275970070681367, + 2.8345902721088434 + ], + [ + 2.7718919550997785, + 2.7692126802325583, + 2.7667862246196404 + ] + ] + }, + "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.18831522247602908, + "scoreError" : 0.01320230585813595, + "scoreConfidence" : [ + 0.17511291661789313, + 0.20151752833416503 + ], + "scorePercentiles" : { + "0.0" : 0.18232057179580674, + "50.0" : 0.18956005307675755, + "90.0" : 0.1925366986657425, + "95.0" : 0.1925366986657425, + "99.0" : 0.1925366986657425, + "99.9" : 0.1925366986657425, + "99.99" : 0.1925366986657425, + "99.999" : 0.1925366986657425, + "99.9999" : 0.1925366986657425, + "100.0" : 0.1925366986657425 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.18683431329870712, + 0.1835491625461153, + 0.18232057179580674 + ], + [ + 0.19236479569499482, + 0.1925366986657425, + 0.192285792854808 + ] + ] + }, + "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.33122974542499567, + "scoreError" : 0.00936213599925976, + "scoreConfidence" : [ + 0.3218676094257359, + 0.34059188142425545 + ], + "scorePercentiles" : { + "0.0" : 0.32807261216455613, + "50.0" : 0.33130213506674144, + "90.0" : 0.33431934437683875, + "95.0" : 0.33431934437683875, + "99.0" : 0.33431934437683875, + "99.9" : 0.33431934437683875, + "99.99" : 0.33431934437683875, + "99.999" : 0.33431934437683875, + "99.9999" : 0.33431934437683875, + "100.0" : 0.33431934437683875 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.33428951552732744, + 0.334218085291267, + 0.33431934437683875 + ], + [ + 0.3283861848422159, + 0.32809273034776903, + 0.32807261216455613 + ] + ] + }, + "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.14199090320111704, + "scoreError" : 6.406888073906941E-4, + "scoreConfidence" : [ + 0.14135021439372636, + 0.14263159200850772 + ], + "scorePercentiles" : { + "0.0" : 0.1415685460015006, + "50.0" : 0.1420378276953001, + "90.0" : 0.14224588614833147, + "95.0" : 0.14224588614833147, + "99.0" : 0.14224588614833147, + "99.9" : 0.14224588614833147, + "99.99" : 0.14224588614833147, + "99.999" : 0.14224588614833147, + "99.9999" : 0.14224588614833147, + "100.0" : 0.14224588614833147 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.14202898292856128, + 0.1415685460015006, + 0.1420466724620389 + ], + [ + 0.14209957129662523, + 0.14195576036964483, + 0.14224588614833147 + ] + ] + }, + "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.41481445061366445, + "scoreError" : 0.025023534227998082, + "scoreConfidence" : [ + 0.3897909163856664, + 0.43983798484166253 + ], + "scorePercentiles" : { + "0.0" : 0.40636495729204763, + "50.0" : 0.414385713218664, + "90.0" : 0.4236801572191154, + "95.0" : 0.4236801572191154, + "99.0" : 0.4236801572191154, + "99.9" : 0.4236801572191154, + "99.99" : 0.4236801572191154, + "99.999" : 0.4236801572191154, + "99.9999" : 0.4236801572191154, + "100.0" : 0.4236801572191154 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.4072214660613217, + 0.40651910788617884, + 0.40636495729204763 + ], + [ + 0.4236801572191154, + 0.4235510548473169, + 0.4215499603760064 + ] + ] + }, + "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.15830778150074207, + "scoreError" : 0.005984104324630183, + "scoreConfidence" : [ + 0.1523236771761119, + 0.16429188582537224 + ], + "scorePercentiles" : { + "0.0" : 0.15638672403277765, + "50.0" : 0.15795887540542858, + "90.0" : 0.16156183815047578, + "95.0" : 0.16156183815047578, + "99.0" : 0.16156183815047578, + "99.9" : 0.16156183815047578, + "99.99" : 0.16156183815047578, + "99.999" : 0.16156183815047578, + "99.9999" : 0.16156183815047578, + "100.0" : 0.16156183815047578 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.15638672403277765, + 0.15658995474617143, + 0.15652439225844825 + ], + [ + 0.16156183815047578, + 0.1594559837518935, + 0.15932779606468572 + ] + ] + }, + "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.048243928350234104, + "scoreError" : 0.004235270320438999, + "scoreConfidence" : [ + 0.0440086580297951, + 0.052479198670673105 + ], + "scorePercentiles" : { + "0.0" : 0.04681095559570843, + "50.0" : 0.048234986205287045, + "90.0" : 0.04988847041157396, + "95.0" : 0.04988847041157396, + "99.0" : 0.04988847041157396, + "99.9" : 0.04988847041157396, + "99.99" : 0.04988847041157396, + "99.999" : 0.04988847041157396, + "99.9999" : 0.04988847041157396, + "100.0" : 0.04988847041157396 + }, + "scoreUnit" : "ms/op", + "rawData" : [ + [ + 0.046993042800148495, + 0.04681593707105606, + 0.04681095559570843 + ], + [ + 0.04988847041157396, + 0.04947823461249208, + 0.049476929610425595 + ] + ] + }, + "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" : 9133420.639616901, + "scoreError" : 412419.678574724, + "scoreConfidence" : [ + 8721000.961042177, + 9545840.318191625 + ], + "scorePercentiles" : { + "0.0" : 8939655.63538874, + "50.0" : 9201217.744126346, + "90.0" : 9254384.480111009, + "95.0" : 9254384.480111009, + "99.0" : 9254384.480111009, + "99.9" : 9254384.480111009, + "99.99" : 9254384.480111009, + "99.999" : 9254384.480111009, + "99.9999" : 9254384.480111009, + "100.0" : 9254384.480111009 + }, + "scoreUnit" : "ns/op", + "rawData" : [ + [ + 9254384.480111009, + 9251219.370027753, + 9213303.569060773 + ], + [ + 8952828.863921218, + 8939655.63538874, + 9189131.91919192 + ] + ] + }, + "secondaryMetrics" : { + } + } +] + +