openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

do not use qemu_icount_delta in the !use_icount case 

The !use_icount code is the same for iothread and non-iothread,
except that the timeout is different.  Since the timeout might as
well be infinite and is only masking bugs, use the higher value.
With this change the !use_icount code is handled equivalently
in qemu_icount_delta and qemu_calculate_timeout, and we rip it
out of the former.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Edgar E. Iglesias <edgar.iglesias@petalogix.com>
This commit is contained in:
Paolo Bonzini 2011-02-21 09:51:23 +01:00 committed by Edgar E. Iglesias
parent 9a31334f41
commit c9f7383c6e
1 changed files with 25 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
qemu-timer.c
View File

@ -112,9 +112,7 @@ static int64_t cpu_get_clock(void)
static int64_t qemu_icount_delta(void)
{
if (!use_icount) {
return 5000 * (int64_t) 1000000;
} else if (use_icount == 1) {
if (use_icount == 1) {
/* When not using an adaptive execution frequency
we tend to get badly out of sync with real time,
so just delay for a reasonable amount of time. */
@ -1077,43 +1075,36 @@ void quit_timers(void)
int qemu_calculate_timeout(void)
{
int timeout;
int64_t add;
int64_t delta;
#ifdef CONFIG_IOTHREAD
/* When using icount, making forward progress with qemu_icount when the
guest CPU is idle is critical. We only use the static io-thread timeout
for non icount runs. */
if (!use_icount) {
return 1000;
if (!use_icount || !vm_running) {
return 5000;
}
#endif
if (!vm_running)
timeout = 5000;
else {
/* XXX: use timeout computed from timers */
int64_t add;
int64_t delta;
/* Advance virtual time to the next event. */
delta = qemu_icount_delta();
if (delta > 0) {
/* If virtual time is ahead of real time then just
wait for IO. */
timeout = (delta + 999999) / 1000000;
} else {
/* Wait for either IO to occur or the next
timer event. */
add = qemu_next_deadline();
/* We advance the timer before checking for IO.
Limit the amount we advance so that early IO
activity won't get the guest too far ahead. */
if (add > 10000000)
add = 10000000;
delta += add;
qemu_icount += qemu_icount_round (add);
timeout = delta / 1000000;
if (timeout < 0)
timeout = 0;
}
/* Advance virtual time to the next event. */
delta = qemu_icount_delta();
if (delta > 0) {
/* If virtual time is ahead of real time then just
wait for IO. */
timeout = (delta + 999999) / 1000000;
} else {
/* Wait for either IO to occur or the next
timer event. */
add = qemu_next_deadline();
/* We advance the timer before checking for IO.
Limit the amount we advance so that early IO
activity won't get the guest too far ahead. */
if (add > 10000000)
add = 10000000;
delta += add;
qemu_icount += qemu_icount_round (add);
timeout = delta / 1000000;
if (timeout < 0)
timeout = 0;
}
return timeout;