Problem about sq->khead update and ring full judgement

[Ferry Meng <mengferry@linux.alibaba.com>]

Hi all:
     I'm using io_uring in a program, with SQPOLL feature enabled. The 
userspace program will actively count the queue status of urings, the 
programming model is similar to:
     {
         sqe = io_uring_get_sqe();
         if(sqe){
             /* prepare next request */
             queue_count++;
     }


     {
         cqe = io_uring_peek_cqe();
         if(cqe){
             queue_count--;
         }
     }

     In this way, maybe we can assume that " sq_ring_size - queue_count 
= sqe_left_we_can_alloc "?

     Userspace program will compare queue_count with io_uring's sq_size 
: if queue is not full ( queue_count < sq_size), it will try getting new 
sqe(means Initiating a new IO request).

     Now I'm currently coming into a situation where  I/O is very high 
—— Userspace program submit lots of sqes (around 2000) at the same time, 
meanwhile  sq_ring_size is 4096. In kernel, 
__io_sq_thread->io_submit_sqes(), I see that nr(to_submit) is also over 
2000.   At a point, a strange point comes out: Userspace program find 
sq_ring is not full, but Kernel(in fact liburing::io_uring_get_sqe) 
think sq_ring is full.

     After analyzing, I find the reason is: kernel update "sq->khead" 
after submitting "all" sqes. The running of my program is : Before 
kernel update khead, userspace program has received many cqes, causing 
queue_count-- . After decreasing queue_count, user-program thinks 
sq_ring is not full, and try to start new IO requeust. As sq->head is 
not updated, io_uring_get_sqe() returns NULL.

     My questions are:

     1. Is userspace 'queue_count' judgement reasonable? From 
'traditional' point of view, if we want to find sq_ring full or not, we 
can just use io_uring_get_sqe() to check. Maybe this discussion is 
similar to this issue in a way: https://github.com/axboe/liburing/issues/88

     2. I must confess that it's very strange that cqe's average 
receiving latency is shorter than the consumption time of sqe(Now it 
really happens and I'm trying to find why this happened, or it's a just 
some bug). Assuming this scenario is reasonable, it seems that we can 
update sq->khead more often to get higher throughput. When userspace 
gets more 'sensetive', it can send out more IO requests. And it won't 
cause much more overhead if kernel atomically update 'khead' 
a-little-bit more.