130 lines
2.8 KiB
C
130 lines
2.8 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-thread (in Go, per-M) malloc cache for small objects.
|
|
//
|
|
// See malloc.h for an overview.
|
|
|
|
#include "runtime.h"
|
|
#include "arch.h"
|
|
#include "malloc.h"
|
|
|
|
void*
|
|
runtime_MCache_Alloc(MCache *c, int32 sizeclass, uintptr size, int32 zeroed)
|
|
{
|
|
MCacheList *l;
|
|
MLink *first, *v;
|
|
int32 n;
|
|
|
|
// Allocate from list.
|
|
l = &c->list[sizeclass];
|
|
if(l->list == nil) {
|
|
// Replenish using central lists.
|
|
n = runtime_MCentral_AllocList(&runtime_mheap.central[sizeclass],
|
|
runtime_class_to_transfercount[sizeclass], &first);
|
|
if(n == 0)
|
|
runtime_throw("out of memory");
|
|
l->list = first;
|
|
l->nlist = n;
|
|
c->size += n*size;
|
|
}
|
|
v = l->list;
|
|
l->list = v->next;
|
|
l->nlist--;
|
|
if(l->nlist < l->nlistmin)
|
|
l->nlistmin = l->nlist;
|
|
c->size -= size;
|
|
|
|
// v is zeroed except for the link pointer
|
|
// that we used above; zero that.
|
|
v->next = nil;
|
|
if(zeroed) {
|
|
// block is zeroed iff second word is zero ...
|
|
if(size > sizeof(uintptr) && ((uintptr*)v)[1] != 0)
|
|
runtime_memclr((byte*)v, size);
|
|
}
|
|
c->local_cachealloc += size;
|
|
c->local_objects++;
|
|
return v;
|
|
}
|
|
|
|
// Take n elements off l and return them to the central free list.
|
|
static void
|
|
ReleaseN(MCache *c, MCacheList *l, int32 n, int32 sizeclass)
|
|
{
|
|
MLink *first, **lp;
|
|
int32 i;
|
|
|
|
// Cut off first n elements.
|
|
first = l->list;
|
|
lp = &l->list;
|
|
for(i=0; i<n; i++)
|
|
lp = &(*lp)->next;
|
|
l->list = *lp;
|
|
*lp = nil;
|
|
l->nlist -= n;
|
|
if(l->nlist < l->nlistmin)
|
|
l->nlistmin = l->nlist;
|
|
c->size -= n*runtime_class_to_size[sizeclass];
|
|
|
|
// Return them to central free list.
|
|
runtime_MCentral_FreeList(&runtime_mheap.central[sizeclass], n, first);
|
|
}
|
|
|
|
void
|
|
runtime_MCache_Free(MCache *c, void *v, int32 sizeclass, uintptr size)
|
|
{
|
|
int32 i, n;
|
|
MCacheList *l;
|
|
MLink *p;
|
|
|
|
// Put back on list.
|
|
l = &c->list[sizeclass];
|
|
p = v;
|
|
p->next = l->list;
|
|
l->list = p;
|
|
l->nlist++;
|
|
c->size += size;
|
|
c->local_cachealloc -= size;
|
|
c->local_objects--;
|
|
|
|
if(l->nlist >= MaxMCacheListLen) {
|
|
// Release a chunk back.
|
|
ReleaseN(c, l, runtime_class_to_transfercount[sizeclass], sizeclass);
|
|
}
|
|
|
|
if(c->size >= MaxMCacheSize) {
|
|
// Scavenge.
|
|
for(i=0; i<NumSizeClasses; i++) {
|
|
l = &c->list[i];
|
|
n = l->nlistmin;
|
|
|
|
// n is the minimum number of elements we've seen on
|
|
// the list since the last scavenge. If n > 0, it means that
|
|
// we could have gotten by with n fewer elements
|
|
// without needing to consult the central free list.
|
|
// Move toward that situation by releasing n/2 of them.
|
|
if(n > 0) {
|
|
if(n > 1)
|
|
n /= 2;
|
|
ReleaseN(c, l, n, i);
|
|
}
|
|
l->nlistmin = l->nlist;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
runtime_MCache_ReleaseAll(MCache *c)
|
|
{
|
|
int32 i;
|
|
MCacheList *l;
|
|
|
|
for(i=0; i<NumSizeClasses; i++) {
|
|
l = &c->list[i];
|
|
ReleaseN(c, l, l->nlist, i);
|
|
l->nlistmin = 0;
|
|
}
|
|
}
|