STATE OF ASYNC PHP

Saad Bin Amjad

Technical Lead, Monstarlab Bangladesh

Agenda

1. Problem Statement

2. Asynchronous Concepts

3. Asynchronous Programming

4. Evolution of PHP

5. PHP State of Affairs

6. PHP Async Libraries and Frameworks

7. Laravel Octane

8. Follow up

Problem Statement

More people are online...

More than 5 billions of people now use the internet as of 2021.

Web applications need to be shipped out fast and efficiently that ensures best user experience.

Developer experience is top priority.

Utilising the advance of self hosted or cloud hardware capabilities.

Application Performance

Client side and server side

Client side need to load fast and be responsive.

Server side must be available and return quick responses, handle many requests at the same time, utilize hardware etc.

25+ years of PHP

Full Details are here: https://www.jetbrains.com/lp/php-25/

Do you need asynchronous PHP?

Michelin Stars

"exceptional cuisine that is worth a special journey"

"excellent cooking that is worth a detour"

"a very good restaurant"

"Michelin Stars" for Async PHP?

exceptional "pattern" that is worth a special journey

excellent "pattern" that is worth a detour

a very good "pattern"

Asynchronous Concepts

Links

The resources used, inspired from, and great reads for further reading will be pasted here at the bottom

Ramsey in 10

Task: Fish and Chips in 10 mins.

Ramsey in 10

Task: Fish and Chips in 10 mins.

One step at a time

1 Chef, 3 items to make, 1 pan + 1 oven available = 17 mins

Let's us all do this together

3 Chef, 9 items to make, 3 pan + 3 oven available = 17 mins

One might argue 17 / 3 = 6 mins for one.

Need to figure out when I am sitting idle?

Tasks

Tasks when I am free

Gordon Ramsey's way

1 Chef, 3 items to make, 1 pan + 1 oven available = 10 mins

Link:

https://www.youtube.com/watch?v=HrNLvCO2tE4

If we were all Gordon Ramsey

3 Chef, 9 items to make, 3 pan + 3 oven available = 10 mins

One might argue 10 / 3 = 3 mins for one.

So what we learn from Gordon Ramsey?

Understanding what blocks him from working.

Instead of doing all his tasks' serially, he plans his tasks.

He do multiple things at the same time , and never sits idle.

Thread

A thread is basically a single process that a program can use to complete tasks. Each thread can only do a single task at once.

Link::

https://www.youtube.com/watch?v=SpmnVDYwr_g&t=223s

Task

Execution

Planning

Communication

Access

Perspective

Execution

Serial

Each task will be run sequentially; a task has to complete before the next one can be started.

Parallel

Parallel execution is executing of items are carried out simultaneously.

Planning

Single Threaded

Each task will be run sequentially; a task has to complete before the next one can be started.

Multi-threaded

Multi-threading is the execution of multiple parts of a program at the same time.

We can multi-thread on the same CPU core, or we can multi-thread on different CPU cores.

Access

Monopoly

Access memory alone

Concurrent

Can access same memory concurrently

Communication

Synchronous

Happen in real-time, waits and then proceeds

Asynchronous

Over a period of time.

Event Loop

Uses single thread but handles blocking I/Os .

So how to be the Gordon Ramsey for web?

Serial: One step at a time

Parallel: Adding many servers

Asynchronous, doing something else while waiting.

What can be done better for this application's process?

Processor sits idle as we wait for file to be read etc.

Our OS can handle that.

But what about our server request handling, what can that process do while it is sitting idle?

Understanding what blocks the process from working.

Instead of doing all his tasks serially, there should be some planning,

Multiple things at the same time will ensure server serves more at a given time.

Asynchronous Programming

Cooking in PHP and Nodejs

Callbacks

One approach to asynchronous programming is to make functions that perform a slow action take an extra argument, a callback function.

The action is started, and when it finishes, the callback function is called with the result.

Links:

https://eloquentjavascript.net/11_async.html

https://nodejs.org/en/knowledge/getting-started/control-flow/what-are-callbacks/

Callback Hells

When you depend on result of an async call, and that in turns depends on another async call and ...

Links:

https://www.freecodecamp.org/news/how-to-deal-with-nested-callbacks-and-avoid-callback-hell-1bc8dc4a2012/

Promises

Solution to callback hell

A promise represents the eventual result of an asynchronous operation.

The primary way of interacting with a promise is through its then() method, which registers callbacks to receive either a promise's eventual value or the reason why the promise cannot be fulfilled.

Links:

https://jeromejaglale.com/doc/php/laravel_asynchronous_guzzle_requests_using_promises

Async/Await

Not in PHP or in any upcoming RFC.

Brings synchronicity to async model.

But in Guzzle's Promise you can synchronously force promises to complete using a promise's wait method. When creating a promise, you can provide a wait function that is used to synchronously force a promise to complete.

Generators

Generators are like the normal functions in PHP but instead of returning a value, they yields as many values as it needs to. So, whichever function that contains “yield” is a generator.

Functions to be paused and then resumed again.

Link:

https://eloquentjavascript.net/11_async.html

Coroutines

Ability to send values back to the generator.

This is useful in asynchronous applications, as the coroutine can suspend while waiting for some task to complete or information to arrive, and the CPU is free to perform other tasks.

Fiber

Lightweight thread of execution

It maintains its own stack (variables and state), that can be started, suspended, or terminated cooperatively by the main code and the Fiber.

These are also known as coroutines or green-threads.

Links:

https://www.zend.com/blog/swoole

https://php.watch/versions/8.1/fibers

Fibers vs Threads

Fibers are a lightweight threads but not threads, but called green threads.

Green threads are "user-level threads". They are scheduled by an "ordinary" user-level process, not by the kernel.

That means fibers are cooperatively scheduled. One fiber yield itself to allow another fiber to run.

Threads are preemptively scheduled, i.e a scheduling technique that works by dividing time slots of CPU to a given process.

Links:

https://graphitemaster.github.io/fibers/

Evolution of PHP

PHP Timeline

Full Details are here: https://www.jetbrains.com/lp/php-25/

PHP State of Affairs

How we work with PHP?

How PHP compiler works?

How PHP Servers works?

How we traditionally code async?

PHP CLI

Traditional Model

https://www.zend.com/blog/exploring-new-php-jit-compiler

PHP 8 JIT

Now with JIT

Just In Time compiler transforms Opcodes into an architecture-specific machine code using DynASM

(C Library).

CPU-intensive task that will benefit the most.

https://stitcher.io/blog/php-jithttps://www.zend.com/blog/exploring-new-php-jit-compiler

https://thephp.website/en/issue/php-8-jit/

PHP HHVM

Outdated now.

HHVM compiles Hack into an intermediate bytecode. This bytecode is then translated into x64 machine code dynamically at runtime by a just-in-time (JIT) compiler.

JIT

Execution (Native)

https://www.keycdn.com/blog/php-7-vs-hhvm

PHP FPM

Traditional PHP model, is the FastCGI server implementation of PHP, like Apache, Nginx.

https://geekflare.com/php-fpm-optimization/

https://www.programmersought.com/article/79284336180/https://tsh.io/blog/php-pm-guide-getting-started-with-the-process-manager/

PHP PPM

PHP Process Manager uses ReactPHP and Symfony components.

PHP-PM basically spawns several PHP instances as worker bootstraping your application (eg. the whole Symfony Kernel) and hold it in the memory to be prepared for every incoming request.

https://web.archive.org/web/20190103202024/http://marcjschmidt.de/2014/02/08/php-high-performance/

https://github.com/php-pm/php-pm

Swoole

Runs in CLI mode, like Nodejs.

Enables the application to keep on running in memory.

PHP servers runs in a stateful manner.

Master process is the entry

Reactor threads handle client and network I/O

Manager process decides how many wokers and task workers to spwan

Task workers are use for offloaded blocking I/Os.

https://www.zend.com/blog/exploring-new-php-jit-compiler

Roadrunner

Written in Golang. It runs php application in the form of workers.

Roadrunner works by creating a HTTP server with golang’s excellent net/http package, and using Goridge as a bridge between golang and PHP to pass PSR7 Request and Responses between PHP and golang

https://roadrunner.dev/docs/intro-about

How we do async in PHP development mostly?

Jobs/ Queues

I\O bound work to queue workers

We can use curl_multi_exec() to ensure we don't have to wait for the async calls. Guzzle library is pretty much good at this.

Though we have process Forking with PHP using pcntl_fork or pthreads, but all of this can't be used in webservers, this are only while using php command line client.

PHP Async Frameworks and Libraries

Frameworks and Libraries

Guzzle
https://docs.guzzlephp.org/en/stable/

Spatie

https://github.com/spatie/async

ReactPHP
https://reactphp.org/

Amp PHP
https://amphp.org/amp/

Swoole
https://www.swoole.co.uk/how-it-works

Octane
https://github.com/laravel/octane

Framework X [Upcoming]
https://github.com/clue/framework-x/

Benchmarking

Why is such?

https://www.zend.com/blog/swoole

Swoole Coroutines

Swoole provides the powerful CSP (Communicating sequential processes) programming model with three keywords: go, chan, defer.

CSP is an alternative concurrent programming model to the actor model in Erlang or Akka. It is well known because it is adopted in Golang

Laravel Octane

How does it work?

Keeps the bootstrapped application in memory

Utilizes this server: Swoole, Roadrunner

What it brings to the table?

Concurrent Tasks

Processed by Octane utilize Swoole's "task workers", and execute within an entirely different process than the incoming request.

Cache

When using Swoole, you may leverage the Octane cache driver, which provides read and write speeds of up to 2 million operations per second. And it is interval based.

Table

Define and interact with your own arbitrary Swoole tables. Swoole tables provide extreme performance throughput and the data in these tables can be accessed by all workers on the server.

https://laravel.com/docs/8.x/octane

What be careful of?

Dependency Injections

Octane will automatically handle resetting any first-party framework state between requests. However, Octane does not always know how to reset the global state created by your application.

Must avoid injecting the application service container, HTTP request instance and configuration repository instance into the constructors of other objects.

Memory Leaks

eg. Adding data to a statically maintained array will result in a memory leak.