826cc32423
Adaptive polling measures the execution time of the polling check plus handlers called when a polled event becomes ready. Handlers can take a significant amount of time, making it look like polling was running for a long time when in fact the event handler was running for a long time. For example, on Linux the io_submit(2) syscall invoked when a virtio-blk device's virtqueue becomes ready can take 10s of microseconds. This can exceed the default polling interval (32 microseconds) and cause adaptive polling to stop polling. By excluding the handler's execution time from the polling check we make the adaptive polling calculation more accurate. As a result, the event loop now stays in polling mode where previously it would have fallen back to file descriptor monitoring. The following data was collected with virtio-blk num-queues=2 event_idx=off using an IOThread. Before: 168k IOPS, IOThread syscalls: 9837.115 ( 0.020 ms): IO iothread1/620155 io_submit(ctx_id: 140512552468480, nr: 16, iocbpp: 0x7fcb9f937db0) = 16 9837.158 ( 0.002 ms): IO iothread1/620155 write(fd: 103, buf: 0x556a2ef71b88, count: 8) = 8 9837.161 ( 0.001 ms): IO iothread1/620155 write(fd: 104, buf: 0x556a2ef71b88, count: 8) = 8 9837.163 ( 0.001 ms): IO iothread1/620155 ppoll(ufds: 0x7fcb90002800, nfds: 4, tsp: 0x7fcb9f1342d0, sigsetsize: 8) = 3 9837.164 ( 0.001 ms): IO iothread1/620155 read(fd: 107, buf: 0x7fcb9f939cc0, count: 512) = 8 9837.174 ( 0.001 ms): IO iothread1/620155 read(fd: 105, buf: 0x7fcb9f939cc0, count: 512) = 8 9837.176 ( 0.001 ms): IO iothread1/620155 read(fd: 106, buf: 0x7fcb9f939cc0, count: 512) = 8 9837.209 ( 0.035 ms): IO iothread1/620155 io_submit(ctx_id: 140512552468480, nr: 32, iocbpp: 0x7fca7d0cebe0) = 32 174k IOPS (+3.6%), IOThread syscalls: 9809.566 ( 0.036 ms): IO iothread1/623061 io_submit(ctx_id: 140539805028352, nr: 32, iocbpp: 0x7fd0cdd62be0) = 32 9809.625 ( 0.001 ms): IO iothread1/623061 write(fd: 103, buf: 0x5647cfba5f58, count: 8) = 8 9809.627 ( 0.002 ms): IO iothread1/623061 write(fd: 104, buf: 0x5647cfba5f58, count: 8) = 8 9809.663 ( 0.036 ms): IO iothread1/623061 io_submit(ctx_id: 140539805028352, nr: 32, iocbpp: 0x7fd0d0388b50) = 32 Notice that ppoll(2) and eventfd read(2) syscalls are eliminated because the IOThread stays in polling mode instead of falling back to file descriptor monitoring. As usual, polling is not implemented on Windows so this patch ignores the new io_poll_read() callback in aio-win32.c. Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> Reviewed-by: Stefano Garzarella <sgarzare@redhat.com> Message-id: 20211207132336.36627-2-stefanha@redhat.com [Fixed up aio_set_event_notifier() calls in tests/unit/test-fdmon-epoll.c added after this series was queued. --Stefan] Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
74 lines
2.0 KiB
C
74 lines
2.0 KiB
C
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
/*
|
|
* fdmon-epoll tests
|
|
*
|
|
* Copyright (c) 2020 Red Hat, Inc.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "block/aio.h"
|
|
#include "qapi/error.h"
|
|
#include "qemu/main-loop.h"
|
|
|
|
static AioContext *ctx;
|
|
|
|
static void dummy_fd_handler(EventNotifier *notifier)
|
|
{
|
|
event_notifier_test_and_clear(notifier);
|
|
}
|
|
|
|
static void add_event_notifiers(EventNotifier *notifiers, size_t n)
|
|
{
|
|
for (size_t i = 0; i < n; i++) {
|
|
event_notifier_init(¬ifiers[i], false);
|
|
aio_set_event_notifier(ctx, ¬ifiers[i], false,
|
|
dummy_fd_handler, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
static void remove_event_notifiers(EventNotifier *notifiers, size_t n)
|
|
{
|
|
for (size_t i = 0; i < n; i++) {
|
|
aio_set_event_notifier(ctx, ¬ifiers[i], false, NULL, NULL, NULL);
|
|
event_notifier_cleanup(¬ifiers[i]);
|
|
}
|
|
}
|
|
|
|
/* Check that fd handlers work when external clients are disabled */
|
|
static void test_external_disabled(void)
|
|
{
|
|
EventNotifier notifiers[100];
|
|
|
|
/* fdmon-epoll is only enabled when many fd handlers are registered */
|
|
add_event_notifiers(notifiers, G_N_ELEMENTS(notifiers));
|
|
|
|
event_notifier_set(¬ifiers[0]);
|
|
assert(aio_poll(ctx, true));
|
|
|
|
aio_disable_external(ctx);
|
|
event_notifier_set(¬ifiers[0]);
|
|
assert(aio_poll(ctx, true));
|
|
aio_enable_external(ctx);
|
|
|
|
remove_event_notifiers(notifiers, G_N_ELEMENTS(notifiers));
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
/*
|
|
* This code relies on the fact that fdmon-io_uring disables itself when
|
|
* the glib main loop is in use. The main loop uses fdmon-poll and upgrades
|
|
* to fdmon-epoll when the number of fds exceeds a threshold.
|
|
*/
|
|
qemu_init_main_loop(&error_fatal);
|
|
ctx = qemu_get_aio_context();
|
|
|
|
while (g_main_context_iteration(NULL, false)) {
|
|
/* Do nothing */
|
|
}
|
|
|
|
g_test_init(&argc, &argv, NULL);
|
|
g_test_add_func("/fdmon-epoll/external-disabled", test_external_disabled);
|
|
return g_test_run();
|
|
}
|