| /qemu/include/system/ |
| H A D | rtc.h | 29 * qemu_get_timedate: Get the current RTC time
30 * @tm: struct tm to fill in with RTC time
31 * @offset: offset in seconds to adjust the RTC time by before
34 * This function fills in @tm with the current RTC time, as adjusted
35 * by @offset (for example, if @offset is 3600 then the returned time/date
36 * will be one hour further ahead than the current RTC time).
39 * to find the time/date value that they should return to the guest
49 * @tm: struct tm containing the date/time to compare against
51 * Returns the difference in seconds between the RTC clock time
52 * and the date/time specified in @tm. For example, if @tm specifies
[all …]
|
| /qemu/util/ |
| H A D | timed-average.c | 31 /* This module computes an average of a set of values within a time
38 * - Each time you want to account a new value, do it in both windows.
53 /* Update the expiration of a time window
56 * @now: the current time in nanoseconds
62 /* time elapsed since the last theoretical expiration */ in update_expiration()
64 /* time remaininging until the next expiration */ in update_expiration()
83 * expiration time).
97 * @period: the time window period in nanoseconds
121 /* Check if the time windows have expired, updating their counters and
122 * expiration time if that's the case.
[all …]
|
| /qemu/tests/functional/ |
| H A D | replay_kernel.py | 13 import time
28 REPLAY_KERNEL_COMMAND_LINE = 'printk.time=1 panic=-1 '
36 start_time = time.time()
64 elapsed = time.time() - start_time
65 logger.info('elapsed time %.2f sec' % elapsed)
|
| H A D | test_migration.py | 15 import time
31 end = time.monotonic() + self.timeout
32 while time.monotonic() < end and not self.migration_finished(src_vm):
33 time.sleep(0.1)
35 end = time.monotonic() + self.timeout
36 while time.monotonic() < end and not self.migration_finished(dst_vm):
37 time.sleep(0.1)
|
| H A D | test_virtio_balloon.py | 8 import time
86 time.sleep(0.5)
88 now = time.time()
155 then = time.time()
172 then = time.time()
|
| /qemu/tests/qemu-iotests/tests/ |
| H A D | nbd-reconnect-on-open | 21 import time
42 start_t = time.time()
44 delta_t = time.time() - start_t
60 time.sleep(1)
67 # check it and at the same time check that with open-timeout=0 client fails
|
| /qemu/docs/devel/ |
| H A D | replay.rst | 38 * wrappers for clock and time functions to save their return values in the log
64 reduce the time the BQL was held across the system including under TCG
99 of time. That's why we do not process a group of timers until the checkpoint
105 1 ns per *real time* nanosecond. This is done by setting up a timer
106 (called the warp timer) on the virtual real time clock, so that the
113 starts accounting real time to virtual clock. ``icount_account_warp_timer``
115 and it warps the virtual clock by the amount of real time that has passed
130 at the specified moments of time. There are several kinds of timers:
132 * Real time clock. Based on host time and used only for callbacks that
133 do not change the virtual machine state. For this reason real time
[all …]
|
| /qemu/tests/qemu-iotests/ |
| H A D | 082.out | 62 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
88 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
114 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
140 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
166 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
192 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
218 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
244 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
285 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
372 encrypt.iter-time=<num> - Time to spend in PBKDF in milliseconds
[all …]
|
| H A D | 264 | 22 import time
69 time.sleep(wait_step)
81 # Emulate server down time for 1 second
82 time.sleep(1)
97 start_t = time.time()
99 delta_t = time.time() - start_t
|
| H A D | 293 | 70 _make_test_img $S0 $EXTRA_IMG_ARGS -o ${PR}key-secret=sec0,${PR}iter-time=10 32M
78 $QEMU_IMG amend $SECRETS $IMGS0 -o ${PR}state=active,${PR}new-secret=sec4,${PR}iter-time=10,${PR}ke…
80 $QEMU_IMG amend $SECRETS $IMGS0 -o ${PR}state=active,${PR}new-secret=sec1,${PR}iter-time=10
82 $QEMU_IMG amend $SECRETS $IMGS1 -o ${PR}state=active,${PR}new-secret=sec3,${PR}iter-time=10,${PR}ke…
85 $QEMU_IMG amend $SECRETS $IMGS3 -o ${PR}state=active,${PR}new-secret=sec2,${PR}iter-time=10
114 $QEMU_IMG amend $SECRETS $IMGS3 -o ${PR}state=active,${PR}new-secret=sec2,${PR}iter-time=10
119 $QEMU_IMG amend $SECRETS $IMGS3 -o ${PR}state=active,${PR}new-secret=sec0,${PR}iter-time=10
123 $QEMU_IMG amend $SECRETS $IMGS3 -o ${PR}state=active,${PR}new-secret=sec3,${PR}iter-time=10
127 $QEMU_IMG amend $SECRETS $IMGS2 -o ${PR}state=active,${PR}new-secret=sec3,${PR}iter-time=10
158 $QEMU_IMG amend $SECRETS $IMGS3 -o ${PR}state=active,${PR}new-secret=sec0,${PR}iter-time=10
[all …]
|
| /qemu/contrib/plugins/ |
| H A D | ips.c | 6 * time as seen by the guest so while wall-clock time may be longer
7 * from the guests point of view time will pass at the normal rate.
10 * system time.
23 /* how many times do we update time per sec */
31 static int64_t virtual_time_ns; /* last set virtual time */
38 int64_t last_quantum_time; /* time when last quantum started */
43 /* return epoch time in ns */
78 /* based on total number of instructions, what should be the new time? */ in update_system_time()
83 /* Time only moves forward. Another vcpu might have updated it already. */ in update_system_time()
|
| /qemu/include/hw/xen/interface/ |
| H A D | vcpu.h | 60 * Return information about the state and running time of a VCPU.
67 /* When was current state entered (system time, ns)? */
76 * Time spent in each RUNSTATE_* (ns). The sum of these times is
77 * guaranteed not to drift from system time.
79 uint64_t time[4]; member
109 * updated by the hypervisor each time the VCPU is scheduled. Thus
111 * runstate.state_entry_time will indicate the system time at which the
146 uint64_t timeout_abs_ns; /* Absolute system time value in nanoseconds. */
194 * Register a memory location to get a secondary copy of the vcpu time
200 * that usermode can compute system time using the time info and the
[all …]
|
| /qemu/include/standard-headers/linux/ |
| H A D | vmclock-abi.h | 6 * counter, etc.) and real time. It is designed to address the problem of
13 * ±50PPM, or 4 seconds a day). This frequency also varies over time on the
30 * action, even when using a vDSO-style method to get the time instead of a
34 * precise relationship of the CPU counter to real time, as calibrated by the
35 * host. This means that userspace applications can have accurate time
106 * guaranteed that the time calculated according this structure at
107 * any given moment shall never appear to be later than the time
112 * associated memory barrier), using the previously-valid time and
128 * The time exposed through this device is never smeared. This field
162 * Paired values of counter and UTC at a given point in time.
[all …]
|
| /qemu/tests/migration-stress/guestperf/ |
| H A D | engine.py | 24 import time
56 now = time.time()
70 now = time.time()
101 time.time(),
102 info.get("total-time", 0),
105 info.get("setup-time", 0),
107 info.get("dirty-limit-throttle-time-per-round", 0),
108 info.get("dirty-limit-ring-full-time", 0),
130 time.sleep(1)
247 start = time.time()
[all …]
|
| /qemu/scripts/ci/ |
| H A D | gitlab-pipeline-status | 22 import time
88 start = time.time()
90 if time.time() >= (start + timeout):
101 time.sleep(1)
109 time.sleep(interval)
126 help=('Amount of time (in seconds) to wait for the '
130 help=('Amount of time (in seconds) to wait between '
|
| /qemu/accel/tcg/ |
| H A D | icount-common.c | 82 * thread so the main-loop can see time has moved forward.
96 * thread so the main-loop can see time has moved forward.
143 /* Return the virtual CPU time, based on the instruction counter. */
163 * Correlation between real and virtual time is always going to be
165 * When the guest is idle real and virtual time will be aligned in
192 /* The guest is getting too far ahead. Slow time down. */ in icount_adjust()
199 /* The guest is getting too far behind. Speed time up. */ in icount_adjust()
261 * ahead of real time (it might already be ahead so careful not in icount_warp_rt()
359 * It is useful when we want a deterministic execution time, in icount_start_warp_timer()
372 * "real" time, (related to the time left until the next event) has in icount_start_warp_timer()
[all …]
|
| /qemu/bsd-user/ |
| H A D | syscall_defs.h | 84 target_time_t shm_atime; /* time of last shmat() */
85 target_time_t shm_dtime; /* time of last shmdt() */
86 target_time_t shm_ctime; /* time of last change by shmctl() */
136 * sys/time.h
194 struct target_freebsd_timeval ru_utime; /* user time used */
195 struct target_freebsd_timeval ru_stime; /* system time used */
228 struct target_freebsd_timespec st_atim; /* time last accessed */
229 struct target_freebsd_timespec st_mtim; /* time last data modification */
230 struct target_freebsd_timespec st_ctim; /* time last file status change */
237 struct target_freebsd_timespec st_birthtim; /* time of file creation */
[all …]
|
| /qemu/include/qemu/ |
| H A D | ratelimit.h | 33 * in the current time slice, return 0 (i.e. no delay). Otherwise
34 * return the amount of time (in ns) until the start of the next time
38 * permitted; the time slice will be extended accordingly.
53 /* Previous, possibly extended, time slice finished; reset the in ratelimit_calculate_delay()
62 /* We may send further data within the current time slice, no in ratelimit_calculate_delay()
|
| H A D | timer.h | 21 * @QEMU_CLOCK_REALTIME: Real time clock
23 * The real time clock should be used only for stuff which does not
35 * real time sources. It will continue to run when the virtual machine
36 * is suspended, and it will reflect system time changes the host may
143 * the timer list. The return value may be outdated by the time it is acted
189 * Returns: time until expiry in nanoseconds or -1
239 * qemu_clock_advance_virtual_time(): advance the virtual time tick
240 * @target_ns: target time in nanoseconds
242 * This function is used where the control of the flow of time has
247 * Time can only move forward, attempts to reverse time would lead to
[all …]
|
| /qemu/docs/specs/ |
| H A D | rapl-msr.rst | 14 userspace (QEMU); a list of MSRs is given at VM creation time to KVM, and
36 energy consumed since the last time the register was cleared. If you multiply
54 1. Snapshot of the time metrics of all QEMU threads (Time spent scheduled in
64 time spent scheduled for each QEMU thread *and* the energy spent by the
89 In Linux, a process has an execution time associated with it. The scheduler is
90 dividing the time in clock ticks. The number of clock ticks per second can be
97 time of a process with the [pid] as the process ID. It gives the amount
103 By reading those metrics for a thread, one can calculate the ratio of time the
|
| /qemu/hw/i386/kvm/ |
| H A D | clock.c | 71 struct pvclock_vcpu_time_info time; in kvmclock_current_nsec() local
85 cpu_physical_memory_read(kvmclock_struct_pa, &time, sizeof(time)); in kvmclock_current_nsec()
87 assert(time.tsc_timestamp <= migration_tsc); in kvmclock_current_nsec()
88 delta = migration_tsc - time.tsc_timestamp; in kvmclock_current_nsec()
89 if (time.tsc_shift < 0) { in kvmclock_current_nsec()
90 delta >>= -time.tsc_shift; in kvmclock_current_nsec()
92 delta <<= time.tsc_shift; in kvmclock_current_nsec()
95 mulu64(&nsec_lo, &nsec_hi, delta, time.tsc_to_system_mul); in kvmclock_current_nsec()
97 return nsec + time.system_time; in kvmclock_current_nsec()
123 * has protection against time going backwards. This "safety net" is only in kvm_update_clock()
|
| /qemu/hw/i2c/ |
| H A D | smbus_eeprom.c | 120 * But until that time, act as if we had been stopped and restarted.
265 spd[10] = 1; /* access time */ in spd_data_generate()
278 spd[23] = 0x12; /* clock cycle time @ medium CAS latency */ in spd_data_generate()
279 /* data access time */ in spd_data_generate()
280 /* clock cycle time @ short CAS latency */ in spd_data_generate()
281 /* data access time */ in spd_data_generate()
282 spd[27] = 20; /* min. row precharge time */ in spd_data_generate()
285 spd[30] = 45; /* min. active to precharge time */ in spd_data_generate()
287 spd[32] = 20; /* addr/cmd setup time */ in spd_data_generate()
288 spd[33] = 8; /* addr/cmd hold time */ in spd_data_generate()
[all …]
|
| /qemu/qapi/ |
| H A D | migration.json | 207 # @total-time: total amount of milliseconds since migration started.
208 # If migration has ended, it returns the total migration time.
218 # @setup-time: amount of setup time in milliseconds *before* the
224 # @cpu-throttle-percentage: percentage of time guest cpus are being
231 # @postcopy-blocktime: total time when all vCPU were blocked during
251 # @dirty-limit-throttle-time-per-round: Maximum throttle time (in
256 # @dirty-limit-ring-full-time: Estimated average dirty ring full time
269 '*total-time': 'int',
272 '*setup-time': 'int',
279 '*dirty-limit-throttle-time-per-round': 'uint64',
[all …]
|
| /qemu/include/hw/misc/ |
| H A D | nrf51_rng.h | 5 * + Property "period_unfiltered_us": Time between two biased values in
7 * + Property "period_filtered_us": Time between two unbiased values in
24 * average generation time stated in the production specification;
69 /* Time between generation of successive unfiltered values in us */
71 /* Time between generation of successive filtered values in us */
|
| /qemu/python/qemu/machine/ |
| H A D | console_socket.py | 19 import time
78 time.sleep(self._sleep_time)
120 start_time = time.time()
122 time.sleep(self._sleep_time)
123 elapsed_sec = time.time() - start_time
|