Added first meaningful benchmarks to have some grounds for future performance optimizations

Author: vladar

benchmarks/HugeSchemaBench.php

@@ -0,0 +1,90 @@
+<?php
+namespace GraphQL\Benchmarks;
+
+use GraphQL\GraphQL;
+use GraphQL\Schema;
+use GraphQL\Benchmarks\Utils\QueryGenerator;
+use GraphQL\Benchmarks\Utils\SchemaGenerator;
+use GraphQL\Type\LazyResolution;
+
+/**
+ * @BeforeMethods({"setUp"})
+ * @OutputTimeUnit("milliseconds", precision=3)
+ * @Warmup(1)
+ * @Revs(5)
+ * @Iterations(1)
+ */
+class HugeSchemaBench
+{
+    /**
+     * @var SchemaGenerator
+     */
+    private $schemaBuilder;
+
+    /**
+     * @var array
+     */
+    private $descriptor;
+
+    private $schema;
+
+    private $lazySchema;
+
+    /**
+     * @var string
+     */
+    private $smallQuery;
+
+    public function setUp()
+    {
+        $this->schemaBuilder = new SchemaGenerator([
+            'totalTypes' => 600,
+            'fieldsPerType' => 8,
+            'listFieldsPerType' => 2,
+            'nestingLevel' => 10
+        ]);
+
+        $this->schema = $this->schemaBuilder->buildSchema();
+
+        $queryBuilder = new QueryGenerator($this->schema, 0.05);
+        $this->descriptor = $this->schema->getDescriptor();
+        $this->smallQuery = $queryBuilder->buildQuery();
+    }
+
+    public function benchSchema()
+    {
+        $this->schemaBuilder
+            ->buildSchema();
+    }
+
+    public function benchSchemaLazy()
+    {
+        $this->createLazySchema();
+    }
+
+    public function benchSmallQuery()
+    {
+        $result = GraphQL::execute($this->schema, $this->smallQuery);
+    }
+
+    public function benchSmallQueryLazy()
+    {
+        $schema = $this->createLazySchema();
+        $result = GraphQL::execute($schema, $this->smallQuery);
+    }
+
+    private function createLazySchema()
+    {
+        $strategy = new LazyResolution(
+            $this->descriptor,
+            function($name) {
+                return $this->schemaBuilder->loadType($name);
+            }
+        );
+
+        return new Schema([
+            'query' => $this->schemaBuilder->buildQueryType(),
+            'typeResolution' => $strategy,
+        ]);
+    }
+}

benchmarks/LexerBench.php

@@ -29,7 +29,7 @@ public function benchIntrospectionQuery()
         $lexer = new Lexer($this->introQuery);
 
         do {
-            $token = $lexer->nextToken();
+            $token = $lexer->advance();
         } while ($token->kind !== Token::EOF);
     }
 }

benchmarks/StarWarsBench.php

@@ -0,0 +1,97 @@
+<?php
+namespace GraphQL\Benchmarks;
+use GraphQL\GraphQL;
+use GraphQL\Tests\StarWarsSchema;
+use GraphQL\Type\Introspection;
+
+/**
+ * @BeforeMethods({"setIntroQuery"})
+ * @OutputTimeUnit("milliseconds", precision=3)
+ * @Warmup(2)
+ * @Revs(10)
+ * @Iterations(2)
+ */
+class StarWarsBench
+{
+    private $introQuery;
+
+    public function setIntroQuery()
+    {
+        $this->introQuery = Introspection::getIntrospectionQuery();
+    }
+
+    public function benchSchema()
+    {
+        StarWarsSchema::build();
+    }
+
+    public function benchHeroQuery()
+    {
+        $q = '
+        query HeroNameQuery {
+          hero {
+            name
+          }
+        }
+        ';
+
+        GraphQL::execute(
+            StarWarsSchema::build(),
+            $q
+        );
+    }
+
+    public function benchNestedQuery()
+    {
+        $q = '
+        query NestedQuery {
+          hero {
+            name
+            friends {
+              name
+              appearsIn
+              friends {
+                name
+              }
+            }
+          }
+        }
+        ';
+        GraphQL::execute(
+            StarWarsSchema::build(),
+            $q
+        );
+    }
+
+    public function benchQueryWithFragment()
+    {
+        $q = '
+        query UseFragment {
+          luke: human(id: "1000") {
+            ...HumanFragment
+          }
+          leia: human(id: "1003") {
+            ...HumanFragment
+          }
+        }
+
+        fragment HumanFragment on Human {
+          name
+          homePlanet
+        }
+        ';
+
+        GraphQL::execute(
+            StarWarsSchema::build(),
+            $q
+        );
+    }
+
+    public function benchStarWarsIntrospectionQuery()
+    {
+        GraphQL::execute(
+            StarWarsSchema::build(),
+            $this->introQuery
+        );
+    }
+}

benchmarks/Utils/QueryGenerator.php

@@ -0,0 +1,100 @@
+<?php
+namespace GraphQL\Benchmarks\Utils;
+
+use GraphQL\Language\AST\DocumentNode;
+use GraphQL\Language\AST\FieldNode;
+use GraphQL\Language\AST\NameNode;
+use GraphQL\Language\AST\OperationDefinitionNode;
+use GraphQL\Language\AST\SelectionSetNode;
+use GraphQL\Language\Printer;
+use GraphQL\Schema;
+use GraphQL\Type\Definition\FieldDefinition;
+use GraphQL\Type\Definition\InterfaceType;
+use GraphQL\Type\Definition\ObjectType;
+use GraphQL\Type\Definition\WrappingType;
+use GraphQL\Utils;
+
+class QueryGenerator
+{
+    private $schema;
+
+    private $maxLeafFields;
+
+    private $currentLeafFields;
+
+    public function __construct(Schema $schema, $percentOfLeafFields)
+    {
+        $this->schema = $schema;
+
+        Utils::invariant(0 < $percentOfLeafFields && $percentOfLeafFields <= 1);
+
+        $totalFields = 0;
+        foreach ($schema->getTypeMap() as $type) {
+            if ($type instanceof ObjectType) {
+                $totalFields += count($type->getFields());
+            }
+        }
+
+        $this->maxLeafFields = max(1, round($totalFields * $percentOfLeafFields));
+        $this->currentLeafFields = 0;
+    }
+
+    public function buildQuery()
+    {
+        $qtype = $this->schema->getQueryType();
+
+        $ast = new DocumentNode([
+            'definitions' => [
+                new OperationDefinitionNode([
+                    'name' => new NameNode(['value' => 'TestQuery']),
+                    'operation' => 'query',
+                    'selectionSet' => $this->buildSelectionSet($qtype->getFields())
+                ])
+            ]
+        ]);
+
+        return Printer::doPrint($ast);
+    }
+
+    /**
+     * @param FieldDefinition[] $fields
+     * @return SelectionSetNode
+     */
+    public function buildSelectionSet($fields)
+    {
+        $selections[] = new FieldNode([
+            'name' => new NameNode(['value' => '__typename'])
+        ]);
+        $this->currentLeafFields++;
+
+        foreach ($fields as $field) {
+            if ($this->currentLeafFields >= $this->maxLeafFields) {
+                break;
+            }
+
+            $type = $field->getType();
+
+            if ($type instanceof WrappingType) {
+                $type = $type->getWrappedType(true);
+            }
+
+            if ($type instanceof ObjectType || $type instanceof InterfaceType) {
+                $selectionSet = $this->buildSelectionSet($type->getFields());
+            } else {
+                $selectionSet = null;
+                $this->currentLeafFields++;
+            }
+
+            $selections[] = new FieldNode([
+                'name' => new NameNode(['value' => $field->name]),
+                'selectionSet' => $selectionSet
+            ]);
+        }
+
+        $selectionSet = new SelectionSetNode([
+            'selections' => $selections
+        ]);
+
+        return $selectionSet;
+    }
+}