}
cpu_icount = cpu->icount_extra + cpu_neg(cpu)->icount_decr.u16.low;
- sc->diff_clk += cpu_icount_to_ns(sc->last_cpu_icount - cpu_icount);
+ sc->diff_clk += icount_to_ns(sc->last_cpu_icount - cpu_icount);
sc->last_cpu_icount = cpu_icount;
if (sc->diff_clk > VM_CLOCK_ADVANCE) {
assert(icount_enabled());
#ifndef CONFIG_USER_ONLY
/* Ensure global icount has gone forward */
- cpu_update_icount(cpu);
+ icount_update(cpu);
/* Refill decrementer and continue execution. */
insns_left = MIN(0xffff, cpu->icount_budget);
cpu_neg(cpu)->icount_decr.u16.low = insns_left;
}
qemu_printf("Host - Guest clock %"PRIi64" ms\n",
- (cpu_get_clock() - cpu_get_icount()) / SCALE_MS);
+ (cpu_get_clock() - icount_get()) / SCALE_MS);
if (icount_align_option) {
qemu_printf("Max guest delay %"PRIi64" ms\n",
-max_delay / SCALE_MS);
soon as the timer fires or the CPUs need to go out of the idle state.
Two functions are used for this purpose; because these actions change
virtual machine state and must be deterministic, each of them creates a
-checkpoint. qemu_start_warp_timer checks if the CPUs are idle and if so
-starts accounting real time to virtual clock. qemu_account_warp_timer
+checkpoint. icount_start_warp_timer checks if the CPUs are idle and if so
+starts accounting real time to virtual clock. icount_account_warp_timer
is called when the CPUs get an interrupt or when the warp timer fires,
and it warps the virtual clock by the amount of real time that has passed
-since qemu_start_warp_timer.
+since icount_start_warp_timer.
Bottom halves
-------------
* Update the icount with the executed instructions. Called by
* cpus-tcg vCPU thread so the main-loop can see time has moved forward.
*/
-void cpu_update_icount(CPUState *cpu);
+void icount_update(CPUState *cpu);
/* get raw icount value */
-int64_t cpu_get_icount_raw(void);
+int64_t icount_get_raw(void);
/* return the virtual CPU time in ns, based on the instruction counter. */
-int64_t cpu_get_icount(void);
+int64_t icount_get(void);
/*
* convert an instruction counter value to ns, based on the icount shift.
* This shift is set as a fixed value with the icount "shift" option
* (precise mode), or it is constantly approximated and corrected at
* runtime in adaptive mode.
*/
-int64_t cpu_icount_to_ns(int64_t icount);
+int64_t icount_to_ns(int64_t icount);
/* configure the icount options, including "shift" */
-void configure_icount(QemuOpts *opts, Error **errp);
+void icount_configure(QemuOpts *opts, Error **errp);
/* used by tcg vcpu thread to calc icount budget */
-int64_t qemu_icount_round(int64_t count);
+int64_t icount_round(int64_t count);
/* if the CPUs are idle, start accounting real time to virtual clock. */
-void qemu_start_warp_timer(void);
-void qemu_account_warp_timer(void);
+void icount_start_warp_timer(void);
+void icount_account_warp_timer(void);
/*
* CPU Ticks and Clock
#define REPLAY_CLOCK(clock, value) \
(replay_mode == REPLAY_MODE_PLAY ? replay_read_clock((clock)) \
: replay_mode == REPLAY_MODE_RECORD \
- ? replay_save_clock((clock), (value), cpu_get_icount_raw()) \
+ ? replay_save_clock((clock), (value), icount_get_raw()) \
: (value))
#define REPLAY_CLOCK_LOCKED(clock, value) \
(replay_mode == REPLAY_MODE_PLAY ? replay_read_clock((clock)) \
: replay_mode == REPLAY_MODE_RECORD \
- ? replay_save_clock((clock), (value), cpu_get_icount_raw_locked()) \
+ ? replay_save_clock((clock), (value), icount_get_raw_locked()) \
: (value))
/* Processing data from random generators */
uint64_t replay_get_current_icount(void)
{
- return cpu_get_icount_raw();
+ return icount_get_raw();
}
int replay_get_instructions(void)
int64_t ticks;
if (icount_enabled()) {
- return cpu_get_icount();
+ return icount_get();
}
qemu_spin_lock(&timers_state.vm_clock_lock);
return s->icount_rt_timer != NULL;
}
-static bool shift_state_needed(void *opaque)
+static bool icount_shift_state_needed(void *opaque)
{
return icount_enabled() == 2;
}
.name = "timer/icount/shift",
.version_id = 1,
.minimum_version_id = 1,
- .needed = shift_state_needed,
+ .needed = icount_shift_state_needed,
.fields = (VMStateField[]) {
VMSTATE_INT16(icount_time_shift, TimersState),
VMSTATE_END_OF_LIST()
deadline = INT32_MAX;
}
- return qemu_icount_round(deadline);
+ return icount_round(deadline);
} else {
return replay_get_instructions();
}
{
if (icount_enabled()) {
/* Account for executed instructions */
- cpu_update_icount(cpu);
+ icount_update(cpu);
/* Reset the counters */
cpu_neg(cpu)->icount_decr.u16.low = 0;
replay_mutex_lock();
qemu_mutex_lock_iothread();
/* Account partial waits to QEMU_CLOCK_VIRTUAL. */
- qemu_account_warp_timer();
+ icount_account_warp_timer();
/* Run the timers here. This is much more efficient than
* waking up the I/O thread and waiting for completion.
* originally budgeted minus the current state of the decrementing
* icount counters in extra/u16.low.
*/
-static int64_t cpu_get_icount_executed(CPUState *cpu)
+static int64_t icount_get_executed(CPUState *cpu)
{
return (cpu->icount_budget -
(cpu_neg(cpu)->icount_decr.u16.low + cpu->icount_extra));
* account executed instructions. This is done by the TCG vCPU
* thread so the main-loop can see time has moved forward.
*/
-static void cpu_update_icount_locked(CPUState *cpu)
+static void icount_update_locked(CPUState *cpu)
{
- int64_t executed = cpu_get_icount_executed(cpu);
+ int64_t executed = icount_get_executed(cpu);
cpu->icount_budget -= executed;
qatomic_set_i64(&timers_state.qemu_icount,
* account executed instructions. This is done by the TCG vCPU
* thread so the main-loop can see time has moved forward.
*/
-void cpu_update_icount(CPUState *cpu)
+void icount_update(CPUState *cpu)
{
seqlock_write_lock(&timers_state.vm_clock_seqlock,
&timers_state.vm_clock_lock);
- cpu_update_icount_locked(cpu);
+ icount_update_locked(cpu);
seqlock_write_unlock(&timers_state.vm_clock_seqlock,
&timers_state.vm_clock_lock);
}
-static int64_t cpu_get_icount_raw_locked(void)
+static int64_t icount_get_raw_locked(void)
{
CPUState *cpu = current_cpu;
exit(1);
}
/* Take into account what has run */
- cpu_update_icount_locked(cpu);
+ icount_update_locked(cpu);
}
/* The read is protected by the seqlock, but needs atomic64 to avoid UB */
return qatomic_read_i64(&timers_state.qemu_icount);
}
-static int64_t cpu_get_icount_locked(void)
+static int64_t icount_get_locked(void)
{
- int64_t icount = cpu_get_icount_raw_locked();
+ int64_t icount = icount_get_raw_locked();
return qatomic_read_i64(&timers_state.qemu_icount_bias) +
- cpu_icount_to_ns(icount);
+ icount_to_ns(icount);
}
-int64_t cpu_get_icount_raw(void)
+int64_t icount_get_raw(void)
{
int64_t icount;
unsigned start;
do {
start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
- icount = cpu_get_icount_raw_locked();
+ icount = icount_get_raw_locked();
} while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
return icount;
}
/* Return the virtual CPU time, based on the instruction counter. */
-int64_t cpu_get_icount(void)
+int64_t icount_get(void)
{
int64_t icount;
unsigned start;
do {
start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
- icount = cpu_get_icount_locked();
+ icount = icount_get_locked();
} while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));
return icount;
}
-int64_t cpu_icount_to_ns(int64_t icount)
+int64_t icount_to_ns(int64_t icount)
{
return icount << qatomic_read(&timers_state.icount_time_shift);
}
&timers_state.vm_clock_lock);
cur_time = REPLAY_CLOCK_LOCKED(REPLAY_CLOCK_VIRTUAL_RT,
cpu_get_clock_locked());
- cur_icount = cpu_get_icount_locked();
+ cur_icount = icount_get_locked();
delta = cur_icount - cur_time;
/* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
icount_adjust();
}
-int64_t qemu_icount_round(int64_t count)
+int64_t icount_round(int64_t count)
{
int shift = qatomic_read(&timers_state.icount_time_shift);
return (count + (1 << shift) - 1) >> shift;
* In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too
* far ahead of real time.
*/
- int64_t cur_icount = cpu_get_icount_locked();
+ int64_t cur_icount = icount_get_locked();
int64_t delta = clock - cur_icount;
warp_delta = MIN(warp_delta, delta);
}
icount_warp_rt();
}
-void qemu_start_warp_timer(void)
+void icount_start_warp_timer(void)
{
int64_t clock;
int64_t deadline;
}
}
-void qemu_account_warp_timer(void)
+void icount_account_warp_timer(void)
{
if (!icount_enabled() || !icount_sleep) {
return;
icount_warp_rt();
}
-void configure_icount(QemuOpts *opts, Error **errp)
+void icount_configure(QemuOpts *opts, Error **errp)
{
const char *option = qemu_opt_get(opts, "shift");
bool sleep = qemu_opt_get_bool(opts, "sleep", true);
static int do_configure_icount(void *opaque, QemuOpts *opts, Error **errp)
{
- configure_icount(opts, errp);
+ icount_configure(opts, errp);
return 0;
}
int use_icount;
-void cpu_update_icount(CPUState *cpu)
+void icount_update(CPUState *cpu)
{
abort();
}
-void configure_icount(QemuOpts *opts, Error **errp)
+void icount_configure(QemuOpts *opts, Error **errp)
{
/* signal error */
error_setg(errp, "cannot configure icount, TCG support not available");
}
-int64_t cpu_get_icount_raw(void)
+int64_t icount_get_raw(void)
{
abort();
return 0;
}
-int64_t cpu_get_icount(void)
+int64_t icount_get(void)
{
abort();
return 0;
}
-int64_t cpu_icount_to_ns(int64_t icount)
+int64_t icount_to_ns(int64_t icount)
{
abort();
return 0;
}
-int64_t qemu_icount_round(int64_t count)
+int64_t icount_round(int64_t count)
{
abort();
return 0;
}
-void qemu_start_warp_timer(void)
+void icount_start_warp_timer(void)
{
abort();
}
-void qemu_account_warp_timer(void)
+void icount_account_warp_timer(void)
{
abort();
}
static uint64_t instructions_get_count(CPUARMState *env)
{
- return (uint64_t)cpu_get_icount_raw();
+ return (uint64_t)icount_get_raw();
}
static int64_t instructions_ns_per(uint64_t icount)
{
- return cpu_icount_to_ns((int64_t)icount);
+ return icount_to_ns((int64_t)icount);
}
#endif
{
#if !defined(CONFIG_USER_ONLY)
if (icount_enabled()) {
- *val = cpu_get_icount();
+ *val = icount_get();
} else {
*val = cpu_get_host_ticks();
}
{
#if !defined(CONFIG_USER_ONLY)
if (icount_enabled()) {
- *val = cpu_get_icount() >> 32;
+ *val = icount_get() >> 32;
} else {
*val = cpu_get_host_ticks() >> 32;
}
* CPU thread can infinitely wait for event after
* missing the warp
*/
- qemu_start_warp_timer();
+ icount_start_warp_timer();
}
qemu_clock_run_all_timers();
}
{
/* Interrupt execution to force deadline recalculation. */
if (icount_enabled() && timer_list->clock->type == QEMU_CLOCK_VIRTUAL) {
- qemu_start_warp_timer();
+ icount_start_warp_timer();
}
timerlist_notify(timer_list);
}
default:
case QEMU_CLOCK_VIRTUAL:
if (icount_enabled()) {
- return cpu_get_icount();
+ return icount_get();
} else if (qtest_enabled()) { /* for qtest_clock_warp */
return qtest_get_virtual_clock();
} else {
projects / qemu.git / commitdiff