1 // Copyright 2023 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 //go:build goexperiment.exectracer2 6 7 // Trace time and clock. 8 9 package runtime 10 11 import "internal/goarch" 12 13 // Timestamps in trace are produced through either nanotime or cputicks 14 // and divided by traceTimeDiv. nanotime is used everywhere except on 15 // platforms where osHasLowResClock is true, because the system clock 16 // isn't granular enough to get useful information out of a trace in 17 // many cases. 18 // 19 // This makes absolute values of timestamp diffs smaller, and so they are 20 // encoded in fewer bytes. 21 // 22 // The target resolution in all cases is 64 nanoseconds. 23 // This is based on the fact that fundamentally the execution tracer won't emit 24 // events more frequently than roughly every 200 ns or so, because that's roughly 25 // how long it takes to call through the scheduler. 26 // We could be more aggressive and bump this up to 128 ns while still getting 27 // useful data, but the extra bit doesn't save us that much and the headroom is 28 // nice to have. 29 // 30 // Hitting this target resolution is easy in the nanotime case: just pick a 31 // division of 64. In the cputicks case it's a bit more complex. 32 // 33 // For x86, on a 3 GHz machine, we'd want to divide by 3*64 to hit our target. 34 // To keep the division operation efficient, we round that up to 4*64, or 256. 35 // Given what cputicks represents, we use this on all other platforms except 36 // for PowerPC. 37 // The suggested increment frequency for PowerPC's time base register is 38 // 512 MHz according to Power ISA v2.07 section 6.2, so we use 32 on ppc64 39 // and ppc64le. 40 const traceTimeDiv = (1-osHasLowResClockInt)*64 + osHasLowResClockInt*(256-224*(goarch.IsPpc64|goarch.IsPpc64le)) 41 42 // traceTime represents a timestamp for the trace. 43 type traceTime uint64 44 45 // traceClockNow returns a monotonic timestamp. The clock this function gets 46 // the timestamp from is specific to tracing, and shouldn't be mixed with other 47 // clock sources. 48 // 49 // nosplit because it's called from exitsyscall, which is nosplit. 50 // 51 //go:nosplit 52 func traceClockNow() traceTime { 53 if osHasLowResClock { 54 return traceTime(cputicks() / traceTimeDiv) 55 } 56 return traceTime(nanotime() / traceTimeDiv) 57 } 58 59 // traceClockUnitsPerSecond estimates the number of trace clock units per 60 // second that elapse. 61 func traceClockUnitsPerSecond() uint64 { 62 if osHasLowResClock { 63 // We're using cputicks as our clock, so we need a real estimate. 64 return uint64(ticksPerSecond() / traceTimeDiv) 65 } 66 // Our clock is nanotime, so it's just the constant time division. 67 // (trace clock units / nanoseconds) * (1e9 nanoseconds / 1 second) 68 return uint64(1.0 / float64(traceTimeDiv) * 1e9) 69 } 70 71 // traceFrequency writes a batch with a single EvFrequency event. 72 // 73 // freq is the number of trace clock units per second. 74 func traceFrequency(gen uintptr) { 75 w := unsafeTraceWriter(gen, nil) 76 77 // Ensure we have a place to write to. 78 w, _ = w.ensure(1 + traceBytesPerNumber /* traceEvFrequency + frequency */) 79 80 // Write out the string. 81 w.byte(byte(traceEvFrequency)) 82 w.varint(traceClockUnitsPerSecond()) 83 84 // Immediately flush the buffer. 85 systemstack(func() { 86 lock(&trace.lock) 87 traceBufFlush(w.traceBuf, gen) 88 unlock(&trace.lock) 89 }) 90 } 91