Single Read

[YoSTEALTH]

Sometimes you want to do just 1 time read. Currently with io_uring you can do this with multiple steps: 1. open, 2. read + 3.close

I did a simple benchmark

# Python
with open('/dev/random', 'rb') as file:
    data = file.read(1024)

Python
------------------------------
Total Time: 0.0000777409986767

io_uring
------------------------------
Total Time: 0.0003582930003176

Its not the fact that python is faster than io_uring its just loosing a lot of time in event loop steps.

I was thinking maybe this can be solved with register_files + linking open_direct + read_fixed + close_direct still those lose out as well in complexity!

What do you think?

[krisman]

I'm not sure I got your point, so please point it out if I didn't.

Sometimes you want to do just 1 time read. Currently with io_uring you can do this with multiple steps: 1. open, 2. read + 3.close

Python is also doing the three steps open-read-close. it is just done through syscalls and hidden by the interpreter.

Its not the fact that python is faster than io_uring its just loosing a lot of time in event loop steps.

IMO The value of io_uring is in 1) the asynchronous model of execution; 2) reduction of system calls, which are way more expensive due to all the speculation mitigations. In the case you point out, you are not really benefiting from (1) since the work is essentially synchronous in this case. Finally, it is kind of an unfair comparison since the overhead of setting up io_uring (assuming you didn't disregard it) and pushing a request down its stack is going to dominate the cost over doing the read/write syscall synchronously against small, readily available data.

I was thinking maybe this can be solved with register_files + linking open_direct + read_fixed + close_direct still those lose out as well in complexity!

The complexity is abstractable away by a library/framework like python. it would be a bit of apple-to-oranges to compare the two, no?

[YoSTEALTH]

Thanks @krisman for your comment.

Complexity with register_files is:

• you have to manage the fds
• needing to know which index to use
• register itself is a syscall.

After wrapping the whole register_files in Python you pretty much lose out on any speed advantage you would have gotten by just the whole management process itself vs passing normal fd around. Maybe in large amount of registered fds there might be an advantage!

Let me try to explain better... Also I am not trying to put io_uring down here, in-fact io_uring has a HUGE advantage its not utilizing on.

with open('/dev/random', 'rb') as file:
    data = file.read(1024)

Using above example Python has few disadvantage

• 3 syscall for:
  • open
  • read
  • close
• and its blocking

What if io_uring had a function like this that does 3 things (open, read, close) in 1?

# open, read, close
io_uring_prep_single_read(sqe, '/dev/random', buffer, buffer_length)

Now with io_uring you can do 1-syscall, and still has asynchronous advantage. This is something Python can't do, having OS run 3 functions using 1 syscall, But io_uring can do this, and thus could take advantage over synchronous area as well.