mirror of
https://github.com/golang/go
synced 2024-10-04 22:21:22 -06:00
472354f81e
Fixes #4090. R=golang-dev, iant, bradfitz, dsymonds CC=golang-dev https://golang.org/cl/7229070
102 lines
3.7 KiB
Go
102 lines
3.7 KiB
Go
// Copyright 2013 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package debug
|
|
|
|
import (
|
|
"runtime"
|
|
"sort"
|
|
"time"
|
|
)
|
|
|
|
// GCStats collect information about recent garbage collections.
|
|
type GCStats struct {
|
|
LastGC time.Time // time of last collection
|
|
NumGC int64 // number of garbage collections
|
|
PauseTotal time.Duration // total pause for all collections
|
|
Pause []time.Duration // pause history, most recent first
|
|
PauseQuantiles []time.Duration
|
|
}
|
|
|
|
// Implemented in package runtime.
|
|
func readGCStats(*[]time.Duration)
|
|
func enableGC(bool) bool
|
|
func setGCPercent(int) int
|
|
func freeOSMemory()
|
|
|
|
// ReadGCStats reads statistics about garbage collection into stats.
|
|
// The number of entries in the pause history is system-dependent;
|
|
// stats.Pause slice will be reused if large enough, reallocated otherwise.
|
|
// ReadGCStats may use the full capacity of the stats.Pause slice.
|
|
// If stats.PauseQuantiles is non-empty, ReadGCStats fills it with quantiles
|
|
// summarizing the distribution of pause time. For example, if
|
|
// len(stats.PauseQuantiles) is 5, it will be filled with the minimum,
|
|
// 25%, 50%, 75%, and maximum pause times.
|
|
func ReadGCStats(stats *GCStats) {
|
|
// Create a buffer with space for at least two copies of the
|
|
// pause history tracked by the runtime. One will be returned
|
|
// to the caller and the other will be used as a temporary buffer
|
|
// for computing quantiles.
|
|
const maxPause = len(((*runtime.MemStats)(nil)).PauseNs)
|
|
if cap(stats.Pause) < 2*maxPause {
|
|
stats.Pause = make([]time.Duration, 2*maxPause)
|
|
}
|
|
|
|
// readGCStats fills in the pause history (up to maxPause entries)
|
|
// and then three more: Unix ns time of last GC, number of GC,
|
|
// and total pause time in nanoseconds. Here we depend on the
|
|
// fact that time.Duration's native unit is nanoseconds, so the
|
|
// pauses and the total pause time do not need any conversion.
|
|
readGCStats(&stats.Pause)
|
|
n := len(stats.Pause) - 3
|
|
stats.LastGC = time.Unix(0, int64(stats.Pause[n]))
|
|
stats.NumGC = int64(stats.Pause[n+1])
|
|
stats.PauseTotal = stats.Pause[n+2]
|
|
stats.Pause = stats.Pause[:n]
|
|
|
|
if len(stats.PauseQuantiles) > 0 {
|
|
if n == 0 {
|
|
for i := range stats.PauseQuantiles {
|
|
stats.PauseQuantiles[i] = 0
|
|
}
|
|
} else {
|
|
// There's room for a second copy of the data in stats.Pause.
|
|
// See the allocation at the top of the function.
|
|
sorted := stats.Pause[n : n+n]
|
|
copy(sorted, stats.Pause)
|
|
sort.Sort(byDuration(sorted))
|
|
nq := len(stats.PauseQuantiles) - 1
|
|
for i := 0; i < nq; i++ {
|
|
stats.PauseQuantiles[i] = sorted[len(sorted)*i/nq]
|
|
}
|
|
stats.PauseQuantiles[nq] = sorted[len(sorted)-1]
|
|
}
|
|
}
|
|
}
|
|
|
|
type byDuration []time.Duration
|
|
|
|
func (x byDuration) Len() int { return len(x) }
|
|
func (x byDuration) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
|
|
func (x byDuration) Less(i, j int) bool { return x[i] < x[j] }
|
|
|
|
// SetGCPercent sets the garbage collection target percentage:
|
|
// a collection is triggered when the ratio of freshly allocated data
|
|
// to live data remaining after the previous collection reaches this percentage.
|
|
// SetGCPercent returns the previous setting.
|
|
// The initial setting is the value of the GOGC environment variable
|
|
// at startup, or 100 if the variable is not set.
|
|
// A negative percentage disables garbage collection.
|
|
func SetGCPercent(percent int) int {
|
|
return setGCPercent(percent)
|
|
}
|
|
|
|
// FreeOSMemory forces a garbage collection followed by an
|
|
// attempt to return as much memory to the operating system
|
|
// as possible. (Even if this is not called, the runtime gradually
|
|
// returns memory to the operating system in a background task.)
|
|
func FreeOSMemory() {
|
|
freeOSMemory()
|
|
}
|