IORING_SQ_NEED_WAKEUP does not honor sq_thread_idle. #947

ghost · 2023-09-09T20:06:58Z

ghost
Sep 9, 2023

I am using the low-level interface of io_uring, so this is unrelated to liburing. If there is a more suitable place for asking this question, I can close it.
Is it a correct assumption that when I use the IORING_ENTER_SQ_WAKEUP flag with the io_uring_enter call, IORING_SQ_NEED_WAKEUP will never be set within the sq_thread_idle time?
After calling io_uring_setup, I use IORING_ENTER_SQ_WAKEUP when calling io_uring_enter, which means that throughout the program, io_uring_enter is called at most once. My sq_thread_idle is set to 10,000, which is a long time. I then submit 4 sqe, which could be completed in less than a millisecond. However, not all four sqe are processed every time the program runs. I check the flags with

assert!(!flag!(flags, IORING_SQ_NEED_WAKEUP),"kernel thread idle");

each time I submit sqe, and sometimes IORING_SQ_NEED_WAKEUP appears, and I don't understand why.

axboe · 2023-09-09T21:28:47Z

axboe
Sep 9, 2023
Maintainer

This is missing the usual information, like what kernel you are running on. I wrote a quick test case for this and it works just fine for me:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <liburing.h>

enum {
	T_EXIT_PASS = 0,
	T_EXIT_SKIP = 77,
	T_EXIT_FAIL = 1,
};

static uint64_t utime_since(const struct timespec *s, const struct timespec *e)
{
	int64_t sec, usec;

	sec = e->tv_sec - s->tv_sec;
	usec = (e->tv_nsec - s->tv_nsec) / 1000;
	if (sec > 0 && usec < 0) {
		sec--;
		usec += 1000000;
	}

	/*
	 * time warp bug on some kernels?
	 */
	if (sec < 0 || (sec == 0 && usec < 0))
		return 0;

	return usec + (sec * 1000000);
}

static uint64_t utime_since_now(const struct timespec *s)
{
	struct timespec t;

	clock_gettime(CLOCK_MONOTONIC, &t);
	return utime_since(s, &t);
}

static int test(void)
{
	struct io_uring_cqe *cqe;
	struct io_uring_sqe *sqe;
	struct io_uring ring;
	struct io_uring_params p = { };
	struct timespec ts;

	p.flags = IORING_SETUP_SQPOLL;
	p.sq_thread_idle = 1000;
	io_uring_queue_init_params(4, &ring, &p);

	sqe = io_uring_get_sqe(&ring);
	io_uring_prep_nop(sqe);
	io_uring_submit(&ring);

	io_uring_wait_cqe(&ring, &cqe);

	clock_gettime(CLOCK_MONOTONIC, &ts);
	while (!(IO_URING_READ_ONCE(*(ring.sq.kflags)) & IORING_SQ_NEED_WAKEUP))
		;
	printf("IORING_SQ_NEED_WAKEUP set after %lu usec\n", utime_since_now(&ts));

	io_uring_queue_exit(&ring);
	return 0;
}

int main(int argc, char *argv[])
{
	int ret;

	if (argc > 1)
		return T_EXIT_SKIP;

	ret = test();
	if (ret) {
		fprintf(stderr, "test sqpoll failed\n");
		return T_EXIT_FAIL;
	}

	return T_EXIT_PASS;
}

xboe@m1max-kvm ~> gcc -Wall -O2 -o sq-sleep sq-sleep.c -luring
axboe@m1max-kvm ~> ./sq-sleep
IORING_SQ_NEED_WAKEUP set after 1002897 usec

Timing may be off a bit in general, it really depends on how the sqpoll loop is processing. But it should not be set much sooner than the specified time, it may trigger later than that however.

1 reply

ghost Sep 9, 2023

uname -a

Linux DEVELOP 6.4.14-200.fc38.x86_64 #1 SMP PREEMPT_DYNAMIC Sat Sep  2 16:36:06 UTC 2023 x86_64 GNU/Linux

ghost · 2023-09-09T22:50:06Z

ghost
Sep 9, 2023

6 replies

ghost Sep 10, 2023

I don't understand what went wrong exactly. IO_URING_READ_ONCE is just a relaxed load.Perhaps I need to test with a different kernel version.

ghost Sep 10, 2023

What Linux distribution are you using?

axboe Sep 10, 2023
Maintainer

I don't understand what went wrong exactly. IO_URING_READ_ONCE is just a relaxed load.Perhaps I need to test with a different kernel version.

I'd be highly surprised if the bug isn't in your code. Which is also why I asked you to test my example.

axboe Sep 10, 2023
Maintainer

What Linux distribution are you using?

That should not matter at all, but I'm on debian testing.

ghost Sep 10, 2023

you're right

IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~0 usec
IORING_SQ_NEED_WAKEUP set after 1000542 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~0 usec
IORING_SQ_NEED_WAKEUP set after 1000950 usec, expected ~1000000 usec

ghost · 2023-09-10T02:14:24Z

ghost
Sep 10, 2023

Have I misunderstood the SQPOLL mode? Why doesn't it work like this?

static int test(void)
{
	struct io_uring_cqe *cqe;
	struct io_uring_sqe *sqe;
	struct io_uring ring;
	struct io_uring_params p = { };

	p.flags = IORING_SETUP_SQPOLL | IORING_SETUP_SINGLE_ISSUER;
	p.sq_thread_idle = 1000;
	io_uring_queue_init_params(4, &ring, &p);

	wait_idle(&ring, "~0 usec");
	io_uring_enter(ring.ring_fd,0,0,IORING_ENTER_SQ_WAKEUP,0);
	while(1) {
		wait_idle(&ring, "~1000000 usec");
		io_uring_enter(ring.ring_fd,0,0,IORING_ENTER_SQ_WAKEUP,0);
	}
	
	io_uring_queue_exit(&ring);
	return 0;
}

IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~0 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 1100031 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 1000976 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 2299964 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 1000975 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~1000000 usec

0 replies

ghost · 2023-09-10T02:17:58Z

ghost
Sep 10, 2023

After each enter, it should at least wait for one second before going to sleep, right?
@axboe

0 replies

ghost · 2023-09-10T21:25:17Z

ghost
Sep 10, 2023

use rustring::{Ring, wait_idle};

fn main() {
    let mut ring = Ring::new(8);

    wait_idle(&ring, "~0 usec");

    ring.start_nop(1);
    dbg!(ring.wait());

    wait_idle(&ring, "~1000000 usec");
    wait_idle(&ring, "~0 usec");

    ring.start_nop(2);
    dbg!(ring.wait());

    wait_idle(&ring, "~1000000 usec");
}

IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~0 usec
enter!
[src/main.rs:9] ring.wait() = 1
IORING_SQ_NEED_WAKEUP set after 1000391 usec, expected ~1000000 usec
IORING_SQ_NEED_WAKEUP set after 0 usec, expected ~0 usec
enter!
[src/main.rs:15] ring.wait() = 2
IORING_SQ_NEED_WAKEUP set after 1000974 usec, expected ~1000000 usec

0 replies

ghost · 2023-09-10T21:26:22Z

ghost
Sep 10, 2023

fn main() {
    let mut ring = Ring::new(8);

    ring.start_nop(1);
    ring.start_nop(2);
    ring.start_nop(3);
    ring.start_nop(4);
    dbg!(ring.wait());
    dbg!(ring.wait());
    dbg!(ring.wait());
    dbg!(ring.wait());
}

enter!
enter!
enter!
[src/main.rs:10] ring.wait() = 1
[src/main.rs:11] ring.wait() = 2
[src/main.rs:12] ring.wait() = 3
[src/main.rs:13] ring.wait() = 4

0 replies

ghost · 2023-09-10T21:26:39Z

ghost
Sep 10, 2023

@axboe

0 replies

ghost · 2023-09-10T21:35:14Z

ghost
Sep 10, 2023

It has nothing to do with your test cases. I just want to know why wait_idle returns immediately after wakeup instead of waiting for one second.

0 replies

axboe · 2023-09-11T13:33:00Z

axboe
Sep 11, 2023
Maintainer

The way SQPOLL works is that it'll busy loop for sq_thread_idle time waiting on new requests to show up in the SQ ring. If that amount of time passes without processing a request, it'll go to sleep and set the IORING_SQ_NEED_WAKEUP. Your test case isn't submitting any requests, so it's basically just busy looping until the timeout is hit, and then woken when you do the syscall with WAKE set. Doing a syscall with WAKE set with the thread looping on new requests does NOT reset the timeout, so you just get some odd behavior with your test case as it isn't a valid use case at all. We could obviously have a WAKE reset the timeout, but it seems pretty pointless as no application would use it like that.

Outside of that, it's the SQPOLL thread itself that both sets and clears the IORING_SQ_NEED_WAKEUP flag. This means that if you do do an enter syscall with WAKE set and the thread is sleeping, you may still see the flag being set until the thread wakes up and clears it.

0 replies

ghost · 2023-09-12T06:51:41Z

ghost
Sep 12, 2023

I believe that sq.flag should not be synchronized with anything else. As long as I get NEED_WAKEUP from sq.flag, I should call ENTER_WAKEUP. This is unrelated to whether I am currently submitting sqe, because I don't know how to handle the synchronization between sqe submission and sq.flag.

1 reply

axboe Sep 12, 2023
Maintainer

It's not unrelated to whether or not you're currently submitting, if you have nothing to submit, there's no point checking the flag or setting ENTER_WAKEUP when you call io_uring_enter(). The only thing you'd call it for at that point would be to wait for CQ entries, which don't need the SQPOLL thread running.

ghost · 2023-09-12T07:18:48Z

ghost
Sep 12, 2023

the application needs to check the SQ flags for IORING_SQ_NEED_WAKEUP after updating the SQ tail; a full memory barrier smp_mb() is needed between.

I mean, if the sqpoll thread runs as I want it to, we don't need that memory barrier.

0 replies

ghost · 2023-09-16T00:01:24Z

ghost
Sep 16, 2023

To summarize:

The sqpoll thread refreshes the timer when processing sqe, so it must be ensured that the sqpoll thread is awakened after the sqe is submitted.
After awakening the sqpoll thread, the NEED_WAKEUP flag is cleared by the sqpoll thread itself, so it cannot be cleared immediately after awakening.

The issue here is that in my test case, no sqe is submitted, but the timer refreshes. Is this some kind of undefined behavior?

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

IORING_SQ_NEED_WAKEUP does not honor sq_thread_idle. #947

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 12 comments 8 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

IORING_SQ_NEED_WAKEUP does not honor sq_thread_idle. #947

Replies: 12 comments · 8 replies

axboe Sep 9, 2023 Maintainer

axboe Sep 10, 2023 Maintainer

axboe Sep 10, 2023 Maintainer

axboe Sep 11, 2023 Maintainer

axboe Sep 12, 2023 Maintainer

Replies: 12 comments 8 replies

axboe
Sep 9, 2023
Maintainer

axboe Sep 10, 2023
Maintainer

axboe Sep 10, 2023
Maintainer

axboe
Sep 11, 2023
Maintainer

axboe Sep 12, 2023
Maintainer