Preliminary vote

[EdmondDantes]

This post represents a preliminary vote on the features that will be included in the next TrueAsync RFC 2.0.

I suggest that everyone who is interested vote explicitly by posting here in favor or against.

You can also review the research that was conducted on WordPress and Laravel as stateful applications:

• WordPress
• Laravel

Also: Two dev strategy

The following is proposed:

Single-threaded coroutines:

1. Each coroutine has its own $GLOBALS.
2. Each Scope can have its own set of SuperGlobals or inherit them from the parent.

Multithreaded version:
3. Coroutines are explicitly created in a separate thread via a dedicated function. Such coroutines will not automatically migrate between PHP VMs/threads like in Go. Passing objects into such coroutines will follow the Shared Nothing principle.

In the future, the possibility of implementing multithreaded coroutines like in Go.

[adrian-enspired]

is there a doc we can see to clarify specifics on these points?
maybe code examples?

for example,
2) does "inherit" mean the superglobals will be copied by value? or shared?
3) is "shared nothing" intended to apply to everything, or just objects?
?) how will communication between coroutines work? is there anything built in or is this left to the user to implement?

[xingye00186]

https://github.com/true-async/wordpress-test-pure/blob/main/app/server.php

spawn(function(): void {
    while (true) {
        delay(5000);
        $activeCoroutines = count(getCoroutines());
        $activeConnections = ServerStats::$connectionsStarted - ServerStats::$connectionsClosed;

        echo "[Stats] Connections: Accepted=" . ServerStats::$connectionsAccepted .
             " Started=" . ServerStats::$connectionsStarted .
             " Active=" . $activeConnections .
             " Closed=" . ServerStats::$connectionsClosed .
             " | Requests: Total=" . ServerStats::$requestCount .
             " Handled=" . ServerStats::$requestHandled .
             " | Coroutines: " . $activeCoroutines . "\n";
    }
});

[EdmondDantes]

@EdmondDantes hello ed, are class static variables isolated?

No, I abandoned this idea because static properties cannot be isolated without performance issues.

[xingye00186]

Here are some considerations regarding static properties in Java for reference:

Replace "thread" with "coroutine" to convey the same meaning.

Thread Safety

Accessing and modifying static properties must ensure thread safety, especially in multi-threaded environments. This can be achieved through synchronized code blocks or methods.

Design Considerations

Overusing static properties can make code difficult to maintain and understand, particularly in large projects. Use them judiciously and consider alternatives such as instance variables or design patterns (e.g., Singleton pattern) to achieve the same functionality.

By using static properties appropriately and with careful design, they can effectively be used for implementing global state, configuration information, and other scenarios.

[EdmondDantes]

Here is some issues about static properties in Java for reference:

The multi-threaded version requires a Shared Nothing memory model.

[xingye00186]

Replace "thread" with "coroutine" to convey the same meaning.

Coroutine Safety
Accessing and modifying static properties must ensure coroutine safety, especially in multi-coroutines environments. This can be achieved through synchronized code blocks or methods. blabla...

[livein]

Well done, hope Single-threaded coroutines can quickly support Laravel. Many people are looking forward to using it soon

[EdmondDantes]

Well done, hope Single-threaded coroutines can quickly support Laravel. Many people are looking forward to using it soon

Coroutines cannot support Laravel, because Laravel is PHP code and coroutines are a part of PHP. Only Laravel can support coroutines, not the other way around.

[supdger]

Group members engaged in extensive discussions about the content and the poll, and also made their choices in the poll.

Meanwhile, some members suggested: why not develop a CLI (Channel for Access to Services)?

[EdmondDantes]

Meanwhile, some members suggested: why not develop a CLI (Channel for Access to Services)?

Could you please elaborate on this question?

[arnaud-lb]

The discussion doesn't state the goal or purpose of the proposed change. Is it only for legacy applications to run concurrently in a single PHP process? Is it to improve performance or purely for convenience?

How do the proposed features compare to e.g. Threads? If purely for convenience, pcntl_fork() or proc_open() can be used to achieve concurrency as well.

Single-threaded coroutines

This strategy provides very little isolation, as global variables are not the only global state in a process: Changes to the autoloader, error handler, ini settings, symbols (constants, functions, classes), persistent resources/connections, static class properties, static local variables, etc, in a request will affect all other requests.

Code that temporarily change the error handler or ini settings will break, if context switches are allowed during the temporary change.

Also, fatal errors (including memory limit) and exit() in a request will kill all other requests.

Does it increase the cost of context switches between coroutines?

Multithreaded version

This seems similar to Threads, and provides full isolation. I would vote for this strategy, but it may be better to have a clearly separate API for this rather than reusing the coroutine API.

[EdmondDantes]

By the way, here is another argument against it: the lack of readonly SuperGlobals.
I was just analyzing the WordPress code the other day, and you can see things like this there:
unset($_GET['some'])

Honestly, I don’t like that the language allows this.

[arnaud-lb]

@EdmondDantes as it's just for convenience, there are existing ways to achieve this, that don't any changes to the application or to php-src:

• Use the builtin cli server with PHP_CLI_SERVER_WORKERS=n: cd wordpress && PHP_CLI_SERVER_WORKERS=5 php -S 0.0.0.0:8080 -t .
• Use pcntl_fork() or proc_open() to build a forking HTTP server that runs the application
• Use the Threads extension

[arnaud-lb]

@xingye00186 of course, but the use-case covered by the proposed changes is legacy applications. A newer application following the best practices will not use globals, therefore will not need the proposed changes.

[EdmondDantes]

@EdmondDantes as it's just for convenience, there are existing ways to achieve this, that don't any changes to the application or to php-src:

• Use the builtin cli server with PHP_CLI_SERVER_WORKERS=n: cd wordpress && PHP_CLI_SERVER_WORKERS=5 php -S 0.0.0.0:8080 -t .
• Use pcntl_fork() or proc_open() to build a forking HTTP server that runs the application
• Use the Threads extension

Then it will be a completely different story: one request, one thread/process.

[xingye00186]

@xingye00186 of course, but the use-case covered by the proposed changes is legacy applications. A newer application following the best practices will not use globals, therefore will not need the proposed changes.

Some people require backward compatibility, while others assume the user's code follows best practices, which is a difficult problem.

[EdmondDantes]

Thank you to everyone who participated in the vote.

Taking into account the arguments for and against, the feature with GLOBALS isolation will be postponed. The two main arguments behind this decision are:

1. The lack of a READONLY mechanism for GLOBALS, which makes their usage potentially dangerous
2. The possibility of automatically refactoring the code