feat(Bench): Make PoC with dragon-code/benchmark (#92)

Author: roxblnfk

composer.json

@@ -23,6 +23,7 @@
     ],
     "require": {
         "php": ">=8.1",
+        "dragon-code/benchmark": "^2.6 || ^3.0",
         "internal/destroy": "^1.0",
         "internal/path": "^1.2",
         "psr/container": "1 - 2",

src/Bench/BenchOptions.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Bench;
+
+/**
+ * Benchmarks options.
+ *
+ * @api
+ */
+final class BenchOptions
+{
+    public function __construct(
+        /**
+         * @var int<1, max> Number of iterations to run for each benchmark.
+         */
+        public readonly int $iterations = 1000,
+
+        /**
+         * @var int<1, max> Number of revolutions to run for each benchmark.
+         *      A revolution is a single execution of the benchmarked function.
+         */
+        public readonly int $revolutions = 5,
+    ) {
+        $iterations > 0 or throw new \InvalidArgumentException('Iterations must be greater than 0.');
+        $revolutions > 0 or throw new \InvalidArgumentException('Revolutions must be greater than 0.');
+    }
+}

src/Bench/BenchWith.php

@@ -17,12 +17,13 @@
 #[FallbackInterceptor(BenchWithInterceptor::class)]
 final class BenchWith implements Interceptable
 {
-    /**
-     * @param array<callable|array{class-string, non-empty-string}> $callables Functions to benchmark with.
-     *        It might be a callable or an array with class name and non-public method name.
-     */
     public function __construct(
+        /**
+         * @var array<callable|array{class-string, non-empty-string}> $callables Functions to benchmark with.
+         *      It might be a callable or an array with class name and non-public method name.
+         */
         public readonly array $callables,
         public readonly array $arguments = [],
+        public readonly BenchOptions $options = new BenchOptions(),
     ) {}
 }

src/Bench/Internal/BenchInvoker.php

@@ -4,23 +4,46 @@
 
 namespace Testo\Bench\Internal;
 
+use DragonCode\Benchmark\Benchmark;
 use Testo\Bench\BenchWith;
 use Testo\Bench\Exception\BenchWithAttributeMissingException;
 use Testo\Core\Context\TestInfo;
 
 final class BenchInvoker
 {
+    private static function normalizeCallable(TestInfo $info, callable|array $callable): \Closure
+    {
+        $fn = $callable(...);
+        return static fn (): mixed => $fn(...$info->arguments);
+    }
+
     public function __invoke(TestInfo $info): mixed
     {
         $attr = $info->getAttribute(BenchWith::class);
         $attr instanceof BenchWith or throw BenchWithAttributeMissingException::fromTestInfo($info);
 
-        # TODO: bench
-        # Execute the method
-        $result = $info->caseInfo->instance === null || $info->testDefinition->reflection->isStatic()
-            ? $info->testDefinition->reflection->invoke(null, ...$info->arguments)
-            : $info->testDefinition->reflection->invoke($info->caseInfo->instance->getInstance(), ...$info->arguments);
+        // Current function callable
+        $fn = $info->caseInfo->instance === null || $info->testDefinition->reflection->isStatic()
+            ? $info->testDefinition->reflection->getClosure(null)
+            : $info->testDefinition->reflection->getClosure($info->caseInfo->instance->getInstance());
+
+
+        $functions = [static fn (): mixed => $fn(...$info->arguments)];
+
+        # Collect callables
+        foreach ($attr->callables as $callable) {
+            $f = self::normalizeCallable($info, $callable);
+            $functions[] = $f;
+        }
+
+
+        Benchmark::start()
+            ->withoutData()
+            ->iterations($attr->options->iterations)
+            ->compare(
+                ...$functions,
+            );
 
-        return $result;
+        return null;
     }
 }

src/Bench/Middleware/BenchFinder.php

@@ -38,7 +38,6 @@ public function locateFile(TokenizedFile $file, callable $next): ?bool
     #[\Override]
     public function locateTestCases(FileDefinitions $file, callable $next): CaseDefinitions
     {
-        echo 123;
         // Define cases for classes
         foreach ($file->classes as $class) {
             if ($class->isAbstract()) {

src/Pipeline/InterceptorProvider.php

@@ -10,6 +10,7 @@
 use Testo\Application\Middleware\Locator\TestoAttributesLocatorInterceptor;
 use Testo\Assert\Interceptor\AssertCollectorInterceptor;
 use Testo\Assert\Interceptor\ExpectationsInterceptor;
+use Testo\Bench\Middleware\BenchFinder;
 use Testo\Common\Container;
 use Testo\Common\Reflection;
 use Testo\Inline\Middleware\TestInlineFinder;
@@ -56,6 +57,7 @@ public function fromConfig(string $class): array
         return $this->fromClasses($class, ...[
             FilterInterceptor::class,
             TestInlineFinder::class,
+            BenchFinder::class,
             new FilePostfixTestLocatorInterceptor(),
             new TestoAttributesLocatorInterceptor(),
             new AssertCollectorInterceptor(),

tests/Bench/Self/BenchWithAttr.php

@@ -4,13 +4,21 @@
 
 namespace Tests\Bench\Self;
 
+use Testo\Bench\BenchOptions;
 use Testo\Bench\BenchWith;
 
 final class BenchWithAttr
 {
-    #[BenchWith([
-        [self::class, 'sumSlow'],
-    ], arguments: [1, 2])]
+    #[BenchWith(
+        [
+            [self::class, 'sumFast'],
+            [self::class, 'sumSlow'],
+        ],
+        arguments: [1, 2],
+        options: new BenchOptions(
+            iterations: 10_000,
+        )
+    )]
     public static function sumFast(int $a, int $b): int
     {
         return $a + $b;