# io_uring_submit_and_wait_min_timeout

## NAME



           io_uring_submit_and_wait_min_timeout - submit requests to the
           submission queue and wait for the completion with both batch and
           normal timeout
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **int io_uring_submit_and_wait_min_timeout(struct io_uring ***_ring_**,**
                                                    **struct io_uring_cqe ****_cqe_ptr_**,**
                                                    **unsigned** _wait_nr_**,**
                                                    **struct __kernel_timespec ***_ts_**,**
                                                    **unsigned int** _min_wait_usec_**,**
                                                    **sigset_t ***_sigmask_**);**
    


## DESCRIPTION



           The io_uring_submit_and_wait_min_timeout(3) function submits the
           next requests from the submission queue belonging to the _ring_ and
           waits for _wait_nr_ completion events, or until the timeout _ts_
           expires. The completion events are stored in the _cqe_ptr_ array. If
           non-zero, _min_wait_usec_ denotes a timeout for the _wait_nr_ batch.
    
           The _sigmask_ specifies the set of signals to block. If set, it is
           equivalent to atomically executing the following calls:
    
               sigset_t origmask;
    
               pthread_sigmask(SIG_SETMASK, &sigmask, &origmask);
               ret = io_uring_submit_and_wait_min_timeout(ring, cqe, wait_nr, ts, min_wait, NULL);
               pthread_sigmask(SIG_SETMASK, &origmask, NULL);
    
           This works like io_uring_submit_and_wait_timeout(3) with the twist
           that it applies a minimum timeout for the requested batch size of
           requests to wait for. While io_uring_submit_and_wait_timeout(3)
           waits for as long as _ts_ specifies, or until _wait_nr_ of request
           completions have been received, if _min_wait_usec_ is set, then this
           is the timeout for the _wait_nr_ number of requests. If the
           requested number of completions have been received within
           _min_wait_usec_ number of microseconds, then the function returns
           successfully. If that isn't the case, once _min_wait_usec_ time has
           passed, control is returned if any completions have been posted.
           If no completions have been posted, the kernel switches to a
           normal wait of up to _ts_ specified amount of time, subtracting the
           time already waited. If any completions are posted after this
           happens, control is returned immediately to the application.
    
           This differs from the normal timeout waiting in that waiting
           continues post the initial timeout, if and only if no completions
           have been posted. It's meant to be used to optimize batch waiting
           for requests, where the application allots a budget of
           _min_wait_usec_ amount of time to receive _wait_nr_ number of
           completions, but if none are received, then waiting can continue
           without incurring extra context switches or extra kernel/user
           transitions.
    
           Can be used with any ring, as long as the kernel supports it.
           Support is indicated by checking the **IORING_FEAT_MIN_TIMEOUT**
           feature flag after the ring has been setup. Ideally used with a
           ring setup with
           **IORING_SETUP_SINGLE_ISSUER** |**IORING_SETUP_DEFER_TASKRUN** as that will
           greatly reduce the number of context switches that an application
           will see waiting on multiple requests.
    
           Available since 6.12.
    


## RETURN VALUE



           On success io_uring_submit_and_wait_min_timeout(3) returns the
           number of submitted submission queue entries. On failure it
           returns **-errno**.  If the kernel doesn't support this functionality,
           **-EINVAL** will be returned. See note on the feature flag.  The most
           common failure case is not receiving a completion within the
           specified timeout, **-ETIME** is returned in this case.
    


* * *