reproduce:

1. create script.php with the following content:

<?php

declare(strict_types=1);

use Revolt\EventLoop;

require __DIR__ . '/../../vendor/autoload.php';

$write_line = static fn(string $m, ...$args) => printf($m . "\n", ...$args);

$write_line('Server is listening on http://localhost:3030');

// Error reporting suppressed since stream_socket_server() emits an E_WARNING on failure (checked below).
$server = @stream_socket_server('tcp://localhost:3030', $errno, $_, flags: STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, context: stream_context_create([
    'socket' => [
        'ipv6_v6only' => true,
        'so_reuseaddr' => false,
        'so_reuseport' => false,
        'so_broadcast' => false,
        'tcp_nodelay' => false,
    ]
]));
if (!$server || $errno) {
    throw new RuntimeException('Failed to listen localhost 3030.', $errno);
}

$watcher = null;
EventLoop::unreference(EventLoop::onSignal(SIGINT, static function () use ($server, &$watcher) {
    EventLoop::cancel((string) $watcher);
    fclose($server);
}));

$watcher = EventLoop::onReadable($server, function ($watcher, $resource) {
    $stream = @stream_socket_accept($resource, timeout: 0.0);
    if (false === $stream) {
        EventLoop::cancel($watcher);

        return;
    }

    stream_set_read_buffer($stream, 0);
    stream_set_blocking($stream, false);
    $suspension = EventLoop::createSuspension();
    $watcher = EventLoop::onReadable($stream, function () use ($suspension) {
        $suspension->resume();
    });
    $suspension->suspend();
    EventLoop::cancel($watcher);
    $request = stream_get_contents($stream);
    $suspension = EventLoop::createSuspension();
    $watcher = EventLoop::onWritable($stream, function () use ($suspension) {
        $suspension->resume();
    });
    $suspension->suspend();
    EventLoop::cancel($watcher);
    fwrite($stream, "HTTP/1.1 200 OK\n");
    $suspension = EventLoop::createSuspension();
    $watcher = EventLoop::onWritable($stream, function () use ($suspension) {
        $suspension->resume();
    });
    $suspension->suspend();
    EventLoop::cancel($watcher);
    fwrite($stream, "Server: TCP Server\n");
    $suspension = EventLoop::createSuspension();
    $watcher = EventLoop::onWritable($stream, function () use ($suspension) {
        $suspension->resume();
    });
    $suspension->suspend();
    EventLoop::cancel($watcher);
    fwrite($stream, "Connection: close\n");
    $suspension = EventLoop::createSuspension();
    $watcher = EventLoop::onWritable($stream, function () use ($suspension) {
        $suspension->resume();
    });
    $suspension->suspend();
    EventLoop::cancel($watcher);
    fwrite($stream, "Content-Type: text/html; charset=utf-8\n\n");
    $suspension = EventLoop::createSuspension();
    $watcher = EventLoop::onWritable($stream, function () use ($suspension) {
        $suspension->resume();
    });
    $suspension->suspend();
    EventLoop::cancel($watcher);
    fwrite($stream, "<h3>Hello, World!</h3>");
    $suspension = EventLoop::createSuspension();
    $watcher = EventLoop::onWritable($stream, function () use ($suspension) {
        $suspension->resume();
    });
    $suspension->suspend();
    EventLoop::cancel($watcher);
    fwrite($stream, "<pre><code>" . htmlentities($request) . "</code></pre>");
    $suspension = EventLoop::createSuspension();
    $watcher = EventLoop::onWritable($stream, function () use ($suspension) {
        $suspension->resume();
    });
    $suspension->suspend();
    EventLoop::cancel($watcher);
    fwrite($stream, sprintf('memory usage: %dMiB<br />', round(memory_get_usage() / 1024 / 1024, 1)));
    $suspension = EventLoop::createSuspension();
    $watcher = EventLoop::onWritable($stream, function () use ($suspension) {
        $suspension->resume();
    });
    $suspension->suspend();
    EventLoop::cancel($watcher);
    fwrite($stream, sprintf('peak memory usage: %dMiB<br />', round(\memory_get_peak_usage() / 1024 / 1024, 1)));
    @fclose($stream);
});

EventLoop::run();

$write_line('');
$write_line('Goodbye 👋');

2. run php script.php

memory keeps going up with each request ( noticeable with a request batch of 10k )

It seems suspensions are not being destructed properly and taking space in memory?

I'm not really sure what is happening, i first noticed the leak in https://github.com/azjezz/hack-php-async-io/blob/main/src/server.php, and went on simplifying the code to isolate it, until i reached this step, where no PSL code was involved, which means the leak is happening in revolt, or I'm doing something wrong.

when one of these extensions is not installed, and isSupported() gets called from the driver factory, you will receive the following error:

> php test.php
PHP Fatal error:  Could not check compatibility between Revolt\EventLoop\Driver\EventDriver::getHandle(): EventBase and Revolt\EventLoop\Driver::getHandle(): mixed, because class EventBase is not available in /home/azjezz/Projects/php-standard-library/vendor/revolt/event-loop/src/EventLoop/Driver/EventDriver.php on line 150

Fatal error: Could not check compatibility between Revolt\EventLoop\Driver\EventDriver::getHandle(): EventBase and Revolt\EventLoop\Driver::getHandle(): mixed, because class EventBase is not available in /home/azjezz/Projects/php-standard-library/vendor/revolt/event-loop/src/EventLoop/Driver/EventDriver.php on line 150

This is somehow PHP's fault as regardless if the type T exist or not, compatibility check for return type from mixed to T should pass, but fixing it here is easier :)

I catch error in my production server in callback method set_exception_handler(***):

Fiber stack protect failed: mprotect failed: Cannot allocate memory (12), /project/vendor/revolt/event-loop/src/EventLoop/Internal/AbstractDriver.php:495

In php.ini:

; Maximum amount of memory a script may consume
; https://php.net/memory-limit
memory_limit = -1

Available memory in server 230Gb.

This code:

$socket = \Amp\Socket\listen('tcp://127.0.0.1:49000', null);
$socket->accept();

Throws this warning on Windows platform:

Warning: EvLoop::run(): Libev error(9): Bad file descriptor in ...\vendor\revolt\event-loop\src\EventLoop\Driver\EvDriver.php on line 164

php -v

PHP 8.1.1 (cli) (built: Dec 15 2021 10:36:13) (NTS Visual C++ 2019 x64)
Copyright (c) The PHP Group
Zend Engine v4.1.1, Copyright (c) Zend Technologies

php --ri ev

ev

Ev support => enabled
Debug support => disabled
Version => 1.1.6RC1

Package versions:

revolt/event-loop: v0.1.1
amphp/socket: v2.x-dev

Drivers result in different exceptions/errors making it harder for end-user to handle.

an example would be EventLoop::onReadable/EventLoop::onWritable throwing different exception/error depending on the driver in case the resource was closed at one point, instead, we should throw ClosedResourceException.

currently, I'm handling this case by catching Throwable, and checking if the resource was closed again: https://github.com/azjezz/psl/blob/2.0.x/src/Psl/Async/await_readable.php#L42-L54, but this method is not sufficient.

Hello,

In Laravel Octane when using Swoole its possible to do something like the following.

	[ $recs1, $recs2 ] = Octane::concurrently( [
		fn() => $this->get_recs_a( $ids ),
		fn() => $this->get_recs_b( $ids )
	] );

What this will do is execute both functions get_recs_a and get_recs_b concurrently yet not returning unless both got executed and set their return values to $recs1 and $recs2.

How to achieve similar behavior?

Hi there 👋 😄 , I'm Benoit, an enthusiast Php/Async dev, and I just wanted to give my feedback (+ questions) as proposed in this tweet.

First of all, thank you very much for all this work! Even if I have some comments about RevoltPhp design, I'm really convinced that it's an awesome opportunity for Php ecosystem to see ReactPhp & Amp teams (& friends) working together to build such library 👍 🤩

Some context

When I had to choose an EventLoop for my company internal project, I studied a lot ReactPhp and Amp developer experience (DX). I really like the EventLoop Interface in ReactPhp, but I was really concerned by the potential callback hell for my team. In the other hand, Amp use generators with a nice DX (more intuitive to read IMHO), but EventLoop is global and doesn't expose an interface (but driver does). That's why we created Tornado, a modest attempt to abstract both with the Generator approach… So, when I read the first tweet of RevoltPhp I was very curious 😄

Fibers

I'm really excited about Fibers, I think it's the perfect tool to provide a fluent DX for async processing. But surprisingly, RevoltPhp seems to use callbacks extensively… Do you consider RevoltPhp like a very low-level async layer on which we can build some Fiber-oriented libs/projects? Nevertheless, it seems possible to rely on Fiber with the Suspension concept (example), but it seems very verbose.

$watcher = EventLoop::onWritable($stream, fn () => $suspension->resume(null));
$suspension->suspend();
EventLoop::cancel($watcher);

I was maybe expecting something like this:

EventLoop::waitWritable($stream);

Or maybe keeping the concept of Promise/Future, with something like:

$foo = EventLoop::wait(EventLoop::async(foo(...)));

🤷 Anyway, all these functions can be created from Revolt core functions, it's just to give you my (humble) opinion 😃

Combinators

Do you intend to provide some basic functions to combine asynchronous functions? Like all, race… ? Once again, it's totally possible thanks to suspension (example), but it's not straightforward IMHO

Conclusion

That's all 😄 Of course, I would prefer to have a non-global EventLoop or an EventLoopInterface (instead of using Drivers), but I don't think it's the most important, just a matter of taste 😉 And once again, thank you for this library 👍 Even with this design, I'm pretty sure it will be very useful as a core component to other projects. If you are curious, I created a 1-file async-library for an incoming talk, to quickly show possibilities offered by Fibers: https://github.com/b-viguier/Slip . Just for demonstration purpose, but feel free to comment 🤷

Benoit

This changes Suspension to hold only a weak reference to the associated Fiber object while not suspended. Without this, there is a circular reference between the weak map of suspensions and the fiber held within the suspension.

This fixes the memory leak in https://github.com/revoltphp/event-loop/issues/42#issuecomment-1041600341.

callable is a problematic type, because it's scope dependent. It can therefore not be used for typed properties, but \Closure can be used as a safe replacement, especially with first-class syntax introduced in PHP 8.1: (...).

Resolves #14.

This PR allows user-definable hooks to be invoked when a fiber (or main) is suspended or resumed.

The motivation is to allow libraries/apps to implement behavior such as that requested in amphp/amp#354 if so desired.

This is designed to be lightweight so applications that do not use these hooks do not incur a large performance overhead.

• [ ] Benchmarks to see what effect this has on performance.

I'm writing a pure PHP equivalent of libpq that uses RevoltPHP v0.2.1 and Amp v3 (latest beta). And after I implemented the basic things like sending queries/reading rows, I decided to profile the performance.

And then I saw that the most time is spent on calling Fiber::suspend:

If I understand correctly, Fiber::suspend time includes I/O wait time. But is there any way to see only I/O wait time?

When I tried to compare my performance results with the same bench, but using the pgsql PHP extension, it was almost twice as fast.

Hello maintainer, I try http-server example in https://github.com/revoltphp/event-loop/blob/main/examples/http-server.php,

But when using ab tool to benchmark, it result in

This is ApacheBench, Version 2.3 <$Revision: 1901567 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (be patient)
apr_socket_recv: Connection reset by peer (104)

AFAIK, this is not the problem with ab tool it self, but with the webserver, I'm using default ubuntu server to test it.