Swow is a high-performance pure coroutine network communication engine written in PHP and Cwhich is committed to using a minimal C core and most PHP code to support PHP high-performance web programming.

Project original intention

Although the PHP coroutine ecology now has a very diverse selection, all coroutine frameworks and libraries have a very fatal problem, that is, they all evolved from asynchronous frameworks, not bottom-up for coroutines. Due to some compatibility considerations, many capabilities that should be possessed are often sacrificed, or reasonable design changes cannot be made due to historical burdens.

Therefore, the Swow project is committed to creating a high-performance, highly controllable, and easily compatible engine designed for coroutines from the bottom up. Relying on the advantages of architecture design, it will fully release the true strength of coroutine technology. This is the original intention of Swow and its team members. We will continue to invest and work hard for this, and you are welcome to join us to participate in open source construction.

design concept

Swow’s minimum C core design determines that it is more about pursuing secondary development capabilities and debuggability in addition to ensuring key performance.

The seamless integration of Swow kernel and PHP code greatly improves the developer’s programming efficiency and flexibility.

Swow provides a variety of debugging mechanisms and powerful and low-threshold debugging capabilities to ensure that developers are free from bugs to the greatest extent. Ordinary developers can also have near-expert-level DEBUG capabilities through the blessing of tools.

thank you

Written before the introduction of capabilities: The development of PHP high-performance coroutine network communication engine has a long way to go. This is an open source work that is too high. I am very grateful to the following partners for their code contributions to the Swow project. Without everyone, there would be no current Swow ! Among them, we would like to thank @dixyes, the core member of the team, for his dedication, which has raised the capabilities and stability of Swow to a whole new level!

Supported OS

[^other-platforms]: Other system support depends on libuv support and community needs

coroutine

C stack coroutine implementation

[^boost-context-tier-1]: First-class support means that members of the Swow development team will submit code contributions to boost-context to better support the application scenarios required by Swow.

Coroutine model

Coroutine control ability

coroutine debugger

Coroutine debugger capability

[^gdb-print]: Equivalent to the print command of GDB, dynamically execute the expression given by the debugger, and print its return value.

aisle

The core effective code is less than 300 lines, and the unit test coverage rate is 100%.

Synchronize

event

[^libcat]: libcat is the coroutine version of libuv, which is independently maintained by the Swow team and can be used by all C-based projects. For example, you can use libcat to write a C++ coroutine project, or provide C stack coroutine capabilities for Python and Node.js Wait.

[^libuv]: The asynchronous event driver of libuv provides mainstream full-platform support, has passed extensive and rigorous production verification in languages ​​such as Node.js and Julia, and has reached industrial-grade standards. The Swow team will submit code contributions to libuv to make it better support the application scenarios required by Swow.

Signal

network programming

With the help of the minimal capability provided by the underlying core of Swow, a high-performance API gateway can be realized by writing PHP code. The specific project practice content and production environment verification sharing, please look forward to the follow-up Twitter update of the official Swow team!

synchronous blocking coroutine

[^not-supported-yet]: Not supported at the moment means that it will be supported in the future, or it is already in the implementation plan

Benefits of this technology:

CPU scheduling

Watchdog provides CPU scheduling capabilities for PHP. The core principle is that the Watchdog thread will periodically check the activity of the coroutines in other threads. If it is found that the coroutines in the worker threads are no longer active, they will be checked through the interrupt mechanism of ZendVM. Confirm that if the VM interrupt fails, it indicates that the worker thread is blocked by a system call and triggers an alarm; if the VM interrupt succeeds, it indicates that the worker thread is caught in CPU-intensive operations or an infinite loop, and immediately triggers the scheduling rules set by the user for scheduling.

modernization

Other debugging capabilities

build system

[^hyperf-box]: Hyperf Box provides out-of-the-box one-click packaging binary tools for the Swow project, and more open source community partners are welcome to re-develop more out-of-the-box packaging tools based on micro technology to benefit the community.

More

The above capability enumeration is just the beginning of Swow. The Swow core also contains a lot of detailed design and some experimental functions that have not been officially disclosed.

In general, the future of Swow is full of imagination. It provides PHP with possibilities far beyond the past. We can use Swow’s ability to think and do more things that have never been thought about.

In the future, we will share with you the detailed description and best practices of each capability item in detail by “publishing a large number of short articles”, and disclose a large number of internal implementation details and production applications, so stay tuned!