1. 09 12月, 2021 1 次提交
  2. 08 12月, 2021 3 次提交
  3. 05 12月, 2021 4 次提交
  4. 29 11月, 2021 1 次提交
  5. 26 11月, 2021 2 次提交
  6. 25 11月, 2021 4 次提交
  7. 24 11月, 2021 4 次提交
  8. 08 11月, 2021 1 次提交
  9. 05 11月, 2021 1 次提交
  10. 03 11月, 2021 1 次提交
  11. 02 11月, 2021 1 次提交
  12. 29 10月, 2021 1 次提交
    • J
      io_uring: harder fdinfo sq/cq ring iterating · f75d1183
      Jens Axboe 提交于
      The ring iteration is racy, which isn't necessarily a problem except it
      can cause us to iterate the whole thing. That isn't desired or ideal,
      and it can lead to excessive runtimes of reading fdinfo.
      
      Cap the iteration at tail - head OR the ring size. While in there, clean
      up the ring masking and just dump the raw values along with the masks.
      That provides more useful debug info.
      
      Fixes: 83f84356 ("io_uring: add more uring info to fdinfo for debug")
      Reported-by: NEric Dumazet <edumazet@google.com>
      Signed-off-by: NJens Axboe <axboe@kernel.dk>
      f75d1183
  13. 27 10月, 2021 1 次提交
  14. 26 10月, 2021 1 次提交
  15. 25 10月, 2021 7 次提交
  16. 23 10月, 2021 1 次提交
    • H
      io_uring: implement async hybrid mode for pollable requests · 90fa0288
      Hao Xu 提交于
      The current logic of requests with IOSQE_ASYNC is first queueing it to
      io-worker, then execute it in a synchronous way. For unbound works like
      pollable requests(e.g. read/write a socketfd), the io-worker may stuck
      there waiting for events for a long time. And thus other works wait in
      the list for a long time too.
      Let's introduce a new way for unbound works (currently pollable
      requests), with this a request will first be queued to io-worker, then
      executed in a nonblock try rather than a synchronous way. Failure of
      that leads it to arm poll stuff and then the worker can begin to handle
      other works.
      The detail process of this kind of requests is:
      
      step1: original context:
                 queue it to io-worker
      step2: io-worker context:
                 nonblock try(the old logic is a synchronous try here)
                     |
                     |--fail--> arm poll
                                  |
                                  |--(fail/ready)-->synchronous issue
                                  |
                                  |--(succeed)-->worker finish it's job, tw
                                                 take over the req
      
      This works much better than the old IOSQE_ASYNC logic in cases where
      unbound max_worker is relatively small. In this case, number of
      io-worker eazily increments to max_worker, new worker cannot be created
      and running workers stuck there handling old works in IOSQE_ASYNC mode.
      
      In my 64-core machine, set unbound max_worker to 20, run echo-server,
      turns out:
      (arguments: register_file, connetion number is 1000, message size is 12
      Byte)
      original IOSQE_ASYNC: 76664.151 tps
      after this patch: 166934.985 tps
      Suggested-by: NJens Axboe <axboe@kernel.dk>
      Signed-off-by: NHao Xu <haoxu@linux.alibaba.com>
      Link: https://lore.kernel.org/r/20211018133445.103438-1-haoxu@linux.alibaba.comSigned-off-by: NJens Axboe <axboe@kernel.dk>
      90fa0288
  17. 22 10月, 2021 1 次提交
  18. 20 10月, 2021 4 次提交
  19. 19 10月, 2021 1 次提交