haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

replay: rename step-related variables and functions

Browse source 
This patch renames replay_get_current_step() and related variables
to make these names consistent with existing 'icount' command line
option and future record/replay hmp/qmp commands.

Signed-off-by: Pavel Dovgalyuk <Pavel.Dovgaluk@ispras.ru>
Message-Id: <156404428377.18669.15476429889039912070.stgit@pasha-Precision-3630-Tower>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Pavel Dovgalyuk 2019-07-25 11:44:43 +03:00 committed by Paolo Bonzini
parent 82f4915653
commit 13f267133f
7 changed files with 27 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
include/sysemu/replay.h
View file

@ -75,7 +75,7 @@ void replay_add_blocker(Error *reason);
/* Processing the instructions */ /* Processing the instructions */
/*! Returns number of executed instructions. */ /*! Returns number of executed instructions. */
uint64_t replay_get_current_step(void); uint64_t replay_get_current_icount(void);
/*! Returns number of instructions to execute in replay mode. */ /*! Returns number of instructions to execute in replay mode. */
int replay_get_instructions(void); int replay_get_instructions(void);
/*! Updates instructions counter in replay mode. */ /*! Updates instructions counter in replay mode. */

2
replay/replay-events.c
View file

@ -124,7 +124,7 @@ void replay_add_event(ReplayAsyncEventKind event_kind,
void replay_bh_schedule_event(QEMUBH *bh) void replay_bh_schedule_event(QEMUBH *bh)
{ {
if (events_enabled) { if (events_enabled) {
uint64_t id = replay_get_current_step(); uint64_t id = replay_get_current_icount();
replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id); replay_add_event(REPLAY_ASYNC_EVENT_BH, bh, NULL, id);
} else { } else {
qemu_bh_schedule(bh); qemu_bh_schedule(bh);

10
replay/replay-internal.c
View file

@ -173,7 +173,7 @@ void replay_fetch_data_kind(void)
if (!replay_state.has_unread_data) { if (!replay_state.has_unread_data) {
replay_state.data_kind = replay_get_byte(); replay_state.data_kind = replay_get_byte();
if (replay_state.data_kind == EVENT_INSTRUCTION) { if (replay_state.data_kind == EVENT_INSTRUCTION) {
replay_state.instructions_count = replay_get_dword(); replay_state.instruction_count = replay_get_dword();
} }
replay_check_error(); replay_check_error();
replay_state.has_unread_data = 1; replay_state.has_unread_data = 1;
@ -227,9 +227,9 @@ void replay_mutex_unlock(void)
} }
} }
void replay_advance_current_step(uint64_t current_step) void replay_advance_current_icount(uint64_t current_icount)
{ {
int diff = (int)(current_step - replay_state.current_step); int diff = (int)(current_icount - replay_state.current_icount);
/* Time can only go forward */ /* Time can only go forward */
assert(diff >= 0); assert(diff >= 0);
@ -237,7 +237,7 @@ void replay_advance_current_step(uint64_t current_step)
if (diff > 0) { if (diff > 0) {
replay_put_event(EVENT_INSTRUCTION); replay_put_event(EVENT_INSTRUCTION);
replay_put_dword(diff); replay_put_dword(diff);
replay_state.current_step += diff; replay_state.current_icount += diff;
} }
} }
@ -246,6 +246,6 @@ void replay_save_instructions(void)
{ {
if (replay_file && replay_mode == REPLAY_MODE_RECORD) { if (replay_file && replay_mode == REPLAY_MODE_RECORD) {
g_assert(replay_mutex_locked()); g_assert(replay_mutex_locked());
replay_advance_current_step(replay_get_current_step()); replay_advance_current_icount(replay_get_current_icount());
} }
} }

10
replay/replay-internal.h
View file

@ -64,10 +64,10 @@ typedef enum ReplayAsyncEventKind ReplayAsyncEventKind;
typedef struct ReplayState { typedef struct ReplayState {
/*! Cached clock values. */ /*! Cached clock values. */
int64_t cached_clock[REPLAY_CLOCK_COUNT]; int64_t cached_clock[REPLAY_CLOCK_COUNT];
/*! Current step - number of processed instructions and timer events. */ /*! Current icount - number of processed instructions. */
uint64_t current_step; uint64_t current_icount;
/*! Number of instructions to be executed before other events happen. */ /*! Number of instructions to be executed before other events happen. */
int instructions_count; int instruction_count;
/*! Type of the currently executed event. */ /*! Type of the currently executed event. */
unsigned int data_kind; unsigned int data_kind;
/*! Flag which indicates that event is not processed yet. */ /*! Flag which indicates that event is not processed yet. */
@ -122,8 +122,8 @@ void replay_finish_event(void);
data_kind variable. */ data_kind variable. */
void replay_fetch_data_kind(void); void replay_fetch_data_kind(void);
/*! Advance replay_state.current_step to the specified value. */ /*! Advance replay_state.current_icount to the specified value. */
void replay_advance_current_step(uint64_t current_step); void replay_advance_current_icount(uint64_t current_icount);
/*! Saves queued events (like instructions and sound). */ /*! Saves queued events (like instructions and sound). */
void replay_save_instructions(void); void replay_save_instructions(void);

6
replay/replay-snapshot.c
View file

@ -38,7 +38,7 @@ static int replay_post_load(void *opaque, int version_id)
} else if (replay_mode == REPLAY_MODE_RECORD) { } else if (replay_mode == REPLAY_MODE_RECORD) {
/* This is only useful for loading the initial state. /* This is only useful for loading the initial state.
Therefore reset all the counters. */ Therefore reset all the counters. */
state->instructions_count = 0; state->instruction_count = 0;
state->block_request_id = 0; state->block_request_id = 0;
} }
@ -53,8 +53,8 @@ static const VMStateDescription vmstate_replay = {
.post_load = replay_post_load, .post_load = replay_post_load,
.fields = (VMStateField[]) { .fields = (VMStateField[]) {
VMSTATE_INT64_ARRAY(cached_clock, ReplayState, REPLAY_CLOCK_COUNT), VMSTATE_INT64_ARRAY(cached_clock, ReplayState, REPLAY_CLOCK_COUNT),
VMSTATE_UINT64(current_step, ReplayState), VMSTATE_UINT64(current_icount, ReplayState),
VMSTATE_INT32(instructions_count, ReplayState), VMSTATE_INT32(instruction_count, ReplayState),
VMSTATE_UINT32(data_kind, ReplayState), VMSTATE_UINT32(data_kind, ReplayState),
VMSTATE_UINT32(has_unread_data, ReplayState), VMSTATE_UINT32(has_unread_data, ReplayState),
VMSTATE_UINT64(file_offset, ReplayState), VMSTATE_UINT64(file_offset, ReplayState),

2
replay/replay-time.c
View file

@ -24,7 +24,7 @@ int64_t replay_save_clock(ReplayClockKind kind, int64_t clock,
* Due to the caller's locking requirements we get the icount from it * Due to the caller's locking requirements we get the icount from it
* instead of using replay_save_instructions(). * instead of using replay_save_instructions().
*/ */
replay_advance_current_step(raw_icount); replay_advance_current_icount(raw_icount);
replay_put_event(EVENT_CLOCK + kind); replay_put_event(EVENT_CLOCK + kind);
replay_put_qword(clock); replay_put_qword(clock);

22
replay/replay.c
View file

@ -39,7 +39,7 @@ bool replay_next_event_is(int event)
bool res = false; bool res = false;
/* nothing to skip - not all instructions used */ /* nothing to skip - not all instructions used */
if (replay_state.instructions_count != 0) { if (replay_state.instruction_count != 0) {
assert(replay_state.data_kind == EVENT_INSTRUCTION); assert(replay_state.data_kind == EVENT_INSTRUCTION);
return event == EVENT_INSTRUCTION; return event == EVENT_INSTRUCTION;
} }
@ -62,7 +62,7 @@ bool replay_next_event_is(int event)
return res; return res;
} }
uint64_t replay_get_current_step(void) uint64_t replay_get_current_icount(void)
{ {
return cpu_get_icount_raw(); return cpu_get_icount_raw();
} }
@ -72,7 +72,7 @@ int replay_get_instructions(void)
int res = 0; int res = 0;
replay_mutex_lock(); replay_mutex_lock();
if (replay_next_event_is(EVENT_INSTRUCTION)) { if (replay_next_event_is(EVENT_INSTRUCTION)) {
res = replay_state.instructions_count; res = replay_state.instruction_count;
} }
replay_mutex_unlock(); replay_mutex_unlock();
return res; return res;
@ -82,16 +82,16 @@ void replay_account_executed_instructions(void)
{ {
if (replay_mode == REPLAY_MODE_PLAY) { if (replay_mode == REPLAY_MODE_PLAY) {
g_assert(replay_mutex_locked()); g_assert(replay_mutex_locked());
if (replay_state.instructions_count > 0) { if (replay_state.instruction_count > 0) {
int count = (int)(replay_get_current_step() int count = (int)(replay_get_current_icount()
- replay_state.current_step); - replay_state.current_icount);
/* Time can only go forward */ /* Time can only go forward */
assert(count >= 0); assert(count >= 0);
replay_state.instructions_count -= count; replay_state.instruction_count -= count;
replay_state.current_step += count; replay_state.current_icount += count;
if (replay_state.instructions_count == 0) { if (replay_state.instruction_count == 0) {
assert(replay_state.data_kind == EVENT_INSTRUCTION); assert(replay_state.data_kind == EVENT_INSTRUCTION);
replay_finish_event(); replay_finish_event();
/* Wake up iothread. This is required because /* Wake up iothread. This is required because
@ -273,8 +273,8 @@ static void replay_enable(const char *fname, int mode)
replay_mutex_init(); replay_mutex_init();
replay_state.data_kind = -1; replay_state.data_kind = -1;
replay_state.instructions_count = 0; replay_state.instruction_count = 0;
replay_state.current_step = 0; replay_state.current_icount = 0;
replay_state.has_unread_data = 0; replay_state.has_unread_data = 0;
/* skip file header for RECORD and check it for PLAY */ /* skip file header for RECORD and check it for PLAY */