4 #include "qemu-common.h"
5 #include "qemu/notify.h"
6 #include "qemu/host-utils.h"
7 #include "sysemu/cpus.h"
9 #define NANOSECONDS_PER_SECOND 1000000000LL
13 #define SCALE_MS 1000000
20 * The following clock types are available:
22 * @QEMU_CLOCK_REALTIME: Real time clock
24 * The real time clock should be used only for stuff which does not
25 * change the virtual machine state, as it runs even if the virtual
28 * @QEMU_CLOCK_VIRTUAL: virtual clock
30 * The virtual clock only runs during the emulation. It stops
31 * when the virtual machine is stopped.
33 * @QEMU_CLOCK_HOST: host clock
35 * The host clock should be used for device models that emulate accurate
36 * real time sources. It will continue to run when the virtual machine
37 * is suspended, and it will reflect system time changes the host may
38 * undergo (e.g. due to NTP).
40 * @QEMU_CLOCK_VIRTUAL_RT: realtime clock used for icount warp
42 * Outside icount mode, this clock is the same as @QEMU_CLOCK_VIRTUAL.
43 * In icount mode, this clock counts nanoseconds while the virtual
44 * machine is running. It is used to increase @QEMU_CLOCK_VIRTUAL
45 * while the CPUs are sleeping and thus not executing instructions.
49 QEMU_CLOCK_REALTIME
= 0,
50 QEMU_CLOCK_VIRTUAL
= 1,
52 QEMU_CLOCK_VIRTUAL_RT
= 3,
56 typedef struct QEMUTimerList QEMUTimerList
;
58 struct QEMUTimerListGroup
{
59 QEMUTimerList
*tl
[QEMU_CLOCK_MAX
];
62 typedef void QEMUTimerCB(void *opaque
);
63 typedef void QEMUTimerListNotifyCB(void *opaque
);
66 int64_t expire_time
; /* in nanoseconds */
67 QEMUTimerList
*timer_list
;
74 extern QEMUTimerListGroup main_loop_tlg
;
78 * @type: the clock type
80 * Get the nanosecond value of a clock with
83 * Returns: the clock value in nanoseconds
85 int64_t qemu_clock_get_ns(QEMUClockType type
);
89 * @type: the clock type
91 * Get the millisecond value of a clock with
94 * Returns: the clock value in milliseconds
96 static inline int64_t qemu_clock_get_ms(QEMUClockType type
)
98 return qemu_clock_get_ns(type
) / SCALE_MS
;
103 * @type: the clock type
105 * Get the microsecond value of a clock with
108 * Returns: the clock value in microseconds
110 static inline int64_t qemu_clock_get_us(QEMUClockType type
)
112 return qemu_clock_get_ns(type
) / SCALE_US
;
116 * qemu_clock_has_timers:
117 * @type: the clock type
119 * Determines whether a clock's default timer list
120 * has timers attached
122 * Note that this function should not be used when other threads also access
123 * the timer list. The return value may be outdated by the time it is acted
126 * Returns: true if the clock's default timer list
127 * has timers attached
129 bool qemu_clock_has_timers(QEMUClockType type
);
132 * qemu_clock_expired:
133 * @type: the clock type
135 * Determines whether a clock's default timer list
136 * has an expired clock.
138 * Returns: true if the clock's default timer list has
141 bool qemu_clock_expired(QEMUClockType type
);
144 * qemu_clock_use_for_deadline:
145 * @type: the clock type
147 * Determine whether a clock should be used for deadline
148 * calculations. Some clocks, for instance vm_clock with
149 * use_icount set, do not count in nanoseconds. Such clocks
150 * are not used for deadline calculations, and are presumed
151 * to interrupt any poll using qemu_notify/aio_notify
154 * Returns: true if the clock runs in nanoseconds and
155 * should be used for a deadline.
157 bool qemu_clock_use_for_deadline(QEMUClockType type
);
160 * qemu_clock_deadline_ns_all:
161 * @type: the clock type
163 * Calculate the deadline across all timer lists associated
164 * with a clock (as opposed to just the default one)
165 * in nanoseconds, or -1 if no timer is set to expire.
167 * Returns: time until expiry in nanoseconds or -1
169 int64_t qemu_clock_deadline_ns_all(QEMUClockType type
);
172 * qemu_clock_get_main_loop_timerlist:
173 * @type: the clock type
175 * Return the default timer list associated with a clock.
177 * Returns: the default timer list
179 QEMUTimerList
*qemu_clock_get_main_loop_timerlist(QEMUClockType type
);
183 * @type: the clock type
185 * Call the notifier callback connected with the default timer
186 * list linked to the clock, or qemu_notify() if none.
188 void qemu_clock_notify(QEMUClockType type
);
192 * @type: the clock type
193 * @enabled: true to enable, false to disable
195 * Enable or disable a clock
196 * Disabling the clock will wait for related timerlists to stop
197 * executing qemu_run_timers. Thus, this functions should not
198 * be used from the callback of a timer that is based on @clock.
199 * Doing so would cause a deadlock.
201 * Caller should hold BQL.
203 void qemu_clock_enable(QEMUClockType type
, bool enabled
);
206 * qemu_start_warp_timer:
208 * Starts a timer for virtual clock update
210 void qemu_start_warp_timer(void);
213 * qemu_clock_register_reset_notifier:
214 * @type: the clock type
215 * @notifier: the notifier function
217 * Register a notifier function to call when the clock
218 * concerned is reset.
220 void qemu_clock_register_reset_notifier(QEMUClockType type
,
224 * qemu_clock_unregister_reset_notifier:
225 * @type: the clock type
226 * @notifier: the notifier function
228 * Unregister a notifier function to call when the clock
229 * concerned is reset.
231 void qemu_clock_unregister_reset_notifier(QEMUClockType type
,
235 * qemu_clock_run_timers:
236 * @type: clock on which to operate
238 * Run all the timers associated with the default timer list
241 * Returns: true if any timer ran.
243 bool qemu_clock_run_timers(QEMUClockType type
);
246 * qemu_clock_run_all_timers:
248 * Run all the timers associated with the default timer list
251 * Returns: true if any timer ran.
253 bool qemu_clock_run_all_timers(void);
261 * @type: the clock type to associate with the timerlist
262 * @cb: the callback to call on notification
263 * @opaque: the opaque pointer to pass to the callback
265 * Create a new timerlist associated with the clock of
268 * Returns: a pointer to the QEMUTimerList created
270 QEMUTimerList
*timerlist_new(QEMUClockType type
,
271 QEMUTimerListNotifyCB
*cb
, void *opaque
);
275 * @timer_list: the timer list to free
277 * Frees a timer_list. It must have no active timers.
279 void timerlist_free(QEMUTimerList
*timer_list
);
282 * timerlist_has_timers:
283 * @timer_list: the timer list to operate on
285 * Determine whether a timer list has active timers
287 * Note that this function should not be used when other threads also access
288 * the timer list. The return value may be outdated by the time it is acted
291 * Returns: true if the timer list has timers.
293 bool timerlist_has_timers(QEMUTimerList
*timer_list
);
297 * @timer_list: the timer list to operate on
299 * Determine whether a timer list has any timers which
302 * Returns: true if the timer list has timers which
305 bool timerlist_expired(QEMUTimerList
*timer_list
);
308 * timerlist_deadline_ns:
309 * @timer_list: the timer list to operate on
311 * Determine the deadline for a timer_list, i.e.
312 * the number of nanoseconds until the first timer
313 * expires. Return -1 if there are no timers.
315 * Returns: the number of nanoseconds until the earliest
316 * timer expires -1 if none
318 int64_t timerlist_deadline_ns(QEMUTimerList
*timer_list
);
321 * timerlist_get_clock:
322 * @timer_list: the timer list to operate on
324 * Determine the clock type associated with a timer list.
326 * Returns: the clock type associated with the
329 QEMUClockType
timerlist_get_clock(QEMUTimerList
*timer_list
);
332 * timerlist_run_timers:
333 * @timer_list: the timer list to use
335 * Call all expired timers associated with the timer list.
337 * Returns: true if any timer expired
339 bool timerlist_run_timers(QEMUTimerList
*timer_list
);
343 * @timer_list: the timer list to use
345 * call the notifier callback associated with the timer list.
347 void timerlist_notify(QEMUTimerList
*timer_list
);
354 * timerlistgroup_init:
355 * @tlg: the timer list group
356 * @cb: the callback to call when a notify is required
357 * @opaque: the opaque pointer to be passed to the callback.
359 * Initialise a timer list group. This must already be
360 * allocated in memory and zeroed. The notifier callback is
361 * called whenever a clock in the timer list group is
362 * reenabled or whenever a timer associated with any timer
363 * list is modified. If @cb is specified as null, qemu_notify()
366 void timerlistgroup_init(QEMUTimerListGroup
*tlg
,
367 QEMUTimerListNotifyCB
*cb
, void *opaque
);
370 * timerlistgroup_deinit:
371 * @tlg: the timer list group
373 * Deinitialise a timer list group. This must already be
374 * initialised. Note the memory is not freed.
376 void timerlistgroup_deinit(QEMUTimerListGroup
*tlg
);
379 * timerlistgroup_run_timers:
380 * @tlg: the timer list group
382 * Run the timers associated with a timer list group.
383 * This will run timers on multiple clocks.
385 * Returns: true if any timer callback ran
387 bool timerlistgroup_run_timers(QEMUTimerListGroup
*tlg
);
390 * timerlistgroup_deadline_ns:
391 * @tlg: the timer list group
393 * Determine the deadline of the soonest timer to
394 * expire associated with any timer list linked to
395 * the timer list group. Only clocks suitable for
396 * deadline calculation are included.
398 * Returns: the deadline in nanoseconds or -1 if no
399 * timers are to expire.
401 int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup
*tlg
);
409 * @ts: the timer to be initialised
410 * @timer_list: the timer list to attach the timer to
411 * @scale: the scale value for the timer
412 * @cb: the callback to be called when the timer expires
413 * @opaque: the opaque pointer to be passed to the callback
415 * Initialise a new timer and associate it with @timer_list.
416 * The caller is responsible for allocating the memory.
418 * You need not call an explicit deinit call. Simply make
419 * sure it is not on a list with timer_del.
421 void timer_init_tl(QEMUTimer
*ts
,
422 QEMUTimerList
*timer_list
, int scale
,
423 QEMUTimerCB
*cb
, void *opaque
);
427 * @ts: the timer to be initialised
428 * @type: the clock to associate with the timer
429 * @scale: the scale value for the timer
430 * @cb: the callback to call when the timer expires
431 * @opaque: the opaque pointer to pass to the callback
433 * Initialize a timer with the given scale on the default timer list
434 * associated with the clock.
436 * You need not call an explicit deinit call. Simply make
437 * sure it is not on a list with timer_del.
439 static inline void timer_init(QEMUTimer
*ts
, QEMUClockType type
, int scale
,
440 QEMUTimerCB
*cb
, void *opaque
)
442 timer_init_tl(ts
, main_loop_tlg
.tl
[type
], scale
, cb
, opaque
);
447 * @ts: the timer to be initialised
448 * @type: the clock to associate with the timer
449 * @cb: the callback to call when the timer expires
450 * @opaque: the opaque pointer to pass to the callback
452 * Initialize a timer with nanosecond scale on the default timer list
453 * associated with the clock.
455 * You need not call an explicit deinit call. Simply make
456 * sure it is not on a list with timer_del.
458 static inline void timer_init_ns(QEMUTimer
*ts
, QEMUClockType type
,
459 QEMUTimerCB
*cb
, void *opaque
)
461 timer_init(ts
, type
, SCALE_NS
, cb
, opaque
);
466 * @ts: the timer to be initialised
467 * @type: the clock to associate with the timer
468 * @cb: the callback to call when the timer expires
469 * @opaque: the opaque pointer to pass to the callback
471 * Initialize a timer with microsecond scale on the default timer list
472 * associated with the clock.
474 * You need not call an explicit deinit call. Simply make
475 * sure it is not on a list with timer_del.
477 static inline void timer_init_us(QEMUTimer
*ts
, QEMUClockType type
,
478 QEMUTimerCB
*cb
, void *opaque
)
480 timer_init(ts
, type
, SCALE_US
, cb
, opaque
);
485 * @ts: the timer to be initialised
486 * @type: the clock to associate with the timer
487 * @cb: the callback to call when the timer expires
488 * @opaque: the opaque pointer to pass to the callback
490 * Initialize a timer with millisecond scale on the default timer list
491 * associated with the clock.
493 * You need not call an explicit deinit call. Simply make
494 * sure it is not on a list with timer_del.
496 static inline void timer_init_ms(QEMUTimer
*ts
, QEMUClockType type
,
497 QEMUTimerCB
*cb
, void *opaque
)
499 timer_init(ts
, type
, SCALE_MS
, cb
, opaque
);
504 * @timer_list: the timer list to attach the timer to
505 * @scale: the scale value for the timer
506 * @cb: the callback to be called when the timer expires
507 * @opaque: the opaque pointer to be passed to the callback
509 * Create a new timer and associate it with @timer_list.
510 * The memory is allocated by the function.
512 * This is not the preferred interface unless you know you
513 * are going to call timer_free. Use timer_init instead.
515 * Returns: a pointer to the timer
517 static inline QEMUTimer
*timer_new_tl(QEMUTimerList
*timer_list
,
522 QEMUTimer
*ts
= g_malloc0(sizeof(QEMUTimer
));
523 timer_init_tl(ts
, timer_list
, scale
, cb
, opaque
);
529 * @type: the clock type to use
530 * @scale: the scale value for the timer
531 * @cb: the callback to be called when the timer expires
532 * @opaque: the opaque pointer to be passed to the callback
534 * Create a new timer and associate it with the default
535 * timer list for the clock type @type.
537 * Returns: a pointer to the timer
539 static inline QEMUTimer
*timer_new(QEMUClockType type
, int scale
,
540 QEMUTimerCB
*cb
, void *opaque
)
542 return timer_new_tl(main_loop_tlg
.tl
[type
], scale
, cb
, opaque
);
547 * @type: the clock type to associate with the timer
548 * @cb: the callback to call when the timer expires
549 * @opaque: the opaque pointer to pass to the callback
551 * Create a new timer with nanosecond scale on the default timer list
552 * associated with the clock.
554 * Returns: a pointer to the newly created timer
556 static inline QEMUTimer
*timer_new_ns(QEMUClockType type
, QEMUTimerCB
*cb
,
559 return timer_new(type
, SCALE_NS
, cb
, opaque
);
564 * @type: the clock type to associate with the timer
565 * @cb: the callback to call when the timer expires
566 * @opaque: the opaque pointer to pass to the callback
568 * Create a new timer with microsecond scale on the default timer list
569 * associated with the clock.
571 * Returns: a pointer to the newly created timer
573 static inline QEMUTimer
*timer_new_us(QEMUClockType type
, QEMUTimerCB
*cb
,
576 return timer_new(type
, SCALE_US
, cb
, opaque
);
581 * @type: the clock type to associate with the timer
582 * @cb: the callback to call when the timer expires
583 * @opaque: the opaque pointer to pass to the callback
585 * Create a new timer with millisecond scale on the default timer list
586 * associated with the clock.
588 * Returns: a pointer to the newly created timer
590 static inline QEMUTimer
*timer_new_ms(QEMUClockType type
, QEMUTimerCB
*cb
,
593 return timer_new(type
, SCALE_MS
, cb
, opaque
);
598 * @ts: the timer to be de-initialised
600 * Deassociate the timer from any timerlist. You should
601 * call timer_del before. After this call, any further
602 * timer_del call cannot cause dangling pointer accesses
603 * even if the previously used timerlist is freed.
605 void timer_deinit(QEMUTimer
*ts
);
611 * Free a timer (it must not be on the active list)
613 void timer_free(QEMUTimer
*ts
);
619 * Delete a timer from the active list.
621 * This function is thread-safe but the timer and its timer list must not be
622 * freed while this function is running.
624 void timer_del(QEMUTimer
*ts
);
629 * @expire_time: the expiry time in nanoseconds
631 * Modify a timer to expire at @expire_time
633 * This function is thread-safe but the timer and its timer list must not be
634 * freed while this function is running.
636 void timer_mod_ns(QEMUTimer
*ts
, int64_t expire_time
);
639 * timer_mod_anticipate_ns:
641 * @expire_time: the expiry time in nanoseconds
643 * Modify a timer to expire at @expire_time or the current time,
644 * whichever comes earlier.
646 * This function is thread-safe but the timer and its timer list must not be
647 * freed while this function is running.
649 void timer_mod_anticipate_ns(QEMUTimer
*ts
, int64_t expire_time
);
654 * @expire_time: the expire time in the units associated with the timer
656 * Modify a timer to expiry at @expire_time, taking into
657 * account the scale associated with the timer.
659 * This function is thread-safe but the timer and its timer list must not be
660 * freed while this function is running.
662 void timer_mod(QEMUTimer
*ts
, int64_t expire_timer
);
665 * timer_mod_anticipate:
667 * @expire_time: the expiry time in nanoseconds
669 * Modify a timer to expire at @expire_time or the current time, whichever
670 * comes earlier, taking into account the scale associated with the timer.
672 * This function is thread-safe but the timer and its timer list must not be
673 * freed while this function is running.
675 void timer_mod_anticipate(QEMUTimer
*ts
, int64_t expire_time
);
681 * Determines whether a timer is pending (i.e. is on the
682 * active list of timers, whether or not it has not yet expired).
684 * Returns: true if the timer is pending
686 bool timer_pending(QEMUTimer
*ts
);
691 * @current_time: the current time
693 * Determines whether a timer has expired.
695 * Returns: true if the timer has expired
697 bool timer_expired(QEMUTimer
*timer_head
, int64_t current_time
);
700 * timer_expire_time_ns:
703 * Determine the expiry time of a timer
705 * Returns: the expiry time in nanoseconds
707 uint64_t timer_expire_time_ns(QEMUTimer
*ts
);
714 * Read a timer @ts from a file @f
716 void timer_get(QEMUFile
*f
, QEMUTimer
*ts
);
723 void timer_put(QEMUFile
*f
, QEMUTimer
*ts
);
726 * General utility functions
730 * qemu_timeout_ns_to_ms:
731 * @ns: nanosecond timeout value
733 * Convert a nanosecond timeout value (or -1) to
734 * a millisecond value (or -1), always rounding up.
736 * Returns: millisecond timeout value
738 int qemu_timeout_ns_to_ms(int64_t ns
);
742 * @fds: Array of file descriptors
743 * @nfds: number of file descriptors
744 * @timeout: timeout in nanoseconds
746 * Perform a poll like g_poll but with a timeout in nanoseconds.
747 * See g_poll documentation for further details.
749 * Returns: number of fds ready
751 int qemu_poll_ns(GPollFD
*fds
, guint nfds
, int64_t timeout
);
754 * qemu_soonest_timeout:
755 * @timeout1: first timeout in nanoseconds (or -1 for infinite)
756 * @timeout2: second timeout in nanoseconds (or -1 for infinite)
758 * Calculates the soonest of two timeout values. -1 means infinite, which
759 * is later than any other value.
761 * Returns: soonest timeout value in nanoseconds (or -1 for infinite)
763 static inline int64_t qemu_soonest_timeout(int64_t timeout1
, int64_t timeout2
)
765 /* we can abuse the fact that -1 (which means infinite) is a maximal
766 * value when cast to unsigned. As this is disgusting, it's kept in
767 * one inline function.
769 return ((uint64_t) timeout1
< (uint64_t) timeout2
) ? timeout1
: timeout2
;
775 * Initialise the clock & timer infrastructure
777 void init_clocks(void);
779 int64_t cpu_get_ticks(void);
780 /* Caller must hold BQL */
781 void cpu_enable_ticks(void);
782 /* Caller must hold BQL */
783 void cpu_disable_ticks(void);
785 static inline int64_t get_max_clock_jump(void)
787 /* This should be small enough to prevent excessive interrupts from being
788 * generated by the RTC on clock jumps, but large enough to avoid frequent
789 * unnecessary resets in idle VMs.
791 return 60 * NANOSECONDS_PER_SECOND
;
795 * Low level clock functions
798 /* get host real time in nanosecond */
799 static inline int64_t get_clock_realtime(void)
803 gettimeofday(&tv
, NULL
);
804 return tv
.tv_sec
* 1000000000LL + (tv
.tv_usec
* 1000);
807 /* Warning: don't insert tracepoints into these functions, they are
808 also used by simpletrace backend and tracepoints would cause
809 an infinite recursion! */
811 extern int64_t clock_freq
;
813 static inline int64_t get_clock(void)
816 QueryPerformanceCounter(&ti
);
817 return muldiv64(ti
.QuadPart
, NANOSECONDS_PER_SECOND
, clock_freq
);
822 extern int use_rt_clock
;
824 static inline int64_t get_clock(void)
826 #ifdef CLOCK_MONOTONIC
829 clock_gettime(CLOCK_MONOTONIC
, &ts
);
830 return ts
.tv_sec
* 1000000000LL + ts
.tv_nsec
;
834 /* XXX: using gettimeofday leads to problems if the date
835 changes, so it should be avoided. */
836 return get_clock_realtime();
842 int64_t cpu_get_icount_raw(void);
843 int64_t cpu_get_icount(void);
844 int64_t cpu_get_clock(void);
845 int64_t cpu_icount_to_ns(int64_t icount
);
847 /*******************************************/
848 /* host CPU ticks (if available) */
850 #if defined(_ARCH_PPC)
852 static inline int64_t cpu_get_host_ticks(void)
856 /* This reads timebase in one 64bit go and includes Cell workaround from:
857 http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
859 __asm__
__volatile__ ("mftb %0\n\t"
864 /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
866 __asm__
__volatile__ ("mfspr %1,269\n\t" /* mftbu */
867 "mfspr %L0,268\n\t" /* mftb */
868 "mfspr %0,269\n\t" /* mftbu */
871 : "=r" (retval
), "=r" (junk
));
876 #elif defined(__i386__)
878 static inline int64_t cpu_get_host_ticks(void)
881 asm volatile ("rdtsc" : "=A" (val
));
885 #elif defined(__x86_64__)
887 static inline int64_t cpu_get_host_ticks(void)
891 asm volatile("rdtsc" : "=a" (low
), "=d" (high
));
898 #elif defined(__hppa__)
900 static inline int64_t cpu_get_host_ticks(void)
903 asm volatile ("mfctl %%cr16, %0" : "=r"(val
));
907 #elif defined(__ia64)
909 static inline int64_t cpu_get_host_ticks(void)
912 asm volatile ("mov %0 = ar.itc" : "=r"(val
) :: "memory");
916 #elif defined(__s390__)
918 static inline int64_t cpu_get_host_ticks(void)
921 asm volatile("stck 0(%1)" : "=m" (val
) : "a" (&val
) : "cc");
925 #elif defined(__sparc__)
927 static inline int64_t cpu_get_host_ticks (void)
931 asm volatile("rd %%tick,%0" : "=r"(rval
));
934 /* We need an %o or %g register for this. For recent enough gcc
935 there is an "h" constraint for that. Don't bother with that. */
943 asm volatile("rd %%tick,%%g1; srlx %%g1,32,%0; mov %%g1,%1"
944 : "=r"(rval
.i32
.high
), "=r"(rval
.i32
.low
) : : "g1");
949 #elif defined(__mips__) && \
950 ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
952 * binutils wants to use rdhwr only on mips32r2
953 * but as linux kernel emulate it, it's fine
957 #define MIPS_RDHWR(rd, value) { \
958 __asm__ __volatile__ (".set push\n\t" \
959 ".set mips32r2\n\t" \
960 "rdhwr %0, "rd"\n\t" \
965 static inline int64_t cpu_get_host_ticks(void)
967 /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
969 static uint32_t cyc_per_count
= 0;
971 if (!cyc_per_count
) {
972 MIPS_RDHWR("$3", cyc_per_count
);
975 MIPS_RDHWR("$2", count
);
976 return (int64_t)(count
* cyc_per_count
);
979 #elif defined(__alpha__)
981 static inline int64_t cpu_get_host_ticks(void)
986 asm volatile("rpcc %0" : "=r"(cc
));
993 /* The host CPU doesn't have an easily accessible cycle counter.
994 Just return a monotonically increasing value. This will be
995 totally wrong, but hopefully better than nothing. */
996 static inline int64_t cpu_get_host_ticks (void)
998 static int64_t ticks
= 0;
1003 #ifdef CONFIG_PROFILER
1004 static inline int64_t profile_getclock(void)
1009 extern int64_t tcg_time
;
1010 extern int64_t dev_time
;