Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:129385
Precedence: list
MIME-Version: 1.0
References: <CAMW7n8D0QshP8VhGOUqVnC+Uwf88TC_yy_mQdeNZW_go5YLdcw@mail.gmail.com>
 <C58ADF49-6E21-4E25-8859-2A0769829E38@php.net> <e8625214-1c6f-40b8-b24f-e592e6f92012@beccati.com>
 <CAMW7n8Dy3=QyCrG4BMwVXWAipgOr2Vyhy_jbLVTYeq2Jc5v15g@mail.gmail.com>
 <dbc31109-a43d-4afc-9f4f-62c6439328e5@rwec.co.uk> <ea59722c-2c84-4a59-a442-a8b217ff577d@gmail.com>
 <b151687a-f4bd-48cf-90e6-440f763ccd6b@rwec.co.uk> <CAMW7n8CLZ7yFhUhh89wx7L+YwQ25LA7HZoGWUFB3R76KgXko2w@mail.gmail.com>
 <CAEKnhAHRPbiU4auDuTtFL2ueNnACjmYm_ff9c3VciYE9HfeGZg@mail.gmail.com> <AM8P250MB01703D8EA7280D024B0623DDE2D2A@AM8P250MB0170.EURP250.PROD.OUTLOOK.COM>
In-Reply-To: <AM8P250MB01703D8EA7280D024B0623DDE2D2A@AM8P250MB0170.EURP250.PROD.OUTLOOK.COM>
Date: Sat, 22 Nov 2025 10:12:57 +0100
Message-ID: <CAEKnhAEuUy5Yr_T4PCcngEr0zpWc_NLyHOXfpTdtw2DOw-DZ1A@mail.gmail.com>
Subject: Re: [PHP-DEV] [VOTE] True Async RFC 1.6
To: Bob Weinand <bobwei9@hotmail.com>
Cc: Edmond Dantes <edmond.ht@gmail.com>, "Rowan Tommins [IMSoP]" <imsop.php@rwec.co.uk>, internals@lists.php.net
Content-Type: multipart/alternative; boundary="000000000000b78d7306442b562a"
From: bukka@php.net (Jakub Zelenka)

--000000000000b78d7306442b562a
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

Hi Bob,

On Sat, Nov 22, 2025 at 5:50=E2=80=AFAM Bob Weinand <bobwei9@hotmail.com> w=
rote:

> Hey Jakub,
> On 21.11.2025 12:29:16, Jakub Zelenka wrote:
>
> Hi,
>
> I think you seriously underestimate impact of this in the current PHP cod=
e
> bases where many applications depend on global state. Especially the lega=
cy
> ones but even the most popular ones. Just look into WordPress which use
> global state extensively. Now imagine that some popular plugin decides to
> use async which change some of its globals (like $post or $wp_query) duri=
ng
> the suspension of the main code. I would assume this could horribly break
> things. Don't forget that other code don't have control over the plugin a=
nd
> it might not even know that async is used there. So I'm not sure if this
> design is compatible with WordPress and similar applications where global
> state is used extensively. If that's the case, it's of course a problem
> because those applications (well WordPress on its own in fact) compose th=
e
> majority of PHP users so introducing something that would have potential =
to
> break its code would limit usability of the whole feature and could even
> lead to loosing more users that we could gain from introducing this featu=
re.
>
> So I think it will need to find some solution that will prevent this from
> happening. I guess there might be few options
>
> 1. Disallow suspension of the main sync code which is effectively some
> sort of colouring.
> 2. Preventing access to globals from coroutine which I'm not sure is even
> fully doable from the engine PoV - it would mean some sort of different
> execution mode that could not use globals (e.g. global keyword and callin=
g
> some functions that change global state). It would need channels for
> communications between coroutines. The advantage of such model would be
> possibility to combine it with threads in the future but I could imagine =
it
> could still lead to some subtle issue for years as there is internal glob=
al
> state as well that can lead to some surprises. But maybe that would be
> worth it.
>
> I think you seriously misunderstand this.
>
> Async does not allow you to introduce some effects from the outside. You
> have to actively opt-in to running stuff in parallel.
>
But you don't have to opt in into it in this current form. If some external
plugin calls spawn (without await), then it can suspend other plugins (that
didn't opt in to it) in places where it wasn't expected.


> The problematic part, is, when you call code inside of coroutines, which
> is not safe to be run in parallel with other code.
>
> I.e. if you start writing code like `await([new Coroutine(fn() =3D>
> not_safe_to_run_twice()), new Coroutine(fn() =3D> not_safe_to_run_twice()=
)])`
> (pseudo code). Where not_safe_to_run_twice() shares some context.
>
> Well if you call await, you should be safe but that's not requirement
here. You can just spawn coroutine and main functions continues the flow to
other plugins that didn't opt in to async.

So, when you write async code, you have to *know* that the called code is
> allowed to run in parallel with any other code which you explicitly chose
> to run in parallel with it. E.g. if you'd run two wordpress functions whi=
ch
> don't have side-effects (not even to internal state), then you're perfect=
ly
> fine doing that. If you run wordpress functions in parallel which may jum=
p
> back to the scheduler during its operation and leave the internal state i=
n
> some intermittently invalid form, then yes, then you have a problem.
>

I'm not saying that is not possible to write safe code. This would be
perfectly possible and recommended, of course. The problem is that it
doesn't prohibit writing unsafe code in any way.


> But if your goal is to just do a localized parallelized operation which
> you know is safe to run in parallel - e.g. some image processing and
> storing some stuff in the database, within your wordpress plugin, that's
> absolutely fine. It won't break anything.
>
 Not sure if you worked with WordPress but if you want to query something,
it is often done through $wp_query global so it might actually not be
always safe if there is some IO done in between building the query.

> Essentially: Just don't call stuff in parallel which you don't know is
> safe to be called in parallel and you're golden.
>
That's, of course, correct advise but I'm not sure you realise that if
those rules are not somehow enforced, it will be most likely get ignored
and lead to problems that many people are worried about. Also it might not
be immediately obvious that something is safe because the change of state
might happen indirectly and be deeply nested.

Kind regards,

Jakub

--000000000000b78d7306442b562a
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>Hi Bob,</div><br><div class=3D"gmail_quote gmail_quot=
e_container"><div dir=3D"ltr" class=3D"gmail_attr">On Sat, Nov 22, 2025 at =
5:50=E2=80=AFAM Bob Weinand &lt;<a href=3D"mailto:bobwei9@hotmail.com">bobw=
ei9@hotmail.com</a>&gt; wrote:<br></div><blockquote class=3D"gmail_quote" s=
tyle=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);pad=
ding-left:1ex"><u></u>

 =20
  <div>
    <p>Hey Jakub,</p>
    <div>On 21.11.2025 12:29:16, Jakub Zelenka
      wrote:<br>
    </div>
    <blockquote type=3D"cite">
     =20
      <div dir=3D"ltr">
        <div>Hi,</div>
        <br>
        <div class=3D"gmail_quote">
          <div>I think you seriously underestimate impact of this in the
            current PHP code bases where many applications depend on
            global state. Especially the legacy ones but even the most
            popular ones. Just look into WordPress which use global
            state extensively. Now imagine that some popular plugin
            decides to use async which change some of its globals (like
            $post or $wp_query)=C2=A0during the suspension of the main code=
.
            I would assume this could horribly break things. Don&#39;t
            forget that other code don&#39;t have control over the plugin
            and it might not even know that async is used there. So I&#39;m
            not sure if this design is compatible with WordPress and
            similar applications where global state is used extensively.
            If that&#39;s the case, it&#39;s of course a problem because th=
ose
            applications (well WordPress on its own in fact) compose the
            majority of PHP users so introducing something that would
            have potential to break its code would limit usability of
            the whole feature and could even lead to loosing more users
            that we could gain from introducing this feature.</div>
          <div><br>
          </div>
          <div>So I think it will need to find some solution that will
            prevent this from happening. I guess there might be few
            options</div>
          <div><br>
          </div>
          <div>1. Disallow suspension of the main sync code which is
            effectively some sort of colouring.</div>
          <div>2. Preventing access to globals from coroutine which I&#39;m
            not sure is even fully doable from the engine PoV - it would
            mean some sort of different execution mode that could not
            use globals (e.g. global keyword and calling some functions
            that change global state). It would need channels for
            communications between coroutines. The advantage of such
            model would be possibility to combine it with threads in the
            future but I could imagine it could still lead to some
            subtle issue for years as there is internal global state as
            well that can lead to some surprises. But maybe that would
            be worth it.</div>
        </div>
      </div>
    </blockquote>
    <p>I think you seriously misunderstand this.</p>
    <p>Async does not allow you to introduce some effects from the
      outside. You have to actively opt-in to running stuff in parallel.=C2=
=A0</p></div></blockquote><div>But you don&#39;t have to opt in into it in =
this current form. If some external plugin calls spawn (without await), the=
n it can suspend other plugins (that didn&#39;t opt in to it) in places whe=
re it wasn&#39;t expected.</div><div>=C2=A0</div><blockquote class=3D"gmail=
_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204=
,204);padding-left:1ex"><div><p>The problematic part, is, when you call cod=
e inside of
      coroutines, which is not safe to be run in parallel with other
      code.</p>
    <p>I.e. if you start writing code like `await([new Coroutine(fn()
      =3D&gt; not_safe_to_run_twice()),=C2=A0new Coroutine(fn() =3D&gt;=C2=
=A0not_safe_to_run_twice())])`
      (pseudo code). Where=C2=A0not_safe_to_run_twice() shares some context=
.</p>
    <p></p></div></blockquote><div>Well if you call await, you should be sa=
fe but that&#39;s not requirement here. You can just spawn coroutine and ma=
in functions continues the flow to other plugins that didn&#39;t opt in to =
async.</div><div><br></div><blockquote class=3D"gmail_quote" style=3D"margi=
n:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex=
"><div><p>So, when you write async code, you have to *know* that the called
      code is allowed to run in parallel with any other code which you
      explicitly chose to run in parallel with it. E.g. if you&#39;d run tw=
o
      wordpress functions which don&#39;t have side-effects (not even to
      internal state), then you&#39;re perfectly fine doing that. If you ru=
n
      wordpress functions in parallel which may jump back to the
      scheduler during its operation and leave the internal state in
      some intermittently invalid form, then yes, then you have a
      problem.</p></div></blockquote><div><br></div><div>I&#39;m not saying=
 that is not possible to write safe code. This would be perfectly possible =
and recommended, of course. The problem is that it doesn&#39;t prohibit wri=
ting unsafe code in any way.</div><div>=C2=A0</div><blockquote class=3D"gma=
il_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,2=
04,204);padding-left:1ex"><div>
    <p>But if your goal is to just do a localized parallelized operation
      which you know is safe to run in parallel - e.g. some image
      processing and storing some stuff in the database, within your
      wordpress plugin, that&#39;s absolutely fine. It won&#39;t break anyt=
hing.</p></div></blockquote><div>=C2=A0Not sure if you worked with WordPres=
s but if you want to query something, it is often done through $wp_query gl=
obal so it might actually not be always safe if there is some IO done in be=
tween building the query.</div><blockquote class=3D"gmail_quote" style=3D"m=
argin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left=
:1ex"><div><p>
    </p>
    <p>Essentially: Just don&#39;t call stuff in parallel which you don&#39=
;t
      know is safe to be called in parallel and you&#39;re golden.</p></div=
></blockquote><div>That&#39;s, of course, correct advise but I&#39;m not su=
re you realise that if those rules are not somehow enforced, it will be mos=
t likely get ignored and lead to problems that many people are worried abou=
t. Also it might not be immediately obvious that something is safe because =
the change of state might happen indirectly and be deeply nested.</div><div=
><br></div><div>Kind regards,</div><div><br></div><div>Jakub</div></div></d=
iv>

--000000000000b78d7306442b562a--