graphql-java · andimarek · Sep 25, 2025 · Sep 25, 2025
diff --git a/src/jmh/java/benchmark/IntMapBenchmark.java b/src/jmh/java/benchmark/IntMapBenchmark.java
diff --git a/src/jmh/java/performance/DataLoaderPerformance.java b/src/jmh/java/performance/DataLoaderPerformance.java
@@ -4,6 +4,7 @@
 import graphql.ExecutionInput;
 import graphql.ExecutionResult;
 import graphql.GraphQL;
+import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys;
 import graphql.schema.DataFetcher;
 import graphql.schema.GraphQLSchema;
 import graphql.schema.idl.RuntimeWiring;
@@ -14,16 +15,28 @@
 import org.dataloader.DataLoader;
 import org.dataloader.DataLoaderFactory;
 import org.dataloader.DataLoaderRegistry;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
 import org.openjdk.jmh.annotations.Scope;
 import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
 import org.openjdk.jmh.infra.Blackhole;
 
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
+@State(Scope.Benchmark)
+@Warmup(iterations = 2, time = 5)
+@Measurement(iterations = 3)
+@Fork(2)
 public class DataLoaderPerformance {
 
     static Owner o1 = new Owner("O-1", "Andi", List.of("P-1", "P-2", "P-3"));
@@ -560,6 +573,9 @@ public void setup() {
 
     }
 
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
     public void executeRequestWithDataLoaders(MyState myState, Blackhole blackhole) {
         DataLoader ownerDL = DataLoaderFactory.newDataLoader(ownerBatchLoader);
         DataLoader petDL = DataLoaderFactory.newDataLoader(petBatchLoader);
@@ -571,7 +587,7 @@ public void executeRequestWithDataLoaders(MyState myState, Blackhole blackhole)
                 .dataLoaderRegistry(registry)
 //                .profileExecution(true)
                 .build();
-//        executionInput.getGraphQLContext().put(DataLoaderDispatchingContextKeys.ENABLE_DATA_LOADER_CHAINING, true);
+        executionInput.getGraphQLContext().put(DataLoaderDispatchingContextKeys.ENABLE_DATA_LOADER_CHAINING, true);
         ExecutionResult execute = myState.graphQL.execute(executionInput);
 //        ProfilerResult profilerResult = executionInput.getGraphQLContext().get(ProfilerResult.PROFILER_CONTEXT_KEY);
 //        System.out.println("execute: " + execute);

diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/LevelMap.java b/src/main/java/graphql/execution/instrumentation/dataloader/LevelMap.java
diff --git a/...java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/...java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java
@@ -72,9 +72,16 @@ public StateForLevel(@Nullable DataLoaderInvocation dataLoaderInvocation,
                 StateForLevel currentState = currentStateRef.get();
 
 
-                boolean dispatchingStarted = currentState != null && currentState.dispatchingStarted;
-                boolean dispatchingFinished = currentState != null && currentState.dispatchingFinished;
-                boolean currentlyDelayedDispatching = currentState != null && currentState.currentlyDelayedDispatching;
+                boolean dispatchingStarted = false;
+                boolean dispatchingFinished = false;
+                boolean currentlyDelayedDispatching = false;
+
+                if (currentState != null) {
+                    dispatchingStarted = currentState.dispatchingStarted;
+                    dispatchingFinished = currentState.dispatchingFinished;
+                    currentlyDelayedDispatching = currentState.currentlyDelayedDispatching;
+
+                }
 
                 if (!chained) {
                     if (normalDispatchOrDelayed) {
@@ -107,10 +114,16 @@ public boolean newDataLoaderInvocation(DataLoaderInvocation dataLoaderInvocation
             while (true) {
                 StateForLevel currentState = currentStateRef.get();
 
+                boolean dispatchingStarted = false;
+                boolean dispatchingFinished = false;
+                boolean currentlyDelayedDispatching = false;
 
-                boolean dispatchingStarted = currentState != null && currentState.dispatchingStarted;
-                boolean dispatchingFinished = currentState != null && currentState.dispatchingFinished;
-                boolean currentlyDelayedDispatching = currentState != null && currentState.currentlyDelayedDispatching;
+                if (currentState != null) {
+                    dispatchingStarted = currentState.dispatchingStarted;
+                    dispatchingFinished = currentState.dispatchingFinished;
+                    currentlyDelayedDispatching = currentState.currentlyDelayedDispatching;
+
+                }
 
                 // we need to start a new delayed dispatching if
                 // the normal dispatching is finished and there is no currently delayed dispatching for this level
@@ -135,6 +148,35 @@ public void clear() {
 
     private static class CallStack {
 
+        /**
+         * We track three things per level:
+         * - the number of execute object calls
+         * - the number of object completion calls
+         * - if the level is already dispatched
+         * <p/>
+         * The number of execute object calls is the number of times the execution
+         * of a field with sub selection (meaning it is an object) started.
+         * <p/>
+         * For each execute object call there will be one matching object completion call,
+         * indicating that the all fields in the sub selection have been fetched AND completed.
+         * Completion implies the fetched value is "resolved" (CompletableFuture is completed if it was a CF)
+         * and it the engine has processed it and called any needed subsequent execute object calls (if the result
+         * was none null and of Object of [Object] (or [[Object]] etc).
+         * <p/>
+         * Together we know a that a level is ready for dispatch if:
+         * - the parent was dispatched
+         * - the #executeObject == #completionFinished in the grandparent level.
+         * <p/>
+         * The second condition implies that all execute object calls in the parent level happened
+         * which again implies that all fetch fields in the current level have happened.
+         * <p/>
+         * For the first level we track only if all expected fetched field calls have happened.
+         */
+
+        /**
+         * The whole algo is impleted lock free and relies purely on CAS methods to handle concurrency.
+         */
+
         static class StateForLevel {
             private final int happenedCompletionFinishedCount;
             private final int happenedExecuteObjectCalls;

diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/LevelMapTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/LevelMapTest.groovy