motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-01 23:03:54 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

AioContext: take bottom halves into account when computing aio_poll timeout

Browse source 
Right now, QEMU invokes aio_bh_poll before the "poll" phase
of aio_poll.  It is simpler to do it afterwards and skip the
"poll" phase altogether when the OS-dependent parts of AioContext
are invoked from GSource.  This way, AioContext behaves more
similarly when used as a GSource vs. when used as stand-alone.

As a start, take bottom halves into account when computing the
poll timeout.  If a bottom half is ready, do a non-blocking
poll.  As a side effect, this makes idle bottom halves work
with aio_poll; an improvement, but not really an important
one since they are deprecated.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
This commit is contained in:
Paolo Bonzini 2014-07-09 11:53:01 +02:00 • committed by Stefan Hajnoczi
parent 3cbbe9fd1f
commit 845ca10dd0
4 changed files with 29 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

32
async.c
View file

@ -152,39 +152,43 @@ void qemu_bh_delete(QEMUBH *bh)
bh->deleted = 1;
}
static gboolean
aio_ctx_prepare(GSource *source, gint *timeout)
int64_t
aio_compute_timeout(AioContext *ctx)
{
AioContext *ctx = (AioContext *) source;
int64_t deadline;
int timeout = -1;
QEMUBH *bh;
int deadline;
/* We assume there is no timeout already supplied */
*timeout = -1;
for (bh = ctx->first_bh; bh; bh = bh->next) {
if (!bh->deleted && bh->scheduled) {
if (bh->idle) {
/* idle bottom halves will be polled at least
* every 10ms */
*timeout = 10;
timeout = 10000000;
} else {
/* non-idle bottom halves will be executed
* immediately */
*timeout = 0;
return true;
return 0;
}
}
}
deadline = qemu_timeout_ns_to_ms(timerlistgroup_deadline_ns(&ctx->tlg));
deadline = timerlistgroup_deadline_ns(&ctx->tlg);
if (deadline == 0) {
*timeout = 0;
return true;
return 0;
} else {
*timeout = qemu_soonest_timeout(*timeout, deadline);
return qemu_soonest_timeout(timeout, deadline);
}
}
return false;
static gboolean
aio_ctx_prepare(GSource *source, gint *timeout)
{
AioContext *ctx = (AioContext *) source;
/* We assume there is no timeout already supplied */
*timeout = qemu_timeout_ns_to_ms(aio_compute_timeout(ctx));
return *timeout == 0;
}
static gboolean