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

We made all callbacks suspension-safe by running them in an extra fiber, but this isn't true for the error handler currently. This has high potential for mistakes, so we should do something about it.

The following code samples fail with different error when using with ev and uv drivers.

Stream select driver does not fail.

using PSL 2.0.x branch:

<?php

require_once 'vendor/autoload.php';

Psl\Async\concurrent([
    fn() => Psl\Async\sleep(0.1),
    fn() => Psl\Async\sleep(0.1),
]);

using Amphp v3 branch:

<?php

require_once 'vendor/autoload.php';

Amp\Future\all([
  Amp\coroutine(fn() => null),
  Amp\coroutine(fn() => null),
]);

Expected: no error.

Actual result:

EvDriver :

[*] ev extension is enabled.
> php sample.php
PHP Warning:  EvLoop::run(): Stopping event loop because of uncaught exception in the callback in /home/azjezz/Projects/php-standard-library/vendor/revolt/event-loop/src/EventLoop/Driver/EvDriver.php on line 164

Warning: EvLoop::run(): Stopping event loop because of uncaught exception in the callback in /home/azjezz/Projects/php-standard-library/vendor/revolt/event-loop/src/EventLoop/Driver/EvDriver.php on line 164

UvDriver :

[*] uv extension is enabled.
> php sample.php
[1]    1478 segmentation fault  php sample.php

Note: EventDriver used to fail as well, however, 70e67dc fixed it.

I'm getting some segfaults reported on older PHP versions (< 8.1.17 and <8.2.4) in our GrumPHP project.
Would it make sense to add a conflict section in the composer file of this package so that people know there something wrong with their setup?

It's a PHP bug but it make usage of fibers rather unstable:

• GH-10496 (segfault when garbage collector is invoked inside of fiber).

I can always add it to my project, but it might make more sense to add it here so that other projects can benifit from this as well.

Would it be possible to use this library to maintain a connection to to a 3rd party API and an internal kafka broker using the rdkafka extension

We have a microservice design with many apps integrated with kafka, and we are working on rewriting our connector to a 3rd party service. We are a bit lost though on how we would be able to maintain a dual connection to both their 3rd party API (via websocket) and an internal kafka broker to send and received both ways.

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.

Do we have any example of improving the performance of an already existing PHP framework or CMS? Are there any libraries that leverage event loop to enhance the performance?

Issue

In Windows, when I type ctrl+c, an exception is thrown.
There are no problems under the Linux system.
I don't know why. Please help me to see if this is a bug?
Please look at my code. I used the error suppressor to call mkdir, which should not throw an exception.

I can solve this problem in my code, but I don't know why register_shutdown_function executed in the event loop.

My English is very poor. Please look at the code. Thank you

PHP code

<?php

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

use Revolt\EventLoop;

$server = \stream_socket_server('tcp://0.0.0.0:8080');
\stream_set_blocking($server, false);

EventLoop::onReadable($server, fn () => null);

\register_shutdown_function(function () {
    @mkdir(__FILE__); // I deliberately made an error, but I masked it through the error suppressor.
});

if (DIRECTORY_SEPARATOR === '\\') {
    sapi_windows_set_ctrl_handler(function () {
        echo "ctrl+c." . PHP_EOL;
        exit;
    });
} else {
    if (defined('\SIGINT')) {
        EventLoop::onSignal(\SIGINT, function () {
            echo "ctrl+c." . PHP_EOL;
            exit;
        });
    }
}

EventLoop::repeat(1, fn () => null);

echo "started." . PHP_EOL;

EventLoop::run();

Windows system threw an exception

• Windows 11
• PHP 8.2.0RC5

F:\revolt>php test.php
started.
ctrl+c.
PHP Fatal error:  Uncaught Exception: mkdir(): File exists in F:\revolt\vendor\revolt\event-loop\src\EventLoop\Driver\StreamSelectDriver.php:77
Stack trace:
#0 [internal function]: Revolt\EventLoop\Driver\StreamSelectDriver->Revolt\EventLoop\Driver\{closure}(2, 'mkdir(): File e...', 'F:\\revolt\\test....', 14)
#1 F:\revolt\test.php(14): mkdir('F:\\revolt\\test....')
#2 [internal function]: {closure}()
#3 {main}
  thrown in F:\revolt\vendor\revolt\event-loop\src\EventLoop\Driver\StreamSelectDriver.php on line 77

Linux system is OK

tianyiw@TIANYIW-HOME-PC:~/revolt$ php test.php
started.
^Cctrl+c.

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

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.

Would it make sense to implement a new based on io_uring / IoRing?

Found a discussion which shares other languages/applications to use a io_uring based loop for better performance, see https://news.ycombinator.com/item?id=23133040

IoRing on Windows: oven-sh/bun#43 (comment)

the origin idea for opening this issue is by Arnauld, a php-src developer

After a while of studying and testing Amphp, I'm finally comfortable programing in Amp. Then I learned about Revolt and its use of Fibers to simplify concurrent php programming. The question/dilemma I have is which should I use now? I would prefer to use Revolt so I don't have to do all of the yield/generator/call() mental juggling but I love the existing framework/libraries that Amp already provides.

So do I implement my own higher-level libs to use Revolt or is there a way I can use Revolt in conjunction with Amp or do I have to wait for another Revolt-based framework to be built? Either way this is very exciting stuff.

When visiting revolt.run, I'm greeted with a certificate expiration error.

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.

See amphp/amp#262.

See amphp/amp#214.

Idle watcher is a bad name, but I got that from http://docs.libuv.org/en/v1.x/design.html#the-i-o-loop. Basically watchers which are invoked on every loop iteration, but they shouldn't trigger an immediate new iteration IMO (like nested defers).

https://github.com/kelunik/loop-block is one possible use case. Another would be moving signal handlers out of the event loop and into these idle handlers.

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.

Currently there's getInfo to allow for some statistics, but I think it would be better to add further inspection tools for monitoring / debugging, e.g.

getCallbackIds(): array
getCallback(string): callable
isReferenced(string): bool
isEnabled(string): bool
getType(string): string // not sure which name fits here

This would probably also allow removing getInfo().

I have some weird issue in amphp/http-client that only happens with extension drivers where it doesn't trigger the readability callback and then eventually triggers a timeout delay callback, however when reading inside the timeout, there's still data to read.

I added some print based logging for debugging purposes, but I guess it could be helpful to have a logging decorator.

Consider these test cases (the one case immediately resumes in cycle collection, the other schedules something on the event loop):

    public function testSuspensionResumptionWithQueueInGarbageCollection(): void
    {
        $suspension = EventLoop::getSuspension();

        $class = new class($suspension) {
            public function __construct(public Suspension $suspension) {}
            public function __destruct() { $this->suspension->resume(true); }
        };
        $cycle = [$class, &$cycle];
        unset($class, $cycle);

        $ended = $suspension->suspend();

        $this->assertTrue($ended);
    }

    public function testEventLoopResumptionWithQueueInGarbageCollection(): void
    {
        $suspension = EventLoop::getSuspension();

        $class = new class($suspension) {
            public function __construct(public Suspension $suspension) {}
            public function __destruct() { EventLoop::queue($this->suspension->resume(...), true); }
        };
        $cycle = [$class, &$cycle];
        unset($class, $cycle);

        $ended = $suspension->suspend();

        $this->assertTrue($ended);
    }

These cases both will fail with:

Error: Event loop terminated without resuming the current suspension (the cause is either a fiber deadlock, or an incorrectly unreferenced/canceled watcher):

(The trailing colon is also weird, it means that no other fibers exist, maybe write that out.)

I was initially very confused when this happened in my code as dumping the event loop showed a pending queue() call, while the EventLoop reported as finished.

I would expect that, after the gc_collect_cycles():

the EventLoop is checked for any active, referenced watchers or microtasks, and if yes, is resumed. Similarly, if a suspension was resumed within that cycle collection, it will leave the code path leading to the error being thrown.

I see a property

It add in #52 to use resume throw.

But the commit 0ea6f6 resume throw remove the property.

Does it need to be cleaned up or does it have any function.

I think it cause leak, related #52 (comment).

Given there's https://wiki.php.net/rfc/first_class_callable_syntax, every callable can easily be expressed using (...), which returns a Closure. Should we use Closure as a type instead of callable? This would probably simplify some code paths and allows using additional typed properties.

The value could default to null as suggested here: amphp/amp#364.

Hello,

When i use examples the http-server.

In this code

When execute close conn, it will be throw TypeError: stream_select(): supplied resource is not a valid stream resourcs

I see the EventLoop::cancel($watcher); in following, the deactivate function seem never to be run?

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.

Using the reproducer @ https://paste.daniil.it/uv.tar.xz (https://github.com/danog/MadelineProto @ commit 0e838c79a56f160143ad88f0dd65d64dc102d2c4 + an aaa.php test file), running the following command on arch linux yields a total hang of the entire application around once every 10 tries, without even the periodic "Still alive" message, manually set up using EventLoop::repeat(1.0, fn () => var_dump("Still alive")); in aaa.php.

rm -rf aaa.madeline; php aaa.php

Sending CTRL-C unblocks the application, gdb shows it's stuck on an epoll syscall inside uv.

Sometimes a partial hang occurs (i.e. reads on some sockets stop returning anything, but the periodic messages are still printed), other times a full hang occurs.

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?

We only have Revolt\now() left in functions.php. It doesn't seem to provide much value and we should get rid of it, so we don't need any files autoload.

We currently don't test with every extension on CI.

The Drupal framework is looking to adopt Revolt as its event loop. Since this would become a very integral part of Drupal (with some existing systems already moving to async), one of the evaluation criteria is that the package has a security policy that outlines how to properly report security issues.

From one of Drupal's security team members on the issue discussing Revolt's adoption:

Can we ask the maintainers if they are willing to publish a security policy? Given that this is a low level runtime dependency it seems quite important that if there is a security issue the maintainers are prepared to fix it within a reasonable timescale.

Would it be possible to clarify Revolt's security policy and document it in a SECURITY.md file so it shows up in GitHub's security tab? This can also help other larger frameworks in adopting Revolt :)

Is it possible to add swow driver?

Problem Description

I want to run code like the following:

// Perform eager tasks as often as possible but never more than one at a time.
$callbackId = EventLoop::repeat(0, function ($callbackId) {
  EventLoop::disable($callbackId);
  $this->performHalfSecondTask();
  EventLoop::enable($callbackId);
});

// Simulate some long task that mostly suspends.
EventLoop::delay(1.25, function() use ($callbackId) {
  echo "Cancelling repeat\n";
  EventLoop::cancel($callbackId);
});

EventLoop::run();

The problem with this is that there's no efficient way to check if $callbackId is still valid when running EventLoop::enable($callbackId); which means that there's a guaranteed exception somewhere in the program.

Workarounds

There's two possible ways around this, neither of which are great:

1. Check all the identifiers, this is potentially expensive if the list of identifiers is large due to a high number of async tasks.

if (in_array($callbackId, EventLoop::getIdentifiers, TRUE)) {}

2. Catch the exception. This feels quite verbose and it's unclear whether this is intentional or whether a developer unintentionally hides a bug here.

try {
    EventLoop::enable($callbackId);
}
catch (EventLoop\InvalidCallbackError $e) {}

Feature Request

It would be great if there is a method saying EventLoop::isValidIdentifier which does an isset behind the scenes.

if (EventLoop::isValidIdentifier($callbackId)) {
   EventLoop::enable($callbackId);
}

Alternatively a second parameter to enable/disable to indicate it may fail silently would work too:

EventLoop::enable($callbackId, TRUE);