From 2eba17de15ec09f364f9772bb7c55a380202057e Mon Sep 17 00:00:00 2001
From: Lee Byron <lee@leebyron.com>
Date: Thu, 7 Dec 2017 17:49:15 -0800
Subject: [PATCH 1/2] Perf: memoize collectSubfields

Collecting subfields occurs after resolving a field's value and before resolving subfield values. This step collects fragment spreads and checks inline fragment conditions. When fetching a list of things, this step is computed with the same inputs and expecting the same outputs for each item in the list. Memoizing ensures the work is done at most once per type returned from a list.

I tested this against the introspection query (which is both synchronous and complex) against a large schema and saw a ~15%-25% reduction in runtime. In practice I don't expect most queries to see this level of speedup as most queries are limited by backend communication and not execution overhead.
---
 src/execution/execute.js | 32 ++++++++++++++++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/src/execution/execute.js b/src/execution/execute.js
index f47334c6f0..7d94795fb4 100644
--- a/src/execution/execute.js
+++ b/src/execution/execute.js
@@ -1236,6 +1236,34 @@ function collectAndExecuteSubfields(
   result: mixed,
 ): mixed {
   // Collect sub-fields to execute to complete this value.
+  const subFieldNodes = collectSubfields(exeContext, returnType, fieldNodes);
+  return executeFields(exeContext, returnType, result, path, subFieldNodes);
+}
+
+/**
+ * A memoized collection of relevant subfields in the context of the return
+ * type. Memoizing ensures the subfields are not repeatedly calculated, which
+ * saves overhead when resolving lists of values.
+ */
+const subfieldCache: WeakMap<
+  $ReadOnlyArray<FieldNode>,
+  WeakMap<GraphQLObjectType, ObjMap<Array<FieldNode>>>,
+> = new WeakMap();
+function collectSubfields(
+  exeContext: ExecutionContext,
+  returnType: GraphQLObjectType,
+  fieldNodes: $ReadOnlyArray<FieldNode>,
+): ObjMap<Array<FieldNode>> {
+  let cacheByReturnType = subfieldCache.get(fieldNodes);
+  if (cacheByReturnType) {
+    const cachedSubFieldNodes = cacheByReturnType.get(returnType);
+    if (cachedSubFieldNodes) {
+      return cachedSubFieldNodes;
+    }
+  } else {
+    cacheByReturnType = new WeakMap();
+    subfieldCache.set(fieldNodes, cacheByReturnType);
+  }
   let subFieldNodes = Object.create(null);
   const visitedFragmentNames = Object.create(null);
   for (let i = 0; i < fieldNodes.length; i++) {
@@ -1250,8 +1278,8 @@ function collectAndExecuteSubfields(
       );
     }
   }
-
-  return executeFields(exeContext, returnType, result, path, subFieldNodes);
+  cacheByReturnType.set(returnType, subFieldNodes);
+  return subFieldNodes;
 }
 
 /**

From 894583c0c2238c8c1d9ce064e2cabf542dd951b8 Mon Sep 17 00:00:00 2001
From: Lee Byron <lee@leebyron.com>
Date: Tue, 9 Jan 2018 17:53:26 -0800
Subject: [PATCH 2/2] Include context in memoization, Factor out memoize3

---
 src/execution/execute.js | 19 +++--------------
 src/jsutils/memoize3.js  | 44 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 16 deletions(-)
 create mode 100644 src/jsutils/memoize3.js

diff --git a/src/execution/execute.js b/src/execution/execute.js
index 7d94795fb4..6a640f3a35 100644
--- a/src/execution/execute.js
+++ b/src/execution/execute.js
@@ -12,6 +12,7 @@ import { GraphQLError, locatedError } from '../error';
 import invariant from '../jsutils/invariant';
 import isInvalid from '../jsutils/isInvalid';
 import isNullish from '../jsutils/isNullish';
+import memoize3 from '../jsutils/memoize3';
 import type { ObjMap } from '../jsutils/ObjMap';
 import type { MaybePromise } from '../jsutils/MaybePromise';
 
@@ -1245,25 +1246,12 @@ function collectAndExecuteSubfields(
  * type. Memoizing ensures the subfields are not repeatedly calculated, which
  * saves overhead when resolving lists of values.
  */
-const subfieldCache: WeakMap<
-  $ReadOnlyArray<FieldNode>,
-  WeakMap<GraphQLObjectType, ObjMap<Array<FieldNode>>>,
-> = new WeakMap();
-function collectSubfields(
+const collectSubfields = memoize3(_collectSubfields);
+function _collectSubfields(
   exeContext: ExecutionContext,
   returnType: GraphQLObjectType,
   fieldNodes: $ReadOnlyArray<FieldNode>,
 ): ObjMap<Array<FieldNode>> {
-  let cacheByReturnType = subfieldCache.get(fieldNodes);
-  if (cacheByReturnType) {
-    const cachedSubFieldNodes = cacheByReturnType.get(returnType);
-    if (cachedSubFieldNodes) {
-      return cachedSubFieldNodes;
-    }
-  } else {
-    cacheByReturnType = new WeakMap();
-    subfieldCache.set(fieldNodes, cacheByReturnType);
-  }
   let subFieldNodes = Object.create(null);
   const visitedFragmentNames = Object.create(null);
   for (let i = 0; i < fieldNodes.length; i++) {
@@ -1278,7 +1266,6 @@ function collectSubfields(
       );
     }
   }
-  cacheByReturnType.set(returnType, subFieldNodes);
   return subFieldNodes;
 }
 
diff --git a/src/jsutils/memoize3.js b/src/jsutils/memoize3.js
new file mode 100644
index 0000000000..95b27c7b2b
--- /dev/null
+++ b/src/jsutils/memoize3.js
@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+/**
+ * Memoizes the provided three-argument function.
+ */
+export default function memoize3<T: (a1: any, a2: any, a3: any) => any>(
+  fn: T,
+): T {
+  let cache0;
+  function memoized(a1, a2, a3) {
+    if (!cache0) {
+      cache0 = new WeakMap();
+    }
+    let cache1 = cache0.get(a1);
+    let cache2;
+    if (cache1) {
+      cache2 = cache1.get(a2);
+      if (cache2) {
+        const cachedValue = cache2.get(a3);
+        if (cachedValue) {
+          return cachedValue;
+        }
+      }
+    } else {
+      cache1 = new WeakMap();
+      cache0.set(a1, cache1);
+    }
+    if (!cache2) {
+      cache2 = new WeakMap();
+      cache1.set(a2, cache2);
+    }
+    const newValue = fn.apply(this, arguments);
+    cache2.set(a3, newValue);
+    return newValue;
+  }
+  return (memoized: any);
+}