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

linux_aio: Python wrapper for Linux Kernel AIO

Python wrapper module that uses Linux Kernel AIO directly

What is Linux Kernel AIO?

Linux IO Models table

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

Related documents

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

It is different from POSIX AIO

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.

Implementation & Structure

Package linux_aio

• 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.

Example

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

Notes & Limits

• 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

Evaluation

Experiment script (requires python 3.7)

Setup

• 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 in1ms intervals.
• The file size varies from 1KB to100KB, 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.

Comparison target

• 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.

Results

It may differ from environment to environment.

Runtime

• Unit: second

Threads

Memory

• Physical memory (Virtual memory)

CPU Utilization