[english] | [한국어 (korean)]

Python wrapper module that uses Linux Kernel AIO directly

Linux IO Models table

In summary, it allows non-blocking and asynchronous use of blocking IO operations such as read(2) and write(2).

• Linux Asynchronous I/O
• Linux Kernel AIO Design Notes
• How to use the Linux AIO feature (in C)

The POSIX AIO APIs have the aio_ prefix, but the Linux Kernel AIO has the io_ prefix.

There is already a POSIX AIO API for asynchronous I/O, but Linux implements it in glibc, a user-space library, which is supposed to use multi-threading internally. So, as you can see from the experiment below, it's much worse than using the blocking IO API.

• Implemented based on linux_aio_bind package which is low-level binding of Linux kernel AIO.
• Unlike linux_aio_bind, it can be used without knowledge of ctypes
• Examples can be found in the code in the test directory.

Examples can be found in the code in the test directory.

• Obviously available only on Linux
• Because it is a wrapper, it brings the constraints of Linux.
  • It can not be used for files used as a kernel interface. (e.g. cgroup)
  • Sometimes it works as Blocking.
    • There are some things that have been solved through development after posting.
  • Some features are being added because they are still under development.
  • There are also some features that are not supported when the Linux version is low
    • You need to check Linux man pages (4.16) and its related API documentation

Experiment script (requires python 3.7)

• Distribution: Ubuntu Server 16.04.5 LTS

• Linux: 4.19.0

• CPU: 2-way Intel(R) Xeon(R) CPU E5-2683 v4 @ 2.10GHz

• MEM: total 64GB

• Storage: SK hynix SC300B SATA 512GB

• Python: 3.7.2 (Ubuntu ppa)

• Attempts to read a total of 1000 times in 1ms intervals.

• The file size varies from 1KB to 100KB, but it is small.

• Experiment with increasing the number of files read at the same time

• Because we have experimented with high-performance server, there may be larger performance differences when testing on a typical desktop.

• aiofiles - Uses Thread pool
• aiofile - Uses POSIX AIO
• libaio - Uses libaio
• python built-in open()

It is not a perfectly fair comparison.

aiofiles and aiofile are libraries that support asyncio. Since open() is blocking, there is a disadvantage that you can not do any other work while IO is going on. libaio and linux_aio are non-blocking, but must be polled.

It may differ from environment to environment.

• Unit: second

• Physical memory (Virtual memory)