diff options
author | 2025-01-13 12:00:33 +0000 | |
---|---|---|
committer | 2025-01-24 01:05:24 -0800 | |
commit | 1a9a8abf19e7641149fcaed3971bf0aa99f4dfb8 (patch) | |
tree | 74cc6c1c49a2fe36b29807ed2256b26073df9628 /runtime/trace_common.h | |
parent | 2576b59a2dad4ee542eb50fb451ff88a4b8902ad (diff) |
Use nanoseconds for v2 method tracing
Update the precision of timestamps to be nanoseconds and use nanosecond
precision in method trace format v2. For format v1 we use microsecond
precision for backwards compatability.
Bug: 259258187
Test: art/test.py -t 2246
Change-Id: I099e21f5d143c5444193e7886b5281b32f87d5d3
Diffstat (limited to 'runtime/trace_common.h')
-rw-r--r-- | runtime/trace_common.h | 40 |
1 files changed, 20 insertions, 20 deletions
diff --git a/runtime/trace_common.h b/runtime/trace_common.h index 759a0bbc49..f29b347462 100644 --- a/runtime/trace_common.h +++ b/runtime/trace_common.h @@ -47,7 +47,7 @@ class TimestampCounter { // access is disabled only for 32-bit processes even when 64-bit processes can accesses the // timer from user space. These are not reflected in the HWCAP_EVTSTRM capability.So just // fallback to clock_gettime on these processes. See b/289178149 for more discussion. - t = MicroTime(); + t = NanoTime(); #elif defined(__aarch64__) // See Arm Architecture Registers Armv8 section System Registers asm volatile("mrs %0, cntvct_el0" : "=r"(t)); @@ -59,7 +59,7 @@ class TimestampCounter { #elif defined(__riscv) asm volatile("rdtime %0" : "=r"(t)); #else - t = MicroTime(); + t = NanoTime(); #endif return t; } @@ -67,36 +67,36 @@ class TimestampCounter { static void InitializeTimestampCounters() { // It is sufficient to initialize this once for the entire execution. Just return if it is // already initialized. - if (tsc_to_microsec_scaling_factor > 0.0) { + if (tsc_to_nanosec_scaling_factor > 0.0) { return; } #if defined(__arm__) // On ARM 32 bit, we don't always have access to the timestamp counters from // user space. Seem comment in GetTimestamp for more details. - tsc_to_microsec_scaling_factor = 1.0; + tsc_to_nanosec_scaling_factor = 1.0; #elif defined(__aarch64__) - double seconds_to_microseconds = 1000 * 1000; + double seconds_to_nanoseconds = 1000 * 1000; uint64_t freq = 0; // See Arm Architecture Registers Armv8 section System Registers asm volatile("mrs %0, cntfrq_el0" : "=r"(freq)); if (freq == 0) { // It is expected that cntfrq_el0 is correctly setup during system initialization but some // devices don't do this. In such cases fall back to computing the frequency. See b/315139000. - tsc_to_microsec_scaling_factor = computeScalingFactor(); + tsc_to_nanosec_scaling_factor = computeScalingFactor(); } else { - tsc_to_microsec_scaling_factor = seconds_to_microseconds / static_cast<double>(freq); + tsc_to_nanosec_scaling_factor = seconds_to_nanoseconds / static_cast<double>(freq); } #elif defined(__i386__) || defined(__x86_64__) - tsc_to_microsec_scaling_factor = GetScalingFactorForX86(); + tsc_to_nanosec_scaling_factor = GetScalingFactorForX86(); #else - tsc_to_microsec_scaling_factor = 1.0; + tsc_to_nanosec_scaling_factor = 1.0; #endif } - static ALWAYS_INLINE uint64_t GetMicroTime(uint64_t counter) { - DCHECK(tsc_to_microsec_scaling_factor > 0.0) << tsc_to_microsec_scaling_factor; - return tsc_to_microsec_scaling_factor * counter; + static ALWAYS_INLINE uint64_t GetNanoTime(uint64_t counter) { + DCHECK(tsc_to_nanosec_scaling_factor > 0.0) << tsc_to_nanosec_scaling_factor; + return tsc_to_nanosec_scaling_factor * counter; } private: @@ -107,12 +107,12 @@ class TimestampCounter { // step using these two samples. However, that would require a change in Android Studio which is // the main consumer of these profiles. For now, just compute the frequency of tsc updates here. static double computeScalingFactor() { - uint64_t start = MicroTime(); + uint64_t start = NanoTime(); uint64_t start_tsc = GetTimestamp(); // Sleep for one millisecond. usleep(1000); uint64_t diff_tsc = GetTimestamp() - start_tsc; - uint64_t diff_time = MicroTime() - start; + uint64_t diff_time = NanoTime() - start; double scaling_factor = static_cast<double>(diff_time) / diff_tsc; DCHECK(scaling_factor > 0.0) << scaling_factor; return scaling_factor; @@ -150,18 +150,18 @@ class TimestampCounter { } double coreCrystalFreq = ecx; // frequency = coreCrystalFreq * (ebx / eax) - // scaling_factor = seconds_to_microseconds / frequency - // = seconds_to_microseconds * eax / (coreCrystalFreq * ebx) - double seconds_to_microseconds = 1000 * 1000; - double scaling_factor = (seconds_to_microseconds * eax) / (coreCrystalFreq * ebx); + // scaling_factor = seconds_to_nanoseconds / frequency + // = seconds_to_nanoseconds * eax / (coreCrystalFreq * ebx) + double seconds_to_nanoseconds = 1000 * 1000; + double scaling_factor = (seconds_to_nanoseconds * eax) / (coreCrystalFreq * ebx); return scaling_factor; } #endif - // Scaling factor to convert timestamp counter into wall clock time reported in micro seconds. + // Scaling factor to convert timestamp counter into wall clock time reported in nano seconds. // This is initialized at the start of tracing using the timestamp counter update frequency. // See InitializeTimestampCounters for more details. - static double tsc_to_microsec_scaling_factor; + static double tsc_to_nanosec_scaling_factor; }; } // namespace art |