mirror of
https://github.com/golang/go
synced 2024-11-20 05:44:44 -07:00
656be317d0
Scalararg and ptrarg are not "signal safe". Go code filling them out can be interrupted by a signal, and then the signal handler runs, and if it also ends up in Go code that uses scalararg or ptrarg, now the old values have been smashed. For the pieces of code that do need to run in a signal handler, we introduced onM_signalok, which is really just onM except that the _signalok is meant to convey that the caller asserts that scalarg and ptrarg will be restored to their old values after the call (instead of the usual behavior, zeroing them). Scalararg and ptrarg are also untyped and therefore error-prone. Go code can always pass a closure instead of using scalararg and ptrarg; they were only really necessary for C code. And there's no more C code. For all these reasons, delete scalararg and ptrarg, converting the few remaining references to use closures. Once those are gone, there is no need for a distinction between onM and onM_signalok, so replace both with a single function equivalent to the current onM_signalok (that is, it can be called on any of the curg, g0, and gsignal stacks). The name onM and the phrase 'm stack' are misnomers, because on most system an M has two system stacks: the main thread stack and the signal handling stack. Correct the misnomer by naming the replacement function systemstack. Fix a few references to "M stack" in code. The main motivation for this change is to eliminate scalararg/ptrarg. Rick and I have already seen them cause problems because the calling sequence m.ptrarg[0] = p is a heap pointer assignment, so it gets a write barrier. The write barrier also uses onM, so it has all the same problems as if it were being invoked by a signal handler. We worked around this by saving and restoring the old values and by calling onM_signalok, but there's no point in keeping this nice home for bugs around any longer. This CL also changes funcline to return the file name as a result instead of filling in a passed-in *string. (The *string signature is left over from when the code was written in and called from C.) That's arguably an unrelated change, except that once I had done the ptrarg/scalararg/onM cleanup I started getting false positives about the *string argument escaping (not allowed in package runtime). The compiler is wrong, but the easiest fix is to write the code like Go code instead of like C code. I am a bit worried that the compiler is wrong because of some use of uninitialized memory in the escape analysis. If that's the reason, it will go away when we convert the compiler to Go. (And if not, we'll debug it the next time.) LGTM=khr R=r, khr CC=austin, golang-codereviews, iant, rlh https://golang.org/cl/174950043
115 lines
3.4 KiB
Go
115 lines
3.4 KiB
Go
// Copyright 2009 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 runtime
|
|
|
|
import "unsafe"
|
|
|
|
// Note: the MemStats struct should be kept in sync with
|
|
// struct MStats in malloc.h
|
|
|
|
// A MemStats records statistics about the memory allocator.
|
|
type MemStats struct {
|
|
// General statistics.
|
|
Alloc uint64 // bytes allocated and still in use
|
|
TotalAlloc uint64 // bytes allocated (even if freed)
|
|
Sys uint64 // bytes obtained from system (sum of XxxSys below)
|
|
Lookups uint64 // number of pointer lookups
|
|
Mallocs uint64 // number of mallocs
|
|
Frees uint64 // number of frees
|
|
|
|
// Main allocation heap statistics.
|
|
HeapAlloc uint64 // bytes allocated and still in use
|
|
HeapSys uint64 // bytes obtained from system
|
|
HeapIdle uint64 // bytes in idle spans
|
|
HeapInuse uint64 // bytes in non-idle span
|
|
HeapReleased uint64 // bytes released to the OS
|
|
HeapObjects uint64 // total number of allocated objects
|
|
|
|
// Low-level fixed-size structure allocator statistics.
|
|
// Inuse is bytes used now.
|
|
// Sys is bytes obtained from system.
|
|
StackInuse uint64 // bytes used by stack allocator
|
|
StackSys uint64
|
|
MSpanInuse uint64 // mspan structures
|
|
MSpanSys uint64
|
|
MCacheInuse uint64 // mcache structures
|
|
MCacheSys uint64
|
|
BuckHashSys uint64 // profiling bucket hash table
|
|
GCSys uint64 // GC metadata
|
|
OtherSys uint64 // other system allocations
|
|
|
|
// Garbage collector statistics.
|
|
NextGC uint64 // next collection will happen when HeapAlloc ≥ this amount
|
|
LastGC uint64 // end time of last collection (nanoseconds since 1970)
|
|
PauseTotalNs uint64
|
|
PauseNs [256]uint64 // circular buffer of recent GC pause durations, most recent at [(NumGC+255)%256]
|
|
PauseEnd [256]uint64 // circular buffer of recent GC pause end times
|
|
NumGC uint32
|
|
EnableGC bool
|
|
DebugGC bool
|
|
|
|
// Per-size allocation statistics.
|
|
// 61 is NumSizeClasses in the C code.
|
|
BySize [61]struct {
|
|
Size uint32
|
|
Mallocs uint64
|
|
Frees uint64
|
|
}
|
|
}
|
|
|
|
// Size of the trailing by_size array differs between Go and C,
|
|
// and all data after by_size is local to runtime, not exported.
|
|
// NumSizeClasses was changed, but we can not change Go struct because of backward compatibility.
|
|
// sizeof_C_MStats is what C thinks about size of Go struct.
|
|
var sizeof_C_MStats = unsafe.Offsetof(memstats.by_size) + 61*unsafe.Sizeof(memstats.by_size[0])
|
|
|
|
func init() {
|
|
var memStats MemStats
|
|
if sizeof_C_MStats != unsafe.Sizeof(memStats) {
|
|
println(sizeof_C_MStats, unsafe.Sizeof(memStats))
|
|
gothrow("MStats vs MemStatsType size mismatch")
|
|
}
|
|
}
|
|
|
|
// ReadMemStats populates m with memory allocator statistics.
|
|
func ReadMemStats(m *MemStats) {
|
|
// Have to acquire worldsema to stop the world,
|
|
// because stoptheworld can only be used by
|
|
// one goroutine at a time, and there might be
|
|
// a pending garbage collection already calling it.
|
|
semacquire(&worldsema, false)
|
|
gp := getg()
|
|
gp.m.gcing = 1
|
|
systemstack(stoptheworld)
|
|
|
|
systemstack(func() {
|
|
readmemstats_m(m)
|
|
})
|
|
|
|
gp.m.gcing = 0
|
|
gp.m.locks++
|
|
semrelease(&worldsema)
|
|
systemstack(starttheworld)
|
|
gp.m.locks--
|
|
}
|
|
|
|
// Implementation of runtime/debug.WriteHeapDump
|
|
func writeHeapDump(fd uintptr) {
|
|
semacquire(&worldsema, false)
|
|
gp := getg()
|
|
gp.m.gcing = 1
|
|
systemstack(stoptheworld)
|
|
|
|
systemstack(func() {
|
|
writeheapdump_m(fd)
|
|
})
|
|
|
|
gp.m.gcing = 0
|
|
gp.m.locks++
|
|
semrelease(&worldsema)
|
|
systemstack(starttheworld)
|
|
gp.m.locks--
|
|
}
|