Not seeing anything obvious based on these profiles. Without a reproducer, the only suggestion I can make is to a) gather garbage collection statistics using gc_status() (maybe Blackfire already collects them and I can't find it) and b) create a memory profile using "USE_ZEND_ALLOC=0 valgrind --tool=massif php vendor/bin/phpunit" followed by "ms_print massif.*" (this will take a long time to run). This may or may not pinpoint the source of the leak.

The PHP 7.3 memory profile states that the peak memory would be
761 MB, but for the Text::getConsecutiveWords the allocated memory
is reported as 4060 MB.  That appears to be contradictory.

> maybe Blackfire already collects them and I can't find it

Sent a message to Blackfire to see if they can provide any insight.

> The PHP 7.3 memory profile states that the peak memory would be
> 761 MB, but for the Text::getConsecutiveWords the allocated memory
> is reported as 4060 MB.  That appears to be contradictory.

I think this may be something else.

https://github.com/bytestream/php74-memory-leak

$ php7.3 vendor/bin/phpunit --repeat 100
Time: 3.78 seconds, Memory: 396.00 MB

$ php7.4 vendor/bin/phpunit --repeat 100
Time: 11.56 seconds, Memory: 734.00 MB

with gc_collect_cycles in tearDown - ref; https://github.com/fzaninotto/Faker/pull/1730

$ php7.3 vendor/bin/phpunit --repeat 100
Time: 4.71 seconds, Memory: 32.00 MB

$ php7.4 vendor/bin/phpunit --repeat 100
Time: 13.54 seconds, Memory: 34.00 MB

If I add gc_collect_cycles to the full app, PHP 7.4 memory usage remains unchanged at 3.89GB

Adding more routes to the test case seems to show some interesting results.

https://github.com/bytestream/php74-memory-leak/tree/routes

$ php7.2 vendor/bin/phpunit --repeat 1000
Time: 1.09 minutes, Memory: 144.00 MB

$ php7.3 vendor/bin/phpunit --repeat 1000
Time: 17.47 seconds, Memory: 138.00 MB

$ php7.4 vendor/bin/phpunit --repeat 1000
Time: 58.73 seconds, Memory: 510.00 MB

It's something to do with the use of require

Another example, different code, but same principle. 

https://github.com/bytestream/php74-memory-leak/tree/factories

$ php7.2 vendor/bin/phpunit --repeat 100
Time: 1.75 minutes, Memory: 322.00 MB

$ php7.3 vendor/bin/phpunit --repeat 100
Time: 1.02 minutes, Memory: 310.50 MB

$ php7.4 vendor/bin/phpunit --repeat 100
Time: 2.24 minutes, Memory: 1.32 GB

Could it be related to the recently fixed leak 

https://github.com/php/php-src/commit/3151676f520555bfadb39ea76779e93552d13fc1

Please tests with PHP 7.4.6RC1 (has just been released).

https://github.com/bytestream/php74-memory-leak/tree/routes

$ ~/php7.4.6-rc.1/bin/php -d memory_limit=-1 vendor/bin/phpunit --repeat 1000
Time: 42.64 seconds, Memory: 520.00 MB

https://github.com/bytestream/php74-memory-leak/tree/factories

$ ~/php7.4.6-rc.1/bin/php -d memory_limit=-1 vendor/bin/phpunit --repeat 100
Time: 3.37 minutes, Memory: 1.45 GB

Another leak? Memory usage up in both cases compared to 7.4.5

Hi there,

Here are 2 profiles for comparison:

- PHP 7.3.17: https://blackfire.io/profiles/b7785fda-415f-4176-a57e-f5e2417b46b0/graph
- PHP 7.4.5: https://blackfire.io/profiles/712b3b08-4ccc-4a6a-ae9b-70b4ee030334/graph
- Comparison graph:https://blackfire.io/profiles/compare/b7785fda-415f-4176-a57e-f5e2417b46b0...712b3b08-4ccc-4a6a-ae9b-70b4ee030334/graph

You have access to the timeline which shows the peak memory increasing (blue graph in the background).
While exploring the comparison graph a bit, using the memory dimension, I found that it looks like it's coming from explode()/implode()/array_shift():
- https://blackfire.io/profiles/compare/b7785fda-415f-4176-a57e-f5e2417b46b0...712b3b08-4ccc-4a6a-ae9b-70b4ee030334/graph?settings%5Bdimension%5D=pmu&settings%5Bdisplay%5D=focused&settings%5BtabPane%5D=nodes&selected=Faker%5CProvider%5CText%3A%3AgetConsecutiveWords%3F00a7bff87618e1493437abb5cf94878a&callname=Faker%5CProvider%5CText%3A%3AgetConsecutiveWords%3F00a7bff87618e1493437abb5cf94878a
- https://blackfire.io/profiles/compare/b7785fda-415f-4176-a57e-f5e2417b46b0...712b3b08-4ccc-4a6a-ae9b-70b4ee030334/graph?settings%5Bdimension%5D=pmu&settings%5Bdisplay%5D=focused&settings%5BtabPane%5D=nodes&selected=Faker%5CProvider%5CText%3A%3AgetExplodedText%3F00a7bff87618e1493437abb5cf94878a&callname=Faker%5CProvider%5CText%3A%3AgetExplodedText%3F00a7bff87618e1493437abb5cf94878a

I hope this helps :-)

It seems that my profile comparisons are not easy to share, so I did some screenshots which you can view here: https://github.com/bytestream/php74-memory-leak/issues/1

Here's the result from valgrind on the CI server (nothing to do with my reproducers). Anything jump out Nikita? Not sure why it's blanked a lot of the lines - it's running with --enable-debug

$ USE_ZEND_ALLOC=0 valgrind --tool=massif php vendor/phpunit/phpunit/phpunit
 ==25== Massif, a heap profiler
 ==25== Copyright (C) 2003-2017, and GNU GPL'd, by Nicholas Nethercote
 ==25== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
 ==25== Command: php vendor/phpunit/phpunit/phpunit
 ==25== 
 PHPUnit 8.5.4 by Sebastian Bergmann and contributors.

https://gist.githubusercontent.com/bytestream/ad3270993599c720eb7db8ada597eb24/raw/fe94995d1aee1eb64a9e61da07810717fb32e0da/massif.out.25

@kieran: The "factories" case looks like https://bugs.php.net/bug.php?id=76982, where a file declaring an anonymous function is included many times. The anonymous function declaration will leak in that case. This is a bug in PHP, but not one that will be fixed in 7.4. I'm not familiar with Laravel's factory system, but it can probably be addressed there by making that the includes are memoized.

I thought it might be that too, but it seems odd that 7.4 is so much higher when that bug report suggests the issue exists in most of 7.x

Nothing in the ms_print in my previous message?

I'll check if includes can be memorised.

@kieran: PHP 7.4 fixed some issues related to anonymous functions "overwriting" previous anonymous functions in the same file under some circumstances. Unfortunately this also means that this leak is now more pronounced, because this accidental destruction vector no longer exists.

It looks like the cause for the "routes" case is the same. However, the "master" branch is a different issue. Here are the massif outputs for 7.3 and 7.4: https://gist.github.com/nikic/2a5d1a6eb4a4bb82be5e18225ae16d87

Can ignore the master branch. That was an issue in Laravel that I pushed a fix for. I've just not updated that repository yet.

I see. The master branch case is still potentially actionable from our side. The problem there is that GC runs too rarely. PHP 7.4 made this worse, because collecting objects with destructors requires two GC runs, and is seems Laravel makes use of destructors somewhere in there.

There's probably two things we can do to improve this at least:
1. Count any GC run with destructors as a "successful" run, so threshold is reduced.
2. Allow threshold reductions below the default of 10000, which seems too high for this case.

Alternatively we could always automatically rerun GC if we encountered destructors, instead of waiting for the next GC run.

@nikita I think you're probably right:
> PHP 7.4 fixed some issues related to anonymous functions "overwriting" previous anonymous functions in the same file

I "memorised" the faker requires as suggested and it cut usage from 3.8G to 2.6G. So I assume similar changes elsewhere would further reduce memory usage. The only problem is anonymous function usage is rife in Laravel!

Not sure if you want to close this as duplicate of https://bugs.php.net/bug.php?id=76982 or repurpose following below comment:
> The master branch case is still potentially actionable from our side.

Will there be a fix for this issue in PHP 8? Just tested against the PHP 8.0-beta.1 docker image and memory usage matches PHP 7.4

I did some work on this in https://github.com/php/php-src/pull/5593 and https://github.com/php/php-src/pull/5595, but unfortunately it's not easy to fix.

In PHP 8.1, the memory leak for repeated included anonymous functions has been addressed by https://github.com/php/php-src/pull/5595 (or at least, mostly addressed).

The GC with destructors issue has been addressed by https://github.com/php/php-src/pull/5581.

I believe that covers the issues raised here.

I want to follow up on this one, since the issue doesn't seem to be resolved.

Tested on PHP 8.1.0 and PHPUnit 9.5.10; running a Laravel test suite of 1400 tests results in a rather significant memory leak. Here's a screenshot of the memory consumption plotted in a chart: https://user-images.githubusercontent.com/6905297/145394833-dc488206-238d-4164-86e4-e2ad8c824590.png

This is the issue related to Laravel discussing the problem: https://github.com/laravel/framework/issues/30736
And here's the phpunit issue: https://github.com/sebastianbergmann/phpunit/issues/3915

@brendt: Is this still the same issue? The fact that a leak occurs when running tests doesn't say a lot about what the root cause is.

PHP 8.1 fixes specifically the case where a file defining an anon function gets included many times, but there are variations on this that still leak (e.g. if it's an anon class instead).

@nikic It's probably the other cases that haven't been fixed

> but there are variations on this that still leak (e.g. if it's an anon class instead).

Is this something I should open a bug report for if you're already aware of the issue?