qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-25 16:57:58 -07:00
Code Releases Activity

undo CL 9805043 / 776aba85ece8

Browse Source 
multiple failures on amd64

««« original CL description
runtime: introduce helper persistentalloc() function
It is a caching wrapper around SysAlloc() that can allocate small chunks.
Use it for symtab allocations. Reduces number of symtab walks from 4 to 3
(reduces buildfuncs time from 10ms to 7.5ms on a large binary,
reduces initial heap size by 680K on the same binary).
Also can be used for type info allocation, itab allocation.
There are also several places in GC where we do the same thing,
they can be changed to use persistentalloc().
Also can be used in FixAlloc, because each instance of FixAlloc allocates
in 128K regions, which is too eager.

R=golang-dev, daniel.morsing, khr
CC=golang-dev
https://golang.org/cl/9805043
»»»

R=golang-dev
CC=golang-dev
https://golang.org/cl/9822043
This commit is contained in:
Dmitriy Vyukov 2013-05-28 11:14:39 +04:00
parent 5166013f75
commit 828c68f8d8
3 changed files with 25 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
src/pkg/runtime/malloc.goc
View File

@ -496,53 +496,6 @@ runtime·MHeap_SysAlloc(MHeap *h, uintptr n)
return p;
}
static struct
{
Lock;
byte* pos;
byte* end;
} persistent;
enum
{
PersistentAllocChunk = 256<<10,
PersistentAllocMaxBlock = 64<<10, // VM reservation granularity is 64K on windows
};
// Wrapper around SysAlloc that can allocate small chunks.
// There is no associated free operation.
// Intended for things like function/type/debug-related persistent data.
// If align is 0, uses default align (currently 8).
void*
runtime·persistentalloc(uintptr size, uintptr align)
{
byte *p;
if(align) {
if(align&(align-1))
runtime·throw("persistentalloc: align is now a power of 2");
if(align > PageSize)
runtime·throw("persistentalloc: align is too large");
} else
align = 8;
if(size >= PersistentAllocMaxBlock)
return runtime·SysAlloc(size);
runtime·lock(&persistent);
persistent.pos = (byte*)ROUND((uintptr)persistent.pos, align);
if(persistent.pos + size > persistent.end) {
persistent.pos = runtime·SysAlloc(PersistentAllocChunk);
if(persistent.pos == nil) {
runtime·unlock(&persistent);
runtime·throw("runtime: cannot allocate memory");
}
persistent.end = persistent.pos + PersistentAllocChunk;
}
p = persistent.pos;
persistent.pos += size;
runtime·unlock(&persistent);
return p;
}
static Lock settype_lock;
void

1
src/pkg/runtime/malloc.h
View File

@ -445,7 +445,6 @@ void runtime·MHeap_MapBits(MHeap *h);
void runtime·MHeap_Scavenger(void);
void* runtime·mallocgc(uintptr size, uint32 flag, int32 dogc, int32 zeroed);
void* runtime·persistentalloc(uintptr size, uintptr align);
int32 runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **s);
void runtime·gc(int32 force);
void runtime·markallocated(void *v, uintptr n, bool noptr);

32
src/pkg/runtime/symtab.c
View File

@ -69,6 +69,11 @@ struct Sym
static uintptr mainoffset;
// A dynamically allocated string containing multiple substrings.
// Individual strings are slices of hugestring.
static String hugestring;
static int32 hugestring_len;
extern void main·main(void);
static uintptr
@ -283,6 +288,7 @@ makepath(byte *buf, int32 nbuf, byte *path)
return p - buf;
}
// appends p to hugestring
static String
gostringn(byte *p, int32 l)
{
@ -290,8 +296,13 @@ gostringn(byte *p, int32 l)
if(l == 0)
return runtime·emptystring;
if(hugestring.str == nil) {
hugestring_len += l;
return runtime·emptystring;
}
s.str = hugestring.str + hugestring.len;
s.len = l;
s.str = runtime·persistentalloc(l, 1);
hugestring.len += s.len;
runtime·memmove(s.str, p, l);
return s;
}
@ -322,6 +333,8 @@ dosrcline(Sym *sym)
switch(sym->symtype) {
case 't':
case 'T':
if(hugestring.str == nil)
break;
if(runtime·strcmp(sym->name, (byte*)"etext") == 0)
break;
f = &func[nfunc++];
@ -546,12 +559,11 @@ buildfuncs(void)
walksymtab(dofunc);
// Initialize tables.
// Memory obtained from runtime·persistentalloc() is not scanned by GC,
// this is fine because all pointers either point into sections of the executable
// or also obtained from persistentmalloc().
func = runtime·persistentalloc((nfunc+1)*sizeof func[0], 0);
// Can use FlagNoPointers - all pointers either point into sections of the executable
// or point into hugestring.
func = runtime·mallocgc((nfunc+1)*sizeof func[0], FlagNoPointers, 0, 1);
func[nfunc].entry = (uint64)etext;
fname = runtime·persistentalloc(nfname*sizeof fname[0], 0);
fname = runtime·mallocgc(nfname*sizeof fname[0], FlagNoPointers, 0, 1);
nfunc = 0;
lastvalue = 0;
walksymtab(dofunc);
@ -561,9 +573,15 @@ buildfuncs(void)
// record src file and line info for each func
files = runtime·malloc(maxfiles * sizeof(files[0]));
walksymtab(dosrcline);
walksymtab(dosrcline); // pass 1: determine hugestring_len
hugestring.str = runtime·mallocgc(hugestring_len, FlagNoPointers, 0, 0);
hugestring.len = 0;
walksymtab(dosrcline); // pass 2: fill and use hugestring
files = nil;
if(hugestring.len != hugestring_len)
runtime·throw("buildfunc: problem in initialization procedure");
m->nomemprof--;
}