func requireProgTimes(s *gcstats.GcStats) {
if !s.HaveProgTimes() {
fmt.Fprintln(os.Stderr,
"This analysis requires program execution times, which are missing from\n"+
"this GC trace. Please see 'go doc gcstats' for how to enable these.")
os.Exit(1)
}
}
func doMMU(s *gcstats.GcStats) {
// 1e9 ns = 1000 ms
windows := vec.Logspace(-3, 0, samples, 10)
plot := newPlot("granularity", windows, "--style", "mmu")
plot.addSeries("MMU", func(window float64) float64 {
return s.MMU(int(window * 1e9))
})
showPlot(plot)
}
func doStopCDF(s *gcstats.GcStats, kdes map[gcstats.PhaseKind]*stats.KDE) {
xs := jointAxis(kdes, float64(s.MaxPause())/1e9)
for _, kde := range kdes {
kde.Kernel = stats.DeltaKernel
}
plot := newPlot("pause time", xs)
for kind := gcstats.PhaseSweepTerm; kind <= gcstats.PhaseMultiple; kind++ {
if kde := kdes[kind]; kde != nil {
plot.addSeries(kind.String(), kde.CDF)
}
}
showPlot(plot)
}
func stopKDEs(s *gcstats.GcStats) map[gcstats.PhaseKind]*stats.KDE {
stops := s.Stops()
times := make(map[gcstats.PhaseKind]stats.Sample)
for _, stop := range stops {
s := times[stop.Kind]
s.Xs = append(s.Xs, float64(stop.Duration)/1e9)
times[stop.Kind] = s
}
kdes := make(map[gcstats.PhaseKind]*stats.KDE)
for kind, sample := range times {
// XXX Bandwidth
kdes[kind] = &stats.KDE{
Sample: sample,
//Bandwidth: stats.FixedBandwidth(100000),
BoundaryMethod: stats.BoundaryReflect,
BoundaryMax: math.Inf(1),
}
}
return kdes
}
func doMUDMap(s *gcstats.GcStats) {
windows := ints(vec.Logspace(6, 9, 100, 10))
muds := make([]*gcstats.MUD, len(windows))
for i, windowNS := range windows {
muds[i] = s.MutatorUtilizationDistribution(windowNS)
}
// gnuplot "nonuniform matrix" format
fmt.Printf("%d ", len(windows)+1)
for _, windowNS := range windows {
fmt.Printf("%d ", windowNS)
}
fmt.Print("\n")
utils := vec.Linspace(0, 1, 100)
for _, util := range utils {
fmt.Printf("%g ", util)
for _, mud := range muds {
fmt.Printf("%g ", mud.CDF(util))
}
fmt.Print("\n")
}
}
func doMUT(s *gcstats.GcStats) {
windows := vec.Logspace(-3, 0, samples, 10)
muds := make(map[float64]*gcstats.MUD)
for _, window := range windows {
muds[window] = s.MutatorUtilizationDistribution(int(window * 1e9))
}
plot := newPlot("granularity", windows, "--style", "mut")
type config struct {
label string
x float64
}
for _, c := range []config{
{"100%ile", 0},
{"99.9%ile", 0.001},
{"99%ile", 0.01},
{"90%ile", 0.1},
} {
plot.addSeries(c.label, func(x float64) float64 {
return muds[x].InvCDF(c.x)
})
}
showPlot(plot)
}
func doSummary(s *gcstats.GcStats) {
// Pause time: Max, 99th %ile, 95th %ile, mean
// Mutator utilization
// 50ms mutator utilization: Min, 1st %ile, 5th %ile
pauseTimes := stats.Sample{Xs: []float64{}}
for _, stop := range s.Stops() {
pauseTimes.Xs = append(pauseTimes.Xs, float64(stop.Duration))
}
pauseTimes.Sort()
fmt.Print("Pause times: max=", ns(pauseTimes.Percentile(1)), " 99th %ile=", ns(pauseTimes.Percentile(.99)), " 95th %ile=", ns(pauseTimes.Percentile(.95)), " mean=", ns(pauseTimes.Mean()), "\n")
if s.HaveProgTimes() {
fmt.Print("Mutator utilization: ", pct(s.MutatorUtilization()), "\n")
fmt.Print("50ms mutator utilization: min=", pct(s.MMUs([]int{50000000})[0]), "\n")
}
}