Skip to contentSkip to conversation

fast poll multishot mode

PATCH Superseded Hao Xu 1 participant 2 messages May 7, 2022 io_uring

v3 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Hao Xu

author
#0 lore raw

v3 cover fast poll multishot mode

Let multishot support multishot mode, currently only add accept as its first comsumer.
theoretical analysis:
1) when connections come in fast

    - singleshot:
              add accept sqe(userpsace) --> accept inline
                              ^                 |
                              |-----------------|
    - multishot:
             add accept sqe(userspace) --> accept inline
                                              ^     |
                                              |--*--|

    we do accept repeatedly in * place until get EAGAIN

2) when connections come in at a low pressure
similar thing like 1), we reduce a lot of userspace-kernel context switch and useless vfs_poll()

tests:
Did some tests, which goes in this way:

  server    client(multiple)
  accept    connect
  read      write
  write     read
  close     close

Basically, raise up a number of clients(on same machine with server) to connect to the server, and then write some data to it, the server will write those data back to the client after it receives them, and then close the connection after write return. Then the client will read the data and then close the connection. Here I test 10000 clients connect one server, data size 128 bytes. And each client has a go routine for it, so they come to the server in short time.
test 20 times before/after this patchset, time spent:(unit cycle, which is the return value of clock())
before:
1930136+1940725+1907981+1947601+1923812+1928226+1911087+1905897+1941075 +1934374+1906614+1912504+1949110+1908790+1909951+1941672+1969525+1934984 +1934226+1914385)/20.0 = 1927633.75
after:
1858905+1917104+1895455+1963963+1892706+1889208+1874175+1904753+1874112 +1874985+1882706+1884642+1864694+1906508+1916150+1924250+1869060+1889506 +1871324+1940803)/20.0 = 1894750.45

(1927633.75 - 1894750.45) / 1927633.75 = 1.65%

A liburing test is here:
https://github.com/HowHsu/liburing/blob/multishot_accept/test/accept.c

v1->v2:
- re-implement it against the reworked poll code

v2->v3:
- fold in code tweak and clean from Jens
- use io_issue_sqe rather than io_queue_sqe, since the former one return the internal error back which makes more sense
- remove io_poll_clean() and its friends since they are not needed

Hao Xu (4):
io_uring: add IORING_ACCEPT_MULTISHOT for accept
io_uring: add REQ_F_APOLL_MULTISHOT for requests
io_uring: let fast poll support multishot
io_uring: implement multishot mode for accept

 fs/io_uring.c                 | 94 +++++++++++++++++++++++++++--------
 include/uapi/linux/io_uring.h |  5 ++
 2 files changed, 79 insertions(+), 20 deletions(-)

base-commit: 0a194603ba7ee67b4e39ec0ee5cda70a356ea618

Signature · 1 line
2.36.0
author
#1 lore raw

Something wrong with my git sendemail, trying to fix it. Please ignore this...

Quoted 75 lines · Hao Xu

Let multishot support multishot mode, currently only add accept as its first comsumer.
theoretical analysis:
1) when connections come in fast

     - singleshot:
               add accept sqe(userpsace) --> accept inline
                               ^                 |
                               |-----------------|
     - multishot:
              add accept sqe(userspace) --> accept inline
                                               ^     |
                                               |--*--|

     we do accept repeatedly in * place until get EAGAIN

2) when connections come in at a low pressure
similar thing like 1), we reduce a lot of userspace-kernel context switch and useless vfs_poll()

tests:
Did some tests, which goes in this way:

   server    client(multiple)
   accept    connect
   read      write
   write     read
   close     close

Basically, raise up a number of clients(on same machine with server) to connect to the server, and then write some data to it, the server will write those data back to the client after it receives them, and then close the connection after write return. Then the client will read the data and then close the connection. Here I test 10000 clients connect one server, data size 128 bytes. And each client has a go routine for it, so they come to the server in short time.
test 20 times before/after this patchset, time spent:(unit cycle, which is the return value of clock())
before:

   1930136+1940725+1907981+1947601+1923812+1928226+1911087+1905897+1941075
   +1934374+1906614+1912504+1949110+1908790+1909951+1941672+1969525+1934984
   +1934226+1914385)/20.0 = 1927633.75
after:
   1858905+1917104+1895455+1963963+1892706+1889208+1874175+1904753+1874112
   +1874985+1882706+1884642+1864694+1906508+1916150+1924250+1869060+1889506
   +1871324+1940803)/20.0 = 1894750.45

(1927633.75 - 1894750.45) / 1927633.75 = 1.65%

A liburing test is here:
https://github.com/HowHsu/liburing/blob/multishot_accept/test/accept.c

v1->v2:
- re-implement it against the reworked poll code

v2->v3:
- fold in code tweak and clean from Jens
- use io_issue_sqe rather than io_queue_sqe, since the former one return the internal error back which makes more sense
- remove io_poll_clean() and its friends since they are not needed

Hao Xu (4):
io_uring: add IORING_ACCEPT_MULTISHOT for accept
io_uring: add REQ_F_APOLL_MULTISHOT for requests
io_uring: let fast poll support multishot
io_uring: implement multishot mode for accept

  fs/io_uring.c                 | 94 +++++++++++++++++++++++++++--------
  include/uapi/linux/io_uring.h |  5 ++
  2 files changed, 79 insertions(+), 20 deletions(-)

base-commit: 0a194603ba7ee67b4e39ec0ee5cda70a356ea618