gnhf #5: Bypassed Builder pattern in ExecutionStepInfoFactory.createExecutionStepInfo and added single-field fast path in executeObject's sync path to eliminate ~30M unnecessary object allocations per 10M-element list execution.

dondonz · dondonz · commit fdb5ca384de2 · 2026-04-03T22:28:49.000+11:00
diff --git a/src/main/java/graphql/execution/ExecutionStepInfo.java b/src/main/java/graphql/execution/ExecutionStepInfo.java
@@ -278,6 +278,20 @@ public static ExecutionStepInfo.Builder newExecutionStepInfo(ExecutionStepInfo e
         return new Builder(existing);
     }
 
+    /**
+     * Direct construction without Builder overhead - for internal hot path use only.
+     */
+    @Internal
+    static ExecutionStepInfo newExecutionStepInfoDirect(GraphQLOutputType type,
+                                                        ResultPath path,
+                                                        ExecutionStepInfo parent,
+                                                        MergedField field,
+                                                        GraphQLFieldDefinition fieldDefinition,
+                                                        GraphQLObjectType fieldContainer,
+                                                        Supplier<ImmutableMapWithNullValues<String, Object>> arguments) {
+        return new ExecutionStepInfo(type, path, parent, field, fieldDefinition, fieldContainer, arguments);
+    }
+
     public static class Builder {
         GraphQLOutputType type;
         ExecutionStepInfo parentInfo;
diff --git a/src/main/java/graphql/execution/ExecutionStepInfoFactory.java b/src/main/java/graphql/execution/ExecutionStepInfoFactory.java
@@ -18,8 +18,6 @@
 import java.util.Map;
 import java.util.function.Supplier;
 
-import static graphql.execution.ExecutionStepInfo.newExecutionStepInfo;
-
 @Internal
 @NullMarked
 public class ExecutionStepInfoFactory {
@@ -56,16 +54,15 @@ public ExecutionStepInfo createExecutionStepInfo(ExecutionContext executionConte
             argumentValues = getArgumentValues(executionContext, fieldArgDefs, field.getArguments());
         }
 
-
-        return newExecutionStepInfo()
-                .type(fieldType)
-                .fieldDefinition(fieldDefinition)
-                .fieldContainer(fieldContainer)
-                .field(field)
-                .path(parameters.getPath())
-                .parentInfo(parentStepInfo)
-                .arguments(argumentValues)
-                .build();
+        // Direct construction bypasses Builder allocation
+        return ExecutionStepInfo.newExecutionStepInfoDirect(
+                fieldType,
+                parameters.getPath(),
+                parentStepInfo,
+                field,
+                fieldDefinition,
+                fieldContainer,
+                argumentValues);
     }
 
     @NonNull
diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java
@@ -250,10 +250,23 @@ protected Object executeObject(ExecutionContext executionContext, ExecutionStrat
         } else {
             List<FieldValueInfo> completeValueInfos = (List<FieldValueInfo>) fieldValueInfosResult;
 
-            Async.CombinedBuilder<Object> resultFutures = fieldValuesCombinedBuilder(completeValueInfos);
             dataLoaderDispatcherStrategy.executeObjectOnFieldValuesInfo(completeValueInfos, parameters);
             resolveObjectCtx.onFieldValuesInfo(completeValueInfos);
 
+            // Fast path: single sync field value - avoid CombinedBuilder overhead
+            if (completeValueInfos.size() == 1) {
+                FieldValueInfo singleFvi = completeValueInfos.get(0);
+                Object fieldValue = singleFvi.getFieldValueObject();
+                if (!(fieldValue instanceof CompletableFuture)) {
+                    Map<String, Object> fieldValueMap = executionContext.getResponseMapFactory()
+                            .createInsertionOrdered(fieldsExecutedOnInitialResult, Collections.singletonList(fieldValue));
+                    resolveObjectCtx.onCompleted(fieldValueMap, null);
+                    return fieldValueMap;
+                }
+            }
+
+            Async.CombinedBuilder<Object> resultFutures = fieldValuesCombinedBuilder(completeValueInfos);
+
             Object completedValuesObject = resultFutures.awaitPolymorphic();
             if (completedValuesObject instanceof CompletableFuture) {
                 // Semi-async path - allocate CF infrastructure only when needed
