[OptionsResolver] Optimize splitOutsideParenthesis() - 2.91x faster #61239

bendavies · 2025-07-25T16:09:21Z

Q	A
Branch?	7.4
Bug fix?	no
New feature?	no
Deprecations?	no
Issues	Fix #59354
License	MIT

This PR optimises the splitOutsideParenthesis method in OptionsResolver.php, achieving a 2.91x performance improvement.

I discovered this method as a performance hotspot while benchmarking a large Symfony form with many fields. Profiling revealed that splitOutsideParenthesis was consuming a significant portion of the form processing time.

The splitOutsideParenthesis method (introduced in PR #59354) is called frequently during options resolution and has several performance bottlenecks:

Character-by-character string concatenation creates new string objects on each iteration (particularly inefficient in PHP due to copy-on-write behavior)
All input strings are processed the same way, regardless of complexity - no fast path for simple types
Multiple conditional checks per character

Test Methodology

Here's how all performance measurements were conducted:

Benchmark tool: hyperfine (10 runs with 1 warmup run)
Test iterations: 100,000 iterations per test case
Test data: 16 different type patterns:
- Simple types: string, int, bool, array
- Union types: string|int, string|int|bool, string|int|bool|array
- Parentheses types: string|(int|bool), (string|int)|bool
- Nested types: string|(int|(bool|float)), (string|int)|(bool|float)
- Array types: string[], int[]
- Class types: MyClass, \\Namespace\\Class
- Complex union: string|int|bool|array|object|resource|callable

Each optimisation was tested in isolation to measure its individual impact, then all optimisations were combined for the final benchmark.

Optimisations

1. Fast Path for Simple Types (No Pipes)

Most type declarations are simple types like string, int, MyClass, etc. without any union types.

Implementation:

if (!\str_contains($type, '|')) {
    return [$type];
}

2. Fast Path for Union Types (No Parentheses)

Common union types like string|int|bool don't need complex parsing - PHP's explode() is much faster.

Implementation:

if (!\str_contains($type, '(') && !\str_contains($type, ')')) {
    return \explode('|', $type);
}

3. Eliminate String Concatenation

String concatenation in loops creates memory overhead. Using substr() avoids creating intermediate strings.

Implementation:

// Instead of: $currentPart .= $char;
// Use: $parts[] = \substr($type, $start, $i - $start);

4. Switch Statement Optimisation

Eliminates Multiple conditional checks per character.

Implementation:

switch ($char) {
    case '(':
        ++$parenthesisLevel;
        break;
    case ')':
        --$parenthesisLevel;
        break;
    case '|':
        // ...
}

Benchmark Results

Individual Optimisation Impact

Testing each optimisation in isolation:

hyperfine --warmup 1 --runs 10 \
  --sort=command \
  --reference 'php test_original.php' \
  'php test_opt1_fast_path_simple.php' \
  'php test_opt2_fast_path_union.php' \
  'php test_opt3_no_string_concat.php'  \
  'php test_opt4_switch_statement.php'

Relative speed comparison
        1.00          php test_original.php
        1.23 ±  0.02  php test_opt1_fast_path_simple.php
        1.95 ±  0.04  php test_opt2_fast_path_union.php
        1.13 ±  0.03  php test_opt3_no_string_concat.php
        1.35 ±  0.03  php test_opt4_switch_statement.php

Combined Optimisation Impact

Combining all optimisations:

hyperfine --warmup 1 --runs 10 \
  --sort=command \
  --reference 'php test_original.php' \
  'php test_optimised.php'

Relative speed comparison
        1.00          php test_original.php
        2.91 ±  0.03  php test_optimised.php

alexandre-daubois

Performance improvements are refactors, which means this should target 7.4. 7.3 being already released, the branch receives bug fixes only.

Also, would you mind sharing the test set you used to run benchmarks? In addition to the methodology used as explained in the description, having the opportunity to see the benchmark code would be a plus!

src/Symfony/Component/OptionsResolver/OptionsResolver.php

yceruto · 2025-07-25T16:21:24Z

Hey @bendavies thanks for this optimization proposal! For performance refactoring PRs, we usually target the latest dev branch, in this case, 7.4

- Fast path for simple types (no pipes) - Fast path for unions without parentheses - Eliminate string concatenation overhead - Switch statement for character matching Reduces form processing time significantly for large forms.

bendavies · 2025-07-25T16:45:27Z

Performance improvements are refactors, which means this should target 7.4. 7.3 being already released, the branch receives bug fixes only.

Also, would you mind sharing the test set you used to run benchmarks? In addition to the methodology used as explained in the description, having the opportunity to see the benchmark code would be a plus!

# Test individual optimizations
hyperfine --warmup 1 --runs 10 \
  --reference 'php test_original.php' \
  'php test_opt1_fast_path_simple.php' \
  'php test_opt2_fast_path_union.php' \
  'php test_opt3_no_string_concat.php' \
  'php test_opt4_switch_statement.php'

# Test combined optimization
hyperfine --warmup 1 --runs 10 \
  --reference 'php test_original.php' \
  'php test_optimized.php'

test_original.php - Original implementation

<?php

function splitOutsideParenthesis(string $type): array
{
    $parts = [];
    $currentPart = '';
    $parenthesisLevel = 0;

    $typeLength = \strlen($type);
    for ($i = 0; $i < $typeLength; ++$i) {
        $char = $type[$i];

        if ('(' === $char) {
            ++$parenthesisLevel;
        } elseif (')' === $char) {
            --$parenthesisLevel;
        }

        if ('|' === $char && 0 === $parenthesisLevel) {
            $parts[] = $currentPart;
            $currentPart = '';
        } else {
            $currentPart .= $char;
        }
    }

    if ('' !== $currentPart) {
        $parts[] = $currentPart;
    }

    return $parts;
}

$testCases = [
    'string',
    'int',
    'bool',
    'array',
    'string|int',
    'string|int|bool',
    'string|int|bool|array',
    'string|(int|bool)',
    '(string|int)|bool',
    'string|(int|(bool|float))',
    '(string|int)|(bool|float)',
    'MyClass',
    'string[]',
    'int[]',
    '\\Namespace\\Class',
    'string|int|bool|array|object|resource|callable',
];

$iterations = 100000;

$start = microtime(true);

for ($i = 0; $i < $iterations; $i++) {
    foreach ($testCases as $testCase) {
        splitOutsideParenthesis($testCase);
    }
}

$end = microtime(true);
$duration = ($end - $start) * 1000;

$peakMemory = memory_get_peak_usage(true) / 1024 / 1024;

echo "Original implementation: " . number_format($duration, 2) . "ms for " . ($iterations * count($testCases)) . " operations\n";
echo "Peak memory usage: " . number_format($peakMemory, 2) . " MB\n";

test_opt1_fast_path_simple.php - Optimization 1: Fast path for simple types

<?php

function splitOutsideParenthesis(string $type): array
{
    if (!\str_contains($type, '|')) {
        return [$type];
    }
    
    $parts = [];
    $currentPart = '';
    $parenthesisLevel = 0;

    $typeLength = \strlen($type);
    for ($i = 0; $i < $typeLength; ++$i) {
        $char = $type[$i];

        if ('(' === $char) {
            ++$parenthesisLevel;
        } elseif (')' === $char) {
            --$parenthesisLevel;
        }

        if ('|' === $char && 0 === $parenthesisLevel) {
            $parts[] = $currentPart;
            $currentPart = '';
        } else {
            $currentPart .= $char;
        }
    }

    if ('' !== $currentPart) {
        $parts[] = $currentPart;
    }

    return $parts;
}

$testCases = [
    'string',
    'int',
    'bool',
    'array',
    'string|int',
    'string|int|bool',
    'string|int|bool|array',
    'string|(int|bool)',
    '(string|int)|bool',
    'string|(int|(bool|float))',
    '(string|int)|(bool|float)',
    'MyClass',
    'string[]',
    'int[]',
    '\\Namespace\\Class',
    'string|int|bool|array|object|resource|callable',
];

$iterations = 100000;

$start = microtime(true);

for ($i = 0; $i < $iterations; $i++) {
    foreach ($testCases as $testCase) {
        splitOutsideParenthesis($testCase);
    }
}

$end = microtime(true);
$duration = ($end - $start) * 1000;

$peakMemory = memory_get_peak_usage(true) / 1024 / 1024;

echo "Optimization 1 (fast path simple): " . number_format($duration, 2) . "ms for " . ($iterations * count($testCases)) . " operations\n";
echo "Peak memory usage: " . number_format($peakMemory, 2) . " MB\n";

test_opt2_fast_path_union.php - Optimization 2: Fast path for union types

<?php

function splitOutsideParenthesis(string $type): array
{
    if (!\str_contains($type, '(') && !\str_contains($type, ')')) {
        return \explode('|', $type);
    }

    $parts = [];
    $currentPart = '';
    $parenthesisLevel = 0;

    $typeLength = \strlen($type);
    for ($i = 0; $i < $typeLength; ++$i) {
        $char = $type[$i];

        if ('(' === $char) {
            ++$parenthesisLevel;
        } elseif (')' === $char) {
            --$parenthesisLevel;
        }

        if ('|' === $char && 0 === $parenthesisLevel) {
            $parts[] = $currentPart;
            $currentPart = '';
        } else {
            $currentPart .= $char;
        }
    }

    if ('' !== $currentPart) {
        $parts[] = $currentPart;
    }

    return $parts;
}

$testCases = [
    'string',
    'int',
    'bool',
    'array',
    'string|int',
    'string|int|bool',
    'string|int|bool|array',
    'string|(int|bool)',
    '(string|int)|bool',
    'string|(int|(bool|float))',
    '(string|int)|(bool|float)',
    'MyClass',
    'string[]',
    'int[]',
    '\\Namespace\\Class',
    'string|int|bool|array|object|resource|callable',
];

$iterations = 100000;

$start = microtime(true);

for ($i = 0; $i < $iterations; $i++) {
    foreach ($testCases as $testCase) {
        splitOutsideParenthesis($testCase);
    }
}

$end = microtime(true);
$duration = ($end - $start) * 1000;

$peakMemory = memory_get_peak_usage(true) / 1024 / 1024;

echo "Optimization 2 (fast path union): " . number_format($duration, 2) . "ms for " . ($iterations * count($testCases)) . " operations\n";
echo "Peak memory usage: " . number_format($peakMemory, 2) . " MB\n";

test_opt3_no_string_concat.php - Optimization 3: Eliminate string concatenation

<?php

function splitOutsideParenthesis(string $type): array
{
    $parts = [];
    $start = 0;
    $parenthesisLevel = 0;
    $length = \strlen($type);
    
    for ($i = 0; $i < $length; ++$i) {
        $char = $type[$i];

        if ('(' === $char) {
            ++$parenthesisLevel;
        } elseif (')' === $char) {
            --$parenthesisLevel;
        } elseif ('|' === $char && 0 === $parenthesisLevel) {
            $parts[] = \substr($type, $start, $i - $start);
            $start = $i + 1;
        }
    }

    if ($start < $length) {
        $parts[] = \substr($type, $start);
    }
    
    return $parts;
}

$testCases = [
    'string',
    'int',
    'bool',
    'array',
    'string|int',
    'string|int|bool',
    'string|int|bool|array',
    'string|(int|bool)',
    '(string|int)|bool',
    'string|(int|(bool|float))',
    '(string|int)|(bool|float)',
    'MyClass',
    'string[]',
    'int[]',
    '\\Namespace\\Class',
    'string|int|bool|array|object|resource|callable',
];

$iterations = 100000;

$start = microtime(true);

for ($i = 0; $i < $iterations; $i++) {
    foreach ($testCases as $testCase) {
        splitOutsideParenthesis($testCase);
    }
}

$end = microtime(true);
$duration = ($end - $start) * 1000;

$peakMemory = memory_get_peak_usage(true) / 1024 / 1024;

echo "Optimization 3 (no string concat): " . number_format($duration, 2) . "ms for " . ($iterations * count($testCases)) . " operations\n";
echo "Peak memory usage: " . number_format($peakMemory, 2) . " MB\n";

test_opt4_switch_statement.php - Optimization 4: Switch statement

<?php

function splitOutsideParenthesis(string $type): array
{
    $parts = [];
    $currentPart = '';
    $parenthesisLevel = 0;

    $typeLength = \strlen($type);
    for ($i = 0; $i < $typeLength; ++$i) {
        $char = $type[$i];

        switch ($char) {
            case '(':
                ++$parenthesisLevel;
                $currentPart .= $char;
                break;
            case ')':
                --$parenthesisLevel;
                $currentPart .= $char;
                break;
            case '|':
                if (0 === $parenthesisLevel) {
                    $parts[] = $currentPart;
                    $currentPart = '';
                } else {
                    $currentPart .= $char;
                }
                break;
            default:
                $currentPart .= $char;
                break;
        }
    }

    if ('' !== $currentPart) {
        $parts[] = $currentPart;
    }

    return $parts;
}

$testCases = [
    'string',
    'int',
    'bool',
    'array',
    'string|int',
    'string|int|bool',
    'string|int|bool|array',
    'string|(int|bool)',
    '(string|int)|bool',
    'string|(int|(bool|float))',
    '(string|int)|(bool|float)',
    'MyClass',
    'string[]',
    'int[]',
    '\\Namespace\\Class',
    'string|int|bool|array|object|resource|callable',
];

$iterations = 100000;

$start = microtime(true);

for ($i = 0; $i < $iterations; $i++) {
    foreach ($testCases as $testCase) {
        splitOutsideParenthesis($testCase);
    }
}

$end = microtime(true);
$duration = ($end - $start) * 1000;

$peakMemory = memory_get_peak_usage(true) / 1024 / 1024;

echo "Optimization 4 (switch statement): " . number_format($duration, 2) . "ms for " . ($iterations * count($testCases)) . " operations\n";
echo "Peak memory usage: " . number_format($peakMemory, 2) . " MB\n";

test_optimized.php - Final optimized implementation (all optimizations combined)

<?php

function splitOutsideParenthesis(string $type): array
{
    if (!\str_contains($type, '|')) {
        return [$type];
    }
    
    if (!\str_contains($type, '(') && !\str_contains($type, ')')) {
        return \explode('|', $type);
    }
    
    $parts = [];
    $start = 0;
    $parenthesisLevel = 0;
    $length = \strlen($type);
    
    for ($i = 0; $i < $length; ++$i) {
        $char = $type[$i];
        
        switch ($char) {
            case '(':
                ++$parenthesisLevel;
                break;
            case ')':
                --$parenthesisLevel;
                break;
            case '|':
                if (0 === $parenthesisLevel) {
                    $parts[] = \substr($type, $start, $i - $start);
                    $start = $i + 1;
                }
                break;
        }
    }
    
    if ($start < $length) {
        $parts[] = \substr($type, $start);
    }
    
    return $parts;
}

$testCases = [
    'string',
    'int',
    'bool',
    'array',
    'string|int',
    'string|int|bool',
    'string|int|bool|array',
    'string|(int|bool)',
    '(string|int)|bool',
    'string|(int|(bool|float))',
    '(string|int)|(bool|float)',
    'MyClass',
    'string[]',
    'int[]',
    '\\Namespace\\Class',
    'string|int|bool|array|object|resource|callable',
];

$iterations = 100000;

$start = microtime(true);

for ($i = 0; $i < $iterations; $i++) {
    foreach ($testCases as $testCase) {
        splitOutsideParenthesis($testCase);
    }
}

$end = microtime(true);
$duration = ($end - $start) * 1000;

$peakMemory = memory_get_peak_usage(true) / 1024 / 1024;

echo "Optimized implementation: " . number_format($duration, 2) . "ms for " . ($iterations * count($testCases)) . " operations\n";
echo "Peak memory usage: " . number_format($peakMemory, 2) . " MB\n";

dunglas · 2025-07-26T08:59:44Z

src/Symfony/Component/OptionsResolver/OptionsResolver.php

@@ -1215,30 +1215,40 @@ private function verifyTypes(string $type, mixed $value, ?array &$invalidTypes =
     */
    private function splitOutsideParenthesis(string $type): array
    {
+        if (!str_contains($type, '|')) {


Maybe could we even store a hardcoded list of known simple types somewhere to avoid the repeated calls to str_contains() in these cases.

Here is a list: https://www.php.net/manual/en/function.gettype.php

dunglas · 2025-07-26T09:03:28Z

src/Symfony/Component/OptionsResolver/OptionsResolver.php

+            return [$type];
+        }
+
+        if (!str_contains($type, '(') && !str_contains($type, ')')) {


We could likely optimize that too by looping over characters and check for both parenthesis. This will prevent looping two times.

A regexp to avoid the two calls to str_contains() may also be faster than the current implementation (but slower that the loop I propose).

bendavies · 2025-07-26T21:39:56Z

i investigated @dunglas suggestion to use regex.
a pure regex solution appears to be almost twice as fast as my current solution.
I'll update this PR on Monday

Summary
  php test_original.php ran
    5.53 ± 0.15 times slower than php test_optimized_v2.php <-- pure regex, no loops
    3.12 ± 0.08 times slower than php test_optimized.php

bendavies requested a review from yceruto as a code owner July 25, 2025 16:09

carsonbot added Status: Needs Review OptionsResolver labels Jul 25, 2025

carsonbot added this to the 7.4 milestone Jul 25, 2025

This comment has been minimized.

Sign in to view

bendavies force-pushed the optionresolver-splitOutsideParenthesis-performance branch from 1312319 to e01b177 Compare July 25, 2025 16:10

bendavies changed the title ~~[OptionsResolver] Optimize splitOutsideParenthesis() - 2.90x faster~~ [OptionsResolver] Optimize splitOutsideParenthesis() - 2.91x faster Jul 25, 2025

bendavies changed the base branch from 7.4 to 7.3 July 25, 2025 16:11

alexandre-daubois added the Performance label Jul 25, 2025

alexandre-daubois reviewed Jul 25, 2025

View reviewed changes

src/Symfony/Component/OptionsResolver/OptionsResolver.php Outdated Show resolved Hide resolved

src/Symfony/Component/OptionsResolver/OptionsResolver.php Outdated Show resolved Hide resolved

bendavies force-pushed the optionresolver-splitOutsideParenthesis-performance branch from e01b177 to 1591e54 Compare July 25, 2025 16:20

bendavies force-pushed the optionresolver-splitOutsideParenthesis-performance branch from 1591e54 to c135a89 Compare July 25, 2025 16:26

bendavies requested review from xabbuh, lyrixx, dunglas, welcoMattic, kbond, chalasr, OskarStark and jderusse as code owners July 25, 2025 16:26

bendavies changed the base branch from 7.3 to 7.4 July 25, 2025 16:26

yceruto approved these changes Jul 26, 2025

View reviewed changes

carsonbot added Status: Reviewed and removed Status: Needs Review labels Jul 26, 2025

alexandre-daubois approved these changes Jul 26, 2025

View reviewed changes

dunglas reviewed Jul 26, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

[OptionsResolver] Optimize splitOutsideParenthesis() - 2.91x faster #61239

[OptionsResolver] Optimize splitOutsideParenthesis() - 2.91x faster #61239

bendavies commented Jul 25, 2025 •

edited

Loading

Uh oh!

This comment has been minimized.

alexandre-daubois left a comment •

edited

Loading

Uh oh!

Uh oh!

Uh oh!

yceruto commented Jul 25, 2025

Uh oh!

bendavies commented Jul 25, 2025 •

edited

Loading

Uh oh!

dunglas Jul 26, 2025 •

edited

Loading

Uh oh!

dunglas Jul 26, 2025 •

edited

Loading

Uh oh!

bendavies commented Jul 26, 2025 •

edited

Loading

Uh oh!

Uh oh!

Uh oh!

[OptionsResolver] Optimize splitOutsideParenthesis() - 2.91x faster #61239

Are you sure you want to change the base?

[OptionsResolver] Optimize splitOutsideParenthesis() - 2.91x faster #61239

Conversation

bendavies commented Jul 25, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Test Methodology

Optimisations

1. Fast Path for Simple Types (No Pipes)

2. Fast Path for Union Types (No Parentheses)

3. Eliminate String Concatenation

4. Switch Statement Optimisation

Benchmark Results

Individual Optimisation Impact

Combined Optimisation Impact

Uh oh!

This comment has been minimized.

alexandre-daubois left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

yceruto commented Jul 25, 2025

Uh oh!

bendavies commented Jul 25, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

dunglas Jul 26, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dunglas Jul 26, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

bendavies commented Jul 26, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

bendavies commented Jul 25, 2025 •

edited

Loading

alexandre-daubois left a comment •

edited

Loading

bendavies commented Jul 25, 2025 •

edited

Loading

dunglas Jul 26, 2025 •

edited

Loading

dunglas Jul 26, 2025 •

edited

Loading

bendavies commented Jul 26, 2025 •

edited

Loading