75791bab05
Use the new -fgo-c-header option to build a header file for the Go
runtime code in libgo/go/runtime, and use the new header file in the C
runtime code in libgo/runtime. This will ensure that the Go code and C
code share the same data structures as we convert the runtime from C to
Go.
The new file libgo/go/runtime/runtime2.go is copied from the Go 1.7
release, and then edited to remove unnecessary data structures and
modify others for use with libgo.
The new file libgo/go/runtime/mcache.go is an initial version of the
same files in the Go 1.7 release, and will be replaced by the Go 1.7
file when we convert to the new memory allocator.
The new file libgo/go/runtime/type.go describes the gccgo version of the
reflection data structures, and replaces the Go 1.7 runtime file which
describes the gc version of those structures.
Using the new header file means changing a number of struct fields to
use Go naming conventions (that is, no underscores) and to rename
constants to have a leading underscore so that they are not exported
from the Go package. These names were updated in the C code.
The C code was also changed to drop the thread-local variable m, as was
done some time ago in the gc sources. Now the m field is always
accessed using g->m, where g is the single remaining thread-local
variable. This in turn required some adjustments to set g->m correctly
in all cases.
Also pass the new -fgo-compiling-runtime option when compiling the
runtime package, although that option doesn't do anything yet.
Reviewed-on: https://go-review.googlesource.com/28051
From-SVN: r239872
132 lines
3.2 KiB
C
132 lines
3.2 KiB
C
// 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.
|
|
|
|
#include "runtime.h"
|
|
#include "arch.h"
|
|
#include "malloc.h"
|
|
|
|
extern volatile intgo runtime_MemProfileRate
|
|
__asm__ (GOSYM_PREFIX "runtime.MemProfileRate");
|
|
|
|
// dummy MSpan that contains no free objects.
|
|
static MSpan emptymspan;
|
|
|
|
MCache*
|
|
runtime_allocmcache(void)
|
|
{
|
|
intgo rate;
|
|
MCache *c;
|
|
int32 i;
|
|
|
|
runtime_lock(&runtime_mheap);
|
|
c = runtime_FixAlloc_Alloc(&runtime_mheap.cachealloc);
|
|
runtime_unlock(&runtime_mheap);
|
|
runtime_memclr((byte*)c, sizeof(*c));
|
|
for(i = 0; i < _NumSizeClasses; i++)
|
|
c->alloc[i] = &emptymspan;
|
|
|
|
// Set first allocation sample size.
|
|
rate = runtime_MemProfileRate;
|
|
if(rate > 0x3fffffff) // make 2*rate not overflow
|
|
rate = 0x3fffffff;
|
|
if(rate != 0)
|
|
c->next_sample = runtime_fastrand1() % (2*rate);
|
|
|
|
return c;
|
|
}
|
|
|
|
void
|
|
runtime_freemcache(MCache *c)
|
|
{
|
|
runtime_MCache_ReleaseAll(c);
|
|
runtime_lock(&runtime_mheap);
|
|
runtime_purgecachedstats(c);
|
|
runtime_FixAlloc_Free(&runtime_mheap.cachealloc, c);
|
|
runtime_unlock(&runtime_mheap);
|
|
}
|
|
|
|
// 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.
|
|
MSpan*
|
|
runtime_MCache_Refill(MCache *c, int32 sizeclass)
|
|
{
|
|
MCacheList *l;
|
|
MSpan *s;
|
|
|
|
runtime_m()->locks++;
|
|
// Return the current cached span to the central lists.
|
|
s = c->alloc[sizeclass];
|
|
if(s->freelist != nil)
|
|
runtime_throw("refill on a nonempty span");
|
|
if(s != &emptymspan)
|
|
runtime_MCentral_UncacheSpan(&runtime_mheap.central[sizeclass], s);
|
|
|
|
// Push any explicitly freed objects to the central lists.
|
|
// Not required, but it seems like a good time to do it.
|
|
l = &c->free[sizeclass];
|
|
if(l->nlist > 0) {
|
|
runtime_MCentral_FreeList(&runtime_mheap.central[sizeclass], l->list);
|
|
l->list = nil;
|
|
l->nlist = 0;
|
|
}
|
|
|
|
// Get a new cached span from the central lists.
|
|
s = runtime_MCentral_CacheSpan(&runtime_mheap.central[sizeclass]);
|
|
if(s == nil)
|
|
runtime_throw("out of memory");
|
|
if(s->freelist == nil) {
|
|
runtime_printf("%d %d\n", s->ref, (int32)((s->npages << PageShift) / s->elemsize));
|
|
runtime_throw("empty span");
|
|
}
|
|
c->alloc[sizeclass] = s;
|
|
runtime_m()->locks--;
|
|
return s;
|
|
}
|
|
|
|
void
|
|
runtime_MCache_Free(MCache *c, MLink *p, int32 sizeclass, uintptr size)
|
|
{
|
|
MCacheList *l;
|
|
|
|
// Put on free list.
|
|
l = &c->free[sizeclass];
|
|
p->next = l->list;
|
|
l->list = p;
|
|
l->nlist++;
|
|
|
|
// We transfer a span at a time from MCentral to MCache,
|
|
// so we'll do the same in the other direction.
|
|
if(l->nlist >= (runtime_class_to_allocnpages[sizeclass]<<PageShift)/size) {
|
|
runtime_MCentral_FreeList(&runtime_mheap.central[sizeclass], l->list);
|
|
l->list = nil;
|
|
l->nlist = 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
runtime_MCache_ReleaseAll(MCache *c)
|
|
{
|
|
int32 i;
|
|
MSpan *s;
|
|
MCacheList *l;
|
|
|
|
for(i=0; i<_NumSizeClasses; i++) {
|
|
s = c->alloc[i];
|
|
if(s != &emptymspan) {
|
|
runtime_MCentral_UncacheSpan(&runtime_mheap.central[i], s);
|
|
c->alloc[i] = &emptymspan;
|
|
}
|
|
l = &c->free[i];
|
|
if(l->nlist > 0) {
|
|
runtime_MCentral_FreeList(&runtime_mheap.central[i], l->list);
|
|
l->list = nil;
|
|
l->nlist = 0;
|
|
}
|
|
}
|
|
}
|