mirror of
https://github.com/golang/go
synced 2024-10-04 19:21:21 -06: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
87 lines
1.9 KiB
Go
87 lines
1.9 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.
|
|
|
|
// Per-P malloc cache for small objects.
|
|
//
|
|
// See malloc.h for an overview.
|
|
|
|
package runtime
|
|
|
|
import "unsafe"
|
|
|
|
// dummy MSpan that contains no free objects.
|
|
var emptymspan mspan
|
|
|
|
func allocmcache() *mcache {
|
|
lock(&mheap_.lock)
|
|
c := (*mcache)(fixAlloc_Alloc(&mheap_.cachealloc))
|
|
unlock(&mheap_.lock)
|
|
memclr(unsafe.Pointer(c), unsafe.Sizeof(*c))
|
|
for i := 0; i < _NumSizeClasses; i++ {
|
|
c.alloc[i] = &emptymspan
|
|
}
|
|
|
|
// Set first allocation sample size.
|
|
rate := MemProfileRate
|
|
if rate > 0x3fffffff { // make 2*rate not overflow
|
|
rate = 0x3fffffff
|
|
}
|
|
if rate != 0 {
|
|
c.next_sample = int32(int(fastrand1()) % (2 * rate))
|
|
}
|
|
|
|
return c
|
|
}
|
|
|
|
func freemcache(c *mcache) {
|
|
systemstack(func() {
|
|
mCache_ReleaseAll(c)
|
|
stackcache_clear(c)
|
|
gcworkbuffree(c.gcworkbuf)
|
|
lock(&mheap_.lock)
|
|
purgecachedstats(c)
|
|
fixAlloc_Free(&mheap_.cachealloc, unsafe.Pointer(c))
|
|
unlock(&mheap_.lock)
|
|
})
|
|
}
|
|
|
|
// Gets a span that has a free object in it and assigns it
|
|
// to be the cached span for the given sizeclass. Returns this span.
|
|
func mCache_Refill(c *mcache, sizeclass int32) *mspan {
|
|
_g_ := getg()
|
|
|
|
_g_.m.locks++
|
|
// Return the current cached span to the central lists.
|
|
s := c.alloc[sizeclass]
|
|
if s.freelist != nil {
|
|
gothrow("refill on a nonempty span")
|
|
}
|
|
if s != &emptymspan {
|
|
s.incache = false
|
|
}
|
|
|
|
// Get a new cached span from the central lists.
|
|
s = mCentral_CacheSpan(&mheap_.central[sizeclass].mcentral)
|
|
if s == nil {
|
|
gothrow("out of memory")
|
|
}
|
|
if s.freelist == nil {
|
|
println(s.ref, (s.npages<<_PageShift)/s.elemsize)
|
|
gothrow("empty span")
|
|
}
|
|
c.alloc[sizeclass] = s
|
|
_g_.m.locks--
|
|
return s
|
|
}
|
|
|
|
func mCache_ReleaseAll(c *mcache) {
|
|
for i := 0; i < _NumSizeClasses; i++ {
|
|
s := c.alloc[i]
|
|
if s != &emptymspan {
|
|
mCentral_UncacheSpan(&mheap_.central[i].mcentral, s)
|
|
c.alloc[i] = &emptymspan
|
|
}
|
|
}
|
|
}
|