diff --git a/src/jmh/java/performance/PerLevelDispatchOverheadPerformance.java b/src/jmh/java/performance/PerLevelDispatchOverheadPerformance.java
new file mode 100644
index 0000000000..193680a180
--- /dev/null
+++ b/src/jmh/java/performance/PerLevelDispatchOverheadPerformance.java
@@ -0,0 +1,145 @@
+package performance;
+
+import graphql.Assert;
+import graphql.ExecutionInput;
+import graphql.ExecutionResult;
+import graphql.GraphQL;
+import graphql.schema.DataFetcher;
+import graphql.schema.GraphQLSchema;
+import graphql.schema.idl.RuntimeWiring;
+import graphql.schema.idl.SchemaGenerator;
+import graphql.schema.idl.SchemaParser;
+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.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+import org.openjdk.jmh.annotations.Warmup;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Isolates the total cost of {@code PerLevelDataLoaderDispatchStrategy} bookkeeping.
+ *
+ * The same wide query runs with identical data fetchers (none of them use a DataLoader) in two
+ * modes: {@code none} executes without a {@code DataLoaderRegistry}, so the engine uses the no-op
+ * dispatch strategy; {@code perLevel} passes a registry holding one unused loader, which switches
+ * the engine to {@code PerLevelDataLoaderDispatchStrategy}. The difference between the two scores
+ * is everything the strategy costs for this query shape.
+ */
+@State(Scope.Benchmark)
+@Warmup(iterations = 3, time = 3)
+@Measurement(iterations = 5, time = 3)
+@Fork(2)
+public class PerLevelDispatchOverheadPerformance {
+
+ private static final String SDL = ""
+ + "type Query { items(count: Int!): [Item!]! }\n"
+ + "type Item { id: ID! a: String b: String c: String d: String e: String child: Child }\n"
+ + "type Child { id: ID! x: String y: String grand: [Grand!]! }\n"
+ + "type Grand { v: String w: String }\n";
+
+ private static final int GRANDCHILDREN_PER_CHILD = 5;
+
+ @Param({"250"})
+ public int count;
+
+ @Param({"false", "true"})
+ public boolean async;
+
+ @Param({"none", "perLevel"})
+ public String strategy;
+
+ private GraphQL graphQL;
+ private String query;
+ private ExecutorService pool;
+
+ @Setup(Level.Trial)
+ public void setup() {
+ pool = Executors.newFixedThreadPool(4);
+
+ DataFetcher