2008-12-18 16:42:28 -07:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
// See malloc.h for overview.
|
|
|
|
//
|
|
|
|
// TODO(rsc): double-check stats.
|
|
|
|
|
2010-02-03 17:31:34 -07:00
|
|
|
package runtime
|
2008-12-18 16:42:28 -07:00
|
|
|
#include "runtime.h"
|
2011-12-16 13:33:58 -07:00
|
|
|
#include "arch_GOARCH.h"
|
2008-12-18 16:42:28 -07:00
|
|
|
#include "malloc.h"
|
2010-02-03 17:31:34 -07:00
|
|
|
#include "type.h"
|
2012-06-06 15:20:02 -06:00
|
|
|
#include "typekind.h"
|
2012-10-07 12:05:32 -06:00
|
|
|
#include "race.h"
|
2013-07-17 10:52:37 -06:00
|
|
|
#include "stack.h"
|
2008-12-18 16:42:28 -07:00
|
|
|
|
2013-07-19 07:47:40 -06:00
|
|
|
// Mark mheap as 'no pointers', it does not contain interesting pointers but occupies ~45K.
|
|
|
|
#pragma dataflag 16
|
2013-05-28 12:14:47 -06:00
|
|
|
MHeap runtime·mheap;
|
2012-02-21 20:08:42 -07:00
|
|
|
|
2013-01-25 18:57:06 -07:00
|
|
|
int32 runtime·checking;
|
|
|
|
|
2012-10-21 11:08:13 -06:00
|
|
|
extern MStats mstats; // defined in zruntime_def_$GOOS_$GOARCH.go
|
2008-12-18 16:42:28 -07:00
|
|
|
|
2012-09-24 12:58:34 -06:00
|
|
|
extern volatile intgo runtime·MemProfileRate;
|
2010-03-24 10:40:09 -06:00
|
|
|
|
2008-12-18 16:42:28 -07:00
|
|
|
// Allocate an object of at least size bytes.
|
|
|
|
// Small objects are allocated from the per-thread cache's free lists.
|
|
|
|
// Large objects (> 32 kB) are allocated straight from the heap.
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
// If the block will be freed with runtime·free(), typ must be 0.
|
2008-12-18 16:42:28 -07:00
|
|
|
void*
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
runtime·mallocgc(uintptr size, uintptr typ, uint32 flag)
|
2008-12-18 16:42:28 -07:00
|
|
|
{
|
2012-09-24 12:58:34 -06:00
|
|
|
int32 sizeclass;
|
|
|
|
intgo rate;
|
2008-12-18 16:42:28 -07:00
|
|
|
MCache *c;
|
2013-05-28 01:05:55 -06:00
|
|
|
MCacheList *l;
|
2008-12-18 16:42:28 -07:00
|
|
|
uintptr npages;
|
|
|
|
MSpan *s;
|
2013-05-28 01:05:55 -06:00
|
|
|
MLink *v;
|
2008-12-18 16:42:28 -07:00
|
|
|
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
if(runtime·gcwaiting && g != m->g0 && m->locks == 0 && !(flag & FlagNoInvokeGC))
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·gosched();
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
if(size == 0) {
|
|
|
|
// All 0-length allocations use this pointer.
|
|
|
|
// The language does not require the allocations to
|
|
|
|
// have distinct values.
|
|
|
|
return &runtime·zerobase;
|
|
|
|
}
|
2008-12-19 04:13:39 -07:00
|
|
|
if(m->mallocing)
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·throw("malloc/free - deadlock");
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
// Disable preemption during settype_flush.
|
|
|
|
// We can not use m->mallocing for this, because settype_flush calls mallocgc.
|
|
|
|
m->locks++;
|
2008-12-19 04:13:39 -07:00
|
|
|
m->mallocing = 1;
|
2008-12-18 16:42:28 -07:00
|
|
|
|
2012-09-24 18:08:05 -06:00
|
|
|
if(DebugTypeAtBlockEnd)
|
|
|
|
size += sizeof(uintptr);
|
|
|
|
|
2011-07-18 12:52:57 -06:00
|
|
|
c = m->mcache;
|
2008-12-18 16:42:28 -07:00
|
|
|
if(size <= MaxSmallSize) {
|
|
|
|
// Allocate from mcache free lists.
|
2013-05-15 01:02:33 -06:00
|
|
|
// Inlined version of SizeToClass().
|
|
|
|
if(size <= 1024-8)
|
|
|
|
sizeclass = runtime·size_to_class8[(size+7)>>3];
|
|
|
|
else
|
|
|
|
sizeclass = runtime·size_to_class128[(size-1024+127) >> 7];
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
size = runtime·class_to_size[sizeclass];
|
2013-05-28 01:05:55 -06:00
|
|
|
l = &c->list[sizeclass];
|
|
|
|
if(l->list == nil)
|
|
|
|
runtime·MCache_Refill(c, sizeclass);
|
|
|
|
v = l->list;
|
|
|
|
l->list = v->next;
|
|
|
|
l->nlist--;
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
if(!(flag & FlagNoZero)) {
|
2013-05-28 01:05:55 -06:00
|
|
|
v->next = nil;
|
|
|
|
// 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;
|
2008-12-19 04:13:39 -07:00
|
|
|
} else {
|
|
|
|
// TODO(rsc): Report tracebacks for very large allocations.
|
|
|
|
|
|
|
|
// Allocate directly from heap.
|
|
|
|
npages = size >> PageShift;
|
|
|
|
if((size & PageMask) != 0)
|
|
|
|
npages++;
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
s = runtime·MHeap_Alloc(&runtime·mheap, npages, 0, 1, !(flag & FlagNoZero));
|
2008-12-19 04:13:39 -07:00
|
|
|
if(s == nil)
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·throw("out of memory");
|
2013-05-30 22:32:20 -06:00
|
|
|
s->limit = (byte*)(s->start<<PageShift) + size;
|
2010-03-23 21:48:23 -06:00
|
|
|
size = npages<<PageShift;
|
2008-12-19 04:13:39 -07:00
|
|
|
v = (void*)(s->start << PageShift);
|
2008-12-18 16:42:28 -07:00
|
|
|
|
2010-02-10 22:23:08 -07:00
|
|
|
// setup for mark sweep
|
2011-02-02 21:03:47 -07:00
|
|
|
runtime·markspan(v, 0, 0, true);
|
2009-06-04 22:09:06 -06:00
|
|
|
}
|
2012-06-08 15:35:14 -06:00
|
|
|
|
2011-02-02 21:03:47 -07:00
|
|
|
if(!(flag & FlagNoGC))
|
|
|
|
runtime·markallocated(v, size, (flag&FlagNoPointers) != 0);
|
2009-01-26 18:37:05 -07:00
|
|
|
|
2012-09-24 18:08:05 -06:00
|
|
|
if(DebugTypeAtBlockEnd)
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
*(uintptr*)((uintptr)v+size-sizeof(uintptr)) = typ;
|
|
|
|
|
|
|
|
if(UseSpanType && !(flag & FlagNoPointers) && typ != 0) {
|
|
|
|
uintptr *buf, i;
|
|
|
|
|
|
|
|
buf = m->settype_buf;
|
|
|
|
i = m->settype_bufsize;
|
|
|
|
buf[i++] = (uintptr)v;
|
|
|
|
buf[i++] = typ;
|
|
|
|
m->settype_bufsize = i;
|
|
|
|
}
|
2012-09-24 18:08:05 -06:00
|
|
|
|
2008-12-19 04:13:39 -07:00
|
|
|
m->mallocing = 0;
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
if(UseSpanType && !(flag & FlagNoPointers) && typ != 0 && m->settype_bufsize == nelem(m->settype_buf))
|
|
|
|
runtime·settype_flush(m, false);
|
|
|
|
m->locks--;
|
|
|
|
if(m->locks == 0 && g->preempt) // restore the preemption request in case we've cleared it in newstack
|
2013-07-17 10:52:37 -06:00
|
|
|
g->stackguard0 = StackPreempt;
|
2009-12-03 18:22:23 -07:00
|
|
|
|
2011-02-02 21:03:47 -07:00
|
|
|
if(!(flag & FlagNoProfiling) && (rate = runtime·MemProfileRate) > 0) {
|
2010-03-24 10:40:09 -06:00
|
|
|
if(size >= rate)
|
|
|
|
goto profile;
|
|
|
|
if(m->mcache->next_sample > size)
|
|
|
|
m->mcache->next_sample -= size;
|
|
|
|
else {
|
|
|
|
// pick next profile time
|
2011-10-06 09:30:48 -06:00
|
|
|
// If you change this, also change allocmcache.
|
2010-03-24 10:40:09 -06:00
|
|
|
if(rate > 0x3fffffff) // make 2*rate not overflow
|
|
|
|
rate = 0x3fffffff;
|
2011-07-11 23:23:58 -06:00
|
|
|
m->mcache->next_sample = runtime·fastrand1() % (2*rate);
|
2010-03-24 10:40:09 -06:00
|
|
|
profile:
|
2011-10-06 09:42:51 -06:00
|
|
|
runtime·setblockspecial(v, true);
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·MProf_Malloc(v, size);
|
2010-03-23 21:48:23 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
if(!(flag & FlagNoInvokeGC) && mstats.heap_alloc >= mstats.next_gc)
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·gc(0);
|
2012-10-07 12:05:32 -06:00
|
|
|
|
|
|
|
if(raceenabled) {
|
|
|
|
runtime·racemalloc(v, size, m->racepc);
|
|
|
|
m->racepc = nil;
|
|
|
|
}
|
2008-12-19 04:13:39 -07:00
|
|
|
return v;
|
2008-12-18 16:42:28 -07:00
|
|
|
}
|
|
|
|
|
2009-01-26 18:37:05 -07:00
|
|
|
void*
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·malloc(uintptr size)
|
2009-01-26 18:37:05 -07:00
|
|
|
{
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
return runtime·mallocgc(size, 0, FlagNoInvokeGC);
|
2009-01-26 18:37:05 -07:00
|
|
|
}
|
|
|
|
|
2008-12-18 16:42:28 -07:00
|
|
|
// Free the object whose base pointer is v.
|
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·free(void *v)
|
2008-12-18 16:42:28 -07:00
|
|
|
{
|
2011-02-02 21:03:47 -07:00
|
|
|
int32 sizeclass;
|
2008-12-18 16:42:28 -07:00
|
|
|
MSpan *s;
|
|
|
|
MCache *c;
|
2011-02-02 21:03:47 -07:00
|
|
|
uint32 prof;
|
|
|
|
uintptr size;
|
2008-12-18 16:42:28 -07:00
|
|
|
|
2009-01-09 17:22:13 -07:00
|
|
|
if(v == nil)
|
|
|
|
return;
|
2011-02-02 21:03:47 -07:00
|
|
|
|
2012-01-10 13:56:25 -07:00
|
|
|
// If you change this also change mgc0.c:/^sweep,
|
2011-02-02 21:03:47 -07:00
|
|
|
// which has a copy of the guts of free.
|
2009-01-09 17:22:13 -07:00
|
|
|
|
2009-05-29 14:31:53 -06:00
|
|
|
if(m->mallocing)
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·throw("malloc/free - deadlock");
|
2009-05-29 14:31:53 -06:00
|
|
|
m->mallocing = 1;
|
|
|
|
|
2011-02-02 21:03:47 -07:00
|
|
|
if(!runtime·mlookup(v, nil, nil, &s)) {
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printf("free %p: not an allocated block\n", v);
|
|
|
|
runtime·throw("free runtime·mlookup");
|
2010-02-03 17:31:34 -07:00
|
|
|
}
|
2011-02-02 21:03:47 -07:00
|
|
|
prof = runtime·blockspecial(v);
|
2009-01-26 18:37:05 -07:00
|
|
|
|
2012-10-07 12:05:32 -06:00
|
|
|
if(raceenabled)
|
|
|
|
runtime·racefree(v);
|
|
|
|
|
2008-12-18 16:42:28 -07:00
|
|
|
// Find size class for v.
|
2010-02-10 22:23:08 -07:00
|
|
|
sizeclass = s->sizeclass;
|
2011-07-18 12:52:57 -06:00
|
|
|
c = m->mcache;
|
2008-12-18 16:42:28 -07:00
|
|
|
if(sizeclass == 0) {
|
2010-02-10 22:23:08 -07:00
|
|
|
// Large object.
|
2011-02-02 21:03:47 -07:00
|
|
|
size = s->npages<<PageShift;
|
2013-04-04 15:18:52 -06:00
|
|
|
*(uintptr*)(s->start<<PageShift) = (uintptr)0xfeedfeedfeedfeedll; // mark as "needs to be zeroed"
|
2011-02-16 11:21:20 -07:00
|
|
|
// Must mark v freed before calling unmarkspan and MHeap_Free:
|
|
|
|
// they might coalesce v into other spans and change the bitmap further.
|
|
|
|
runtime·markfreed(v, size);
|
2011-02-02 21:03:47 -07:00
|
|
|
runtime·unmarkspan(v, 1<<PageShift);
|
2013-05-28 12:14:47 -06:00
|
|
|
runtime·MHeap_Free(&runtime·mheap, s, 1);
|
2013-06-06 04:56:50 -06:00
|
|
|
c->local_nlargefree++;
|
|
|
|
c->local_largefree += size;
|
2010-02-10 22:23:08 -07:00
|
|
|
} else {
|
|
|
|
// Small object.
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
size = runtime·class_to_size[sizeclass];
|
2010-02-10 22:23:08 -07:00
|
|
|
if(size > sizeof(uintptr))
|
2013-04-04 15:18:52 -06:00
|
|
|
((uintptr*)v)[1] = (uintptr)0xfeedfeedfeedfeedll; // mark as "needs to be zeroed"
|
2011-02-16 11:21:20 -07:00
|
|
|
// Must mark v freed before calling MCache_Free:
|
|
|
|
// it might coalesce v and other blocks into a bigger span
|
|
|
|
// and change the bitmap further.
|
|
|
|
runtime·markfreed(v, size);
|
2013-06-06 04:56:50 -06:00
|
|
|
c->local_nsmallfree[sizeclass]++;
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·MCache_Free(c, v, sizeclass, size);
|
2008-12-18 16:42:28 -07:00
|
|
|
}
|
2011-02-02 21:03:47 -07:00
|
|
|
if(prof)
|
|
|
|
runtime·MProf_Free(v, size);
|
2009-05-29 14:31:53 -06:00
|
|
|
m->mallocing = 0;
|
2008-12-18 16:42:28 -07:00
|
|
|
}
|
|
|
|
|
2009-01-26 18:37:05 -07:00
|
|
|
int32
|
2011-02-02 21:03:47 -07:00
|
|
|
runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **sp)
|
2008-12-19 04:13:39 -07:00
|
|
|
{
|
2011-02-02 21:03:47 -07:00
|
|
|
uintptr n, i;
|
2009-02-11 18:54:03 -07:00
|
|
|
byte *p;
|
2008-12-19 04:13:39 -07:00
|
|
|
MSpan *s;
|
|
|
|
|
2011-07-18 12:52:57 -06:00
|
|
|
m->mcache->local_nlookup++;
|
2012-06-08 15:35:14 -06:00
|
|
|
if (sizeof(void*) == 4 && m->mcache->local_nlookup >= (1<<30)) {
|
|
|
|
// purge cache stats to prevent overflow
|
2013-05-28 12:14:47 -06:00
|
|
|
runtime·lock(&runtime·mheap);
|
2012-07-01 03:10:01 -06:00
|
|
|
runtime·purgecachedstats(m->mcache);
|
2013-05-28 12:14:47 -06:00
|
|
|
runtime·unlock(&runtime·mheap);
|
2012-06-08 15:35:14 -06:00
|
|
|
}
|
|
|
|
|
2013-05-28 12:14:47 -06:00
|
|
|
s = runtime·MHeap_LookupMaybe(&runtime·mheap, v);
|
2010-02-10 22:23:08 -07:00
|
|
|
if(sp)
|
|
|
|
*sp = s;
|
2008-12-19 04:13:39 -07:00
|
|
|
if(s == nil) {
|
2011-02-02 21:03:47 -07:00
|
|
|
runtime·checkfreed(v, 1);
|
2009-01-26 18:37:05 -07:00
|
|
|
if(base)
|
|
|
|
*base = nil;
|
|
|
|
if(size)
|
|
|
|
*size = 0;
|
|
|
|
return 0;
|
2008-12-19 04:13:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
p = (byte*)((uintptr)s->start<<PageShift);
|
|
|
|
if(s->sizeclass == 0) {
|
|
|
|
// Large object.
|
2009-01-26 18:37:05 -07:00
|
|
|
if(base)
|
|
|
|
*base = p;
|
|
|
|
if(size)
|
|
|
|
*size = s->npages<<PageShift;
|
|
|
|
return 1;
|
2008-12-19 04:13:39 -07:00
|
|
|
}
|
|
|
|
|
2012-09-24 18:08:05 -06:00
|
|
|
n = s->elemsize;
|
2011-07-18 12:52:57 -06:00
|
|
|
if(base) {
|
|
|
|
i = ((byte*)v - p)/n;
|
2009-01-26 18:37:05 -07:00
|
|
|
*base = p + i*n;
|
2011-07-18 12:52:57 -06:00
|
|
|
}
|
2009-01-26 18:37:05 -07:00
|
|
|
if(size)
|
|
|
|
*size = n;
|
2010-02-10 01:00:12 -07:00
|
|
|
|
2009-01-26 18:37:05 -07:00
|
|
|
return 1;
|
2008-12-19 04:13:39 -07:00
|
|
|
}
|
|
|
|
|
2008-12-18 16:42:28 -07:00
|
|
|
MCache*
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·allocmcache(void)
|
2008-12-18 16:42:28 -07:00
|
|
|
{
|
2012-09-24 12:58:34 -06:00
|
|
|
intgo rate;
|
2010-03-29 14:06:26 -06:00
|
|
|
MCache *c;
|
|
|
|
|
2013-05-28 12:14:47 -06:00
|
|
|
runtime·lock(&runtime·mheap);
|
|
|
|
c = runtime·FixAlloc_Alloc(&runtime·mheap.cachealloc);
|
|
|
|
mstats.mcache_inuse = runtime·mheap.cachealloc.inuse;
|
|
|
|
mstats.mcache_sys = runtime·mheap.cachealloc.sys;
|
|
|
|
runtime·unlock(&runtime·mheap);
|
2012-07-01 03:10:01 -06:00
|
|
|
runtime·memclr((byte*)c, sizeof(*c));
|
2011-10-06 09:30:48 -06:00
|
|
|
|
|
|
|
// Set first allocation sample size.
|
|
|
|
rate = runtime·MemProfileRate;
|
|
|
|
if(rate > 0x3fffffff) // make 2*rate not overflow
|
|
|
|
rate = 0x3fffffff;
|
2011-10-16 01:49:24 -06:00
|
|
|
if(rate != 0)
|
|
|
|
c->next_sample = runtime·fastrand1() % (2*rate);
|
2011-10-06 09:30:48 -06:00
|
|
|
|
2010-03-29 14:06:26 -06:00
|
|
|
return c;
|
2008-12-18 16:42:28 -07:00
|
|
|
}
|
|
|
|
|
2011-07-18 12:52:57 -06:00
|
|
|
void
|
2012-07-01 03:10:01 -06:00
|
|
|
runtime·freemcache(MCache *c)
|
2011-07-18 12:52:57 -06:00
|
|
|
{
|
2012-07-01 03:10:01 -06:00
|
|
|
runtime·MCache_ReleaseAll(c);
|
2013-05-28 12:14:47 -06:00
|
|
|
runtime·lock(&runtime·mheap);
|
2012-07-01 03:10:01 -06:00
|
|
|
runtime·purgecachedstats(c);
|
2013-05-28 12:14:47 -06:00
|
|
|
runtime·FixAlloc_Free(&runtime·mheap.cachealloc, c);
|
|
|
|
runtime·unlock(&runtime·mheap);
|
2012-07-01 03:10:01 -06:00
|
|
|
}
|
2011-07-18 12:52:57 -06:00
|
|
|
|
2012-07-01 03:10:01 -06:00
|
|
|
void
|
|
|
|
runtime·purgecachedstats(MCache *c)
|
|
|
|
{
|
2013-06-06 04:56:50 -06:00
|
|
|
MHeap *h;
|
2013-05-22 12:22:57 -06:00
|
|
|
int32 i;
|
|
|
|
|
2011-07-18 12:52:57 -06:00
|
|
|
// Protected by either heap or GC lock.
|
2013-06-06 04:56:50 -06:00
|
|
|
h = &runtime·mheap;
|
2011-07-18 12:52:57 -06:00
|
|
|
mstats.heap_alloc += c->local_cachealloc;
|
|
|
|
c->local_cachealloc = 0;
|
|
|
|
mstats.nlookup += c->local_nlookup;
|
|
|
|
c->local_nlookup = 0;
|
2013-06-06 04:56:50 -06:00
|
|
|
h->largefree += c->local_largefree;
|
|
|
|
c->local_largefree = 0;
|
|
|
|
h->nlargefree += c->local_nlargefree;
|
|
|
|
c->local_nlargefree = 0;
|
|
|
|
for(i=0; i<nelem(c->local_nsmallfree); i++) {
|
|
|
|
h->nsmallfree[i] += c->local_nsmallfree[i];
|
|
|
|
c->local_nsmallfree[i] = 0;
|
2013-05-22 12:22:57 -06:00
|
|
|
}
|
2011-07-18 12:52:57 -06:00
|
|
|
}
|
|
|
|
|
2011-06-17 14:12:14 -06:00
|
|
|
uintptr runtime·sizeof_C_MStats = sizeof(MStats);
|
2010-12-13 14:22:19 -07:00
|
|
|
|
2011-02-02 21:03:47 -07:00
|
|
|
#define MaxArena32 (2U<<30)
|
|
|
|
|
2008-12-18 16:42:28 -07:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·mallocinit(void)
|
2008-12-18 16:42:28 -07:00
|
|
|
{
|
2011-01-28 13:03:26 -07:00
|
|
|
byte *p;
|
2013-05-28 12:04:34 -06:00
|
|
|
uintptr arena_size, bitmap_size, spans_size;
|
2011-02-02 21:03:47 -07:00
|
|
|
extern byte end[];
|
2011-08-31 05:02:46 -06:00
|
|
|
byte *want;
|
2012-02-24 13:28:51 -07:00
|
|
|
uintptr limit;
|
2013-06-12 08:47:16 -06:00
|
|
|
uint64 i;
|
2011-01-28 13:03:26 -07:00
|
|
|
|
2012-02-08 15:25:10 -07:00
|
|
|
p = nil;
|
2012-02-08 22:48:52 -07:00
|
|
|
arena_size = 0;
|
|
|
|
bitmap_size = 0;
|
2013-05-28 12:04:34 -06:00
|
|
|
spans_size = 0;
|
|
|
|
|
2012-02-08 22:48:52 -07:00
|
|
|
// for 64-bit build
|
|
|
|
USED(p);
|
|
|
|
USED(arena_size);
|
|
|
|
USED(bitmap_size);
|
2013-05-28 12:04:34 -06:00
|
|
|
USED(spans_size);
|
2012-02-08 15:25:10 -07:00
|
|
|
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·InitSizes();
|
2011-01-28 13:03:26 -07:00
|
|
|
|
2013-03-26 15:01:12 -06:00
|
|
|
// limit = runtime·memlimit();
|
|
|
|
// See https://code.google.com/p/go/issues/detail?id=5049
|
|
|
|
// TODO(rsc): Fix after 1.1.
|
|
|
|
limit = 0;
|
2012-02-24 13:28:51 -07:00
|
|
|
|
2011-02-02 21:03:47 -07:00
|
|
|
// Set up the allocation arena, a contiguous area of memory where
|
|
|
|
// allocated data will be found. The arena begins with a bitmap large
|
|
|
|
// enough to hold 4 bits per allocated word.
|
2012-02-24 13:28:51 -07:00
|
|
|
if(sizeof(void*) == 8 && (limit == 0 || limit > (1<<30))) {
|
2011-01-28 13:03:26 -07:00
|
|
|
// On a 64-bit machine, allocate from a single contiguous reservation.
|
2012-11-13 10:45:08 -07:00
|
|
|
// 128 GB (MaxMem) should be big enough for now.
|
2011-01-28 13:03:26 -07:00
|
|
|
//
|
|
|
|
// The code will work with the reservation at any address, but ask
|
2013-06-12 08:47:16 -06:00
|
|
|
// SysReserve to use 0x0000XXc000000000 if possible (XX=00...7f).
|
2012-11-13 10:45:08 -07:00
|
|
|
// Allocating a 128 GB region takes away 37 bits, and the amd64
|
2011-01-28 13:03:26 -07:00
|
|
|
// doesn't let us choose the top 17 bits, so that leaves the 11 bits
|
2012-11-13 10:45:08 -07:00
|
|
|
// in the middle of 0x00c0 for us to choose. Choosing 0x00c0 means
|
2013-06-12 08:47:16 -06:00
|
|
|
// that the valid memory addresses will begin 0x00c0, 0x00c1, ..., 0x00df.
|
2012-11-13 10:45:08 -07:00
|
|
|
// In little-endian, that's c0 00, c1 00, ..., df 00. None of those are valid
|
|
|
|
// UTF-8 sequences, and they are otherwise as far away from
|
2013-06-12 08:47:16 -06:00
|
|
|
// ff (likely a common byte) as possible. If that fails, we try other 0xXXc0
|
|
|
|
// addresses. An earlier attempt to use 0x11f8 caused out of memory errors
|
|
|
|
// on OS X during thread allocations. 0x00c0 causes conflicts with
|
|
|
|
// AddressSanitizer which reserves all memory up to 0x0100.
|
2011-01-28 13:03:26 -07:00
|
|
|
// These choices are both for debuggability and to reduce the
|
|
|
|
// odds of the conservative garbage collector not collecting memory
|
|
|
|
// because some non-pointer block of memory had a bit pattern
|
|
|
|
// that matched a memory address.
|
2011-02-02 21:03:47 -07:00
|
|
|
//
|
2012-11-13 10:45:08 -07:00
|
|
|
// Actually we reserve 136 GB (because the bitmap ends up being 8 GB)
|
|
|
|
// but it hardly matters: e0 00 is not valid UTF-8 either.
|
2012-02-08 12:39:16 -07:00
|
|
|
//
|
|
|
|
// If this fails we fall back to the 32 bit memory mechanism
|
2012-11-13 10:45:08 -07:00
|
|
|
arena_size = MaxMem;
|
2011-02-02 21:03:47 -07:00
|
|
|
bitmap_size = arena_size / (sizeof(void*)*8/4);
|
2013-05-30 07:09:58 -06:00
|
|
|
spans_size = arena_size / PageSize * sizeof(runtime·mheap.spans[0]);
|
2013-06-13 06:02:50 -06:00
|
|
|
spans_size = ROUND(spans_size, PageSize);
|
2013-06-12 08:47:16 -06:00
|
|
|
for(i = 0; i <= 0x7f; i++) {
|
|
|
|
p = (void*)(i<<40 | 0x00c0ULL<<32);
|
|
|
|
p = runtime·SysReserve(p, bitmap_size + spans_size + arena_size);
|
|
|
|
if(p != nil)
|
|
|
|
break;
|
|
|
|
}
|
2012-02-08 12:39:16 -07:00
|
|
|
}
|
|
|
|
if (p == nil) {
|
2011-02-02 21:03:47 -07:00
|
|
|
// On a 32-bit machine, we can't typically get away
|
|
|
|
// with a giant virtual address space reservation.
|
|
|
|
// Instead we map the memory information bitmap
|
|
|
|
// immediately after the data segment, large enough
|
|
|
|
// to handle another 2GB of mappings (256 MB),
|
|
|
|
// along with a reservation for another 512 MB of memory.
|
|
|
|
// When that gets used up, we'll start asking the kernel
|
|
|
|
// for any memory anywhere and hope it's in the 2GB
|
|
|
|
// following the bitmap (presumably the executable begins
|
|
|
|
// near the bottom of memory, so we'll have to use up
|
|
|
|
// most of memory before the kernel resorts to giving out
|
|
|
|
// memory before the beginning of the text segment).
|
|
|
|
//
|
|
|
|
// Alternatively we could reserve 512 MB bitmap, enough
|
|
|
|
// for 4GB of mappings, and then accept any memory the
|
|
|
|
// kernel threw at us, but normally that's a waste of 512 MB
|
|
|
|
// of address space, which is probably too much in a 32-bit world.
|
|
|
|
bitmap_size = MaxArena32 / (sizeof(void*)*8/4);
|
|
|
|
arena_size = 512<<20;
|
2013-05-30 07:09:58 -06:00
|
|
|
spans_size = MaxArena32 / PageSize * sizeof(runtime·mheap.spans[0]);
|
2013-05-28 12:04:34 -06:00
|
|
|
if(limit > 0 && arena_size+bitmap_size+spans_size > limit) {
|
2012-02-24 13:28:51 -07:00
|
|
|
bitmap_size = (limit / 9) & ~((1<<PageShift) - 1);
|
|
|
|
arena_size = bitmap_size * 8;
|
2013-05-30 07:09:58 -06:00
|
|
|
spans_size = arena_size / PageSize * sizeof(runtime·mheap.spans[0]);
|
2012-02-24 13:28:51 -07:00
|
|
|
}
|
2013-06-13 06:02:50 -06:00
|
|
|
spans_size = ROUND(spans_size, PageSize);
|
2013-05-28 12:04:34 -06:00
|
|
|
|
2011-02-09 13:08:30 -07:00
|
|
|
// SysReserve treats the address we ask for, end, as a hint,
|
|
|
|
// not as an absolute requirement. If we ask for the end
|
|
|
|
// of the data segment but the operating system requires
|
|
|
|
// a little more space before we can start allocating, it will
|
2011-08-31 05:02:46 -06:00
|
|
|
// give out a slightly higher pointer. Except QEMU, which
|
|
|
|
// is buggy, as usual: it won't adjust the pointer upward.
|
|
|
|
// So adjust it upward a little bit ourselves: 1/4 MB to get
|
|
|
|
// away from the running binary image and then round up
|
|
|
|
// to a MB boundary.
|
2013-06-13 06:40:10 -06:00
|
|
|
want = (byte*)ROUND((uintptr)end + (1<<18), 1<<20);
|
2013-05-28 12:04:34 -06:00
|
|
|
p = runtime·SysReserve(want, bitmap_size + spans_size + arena_size);
|
2011-02-09 13:08:30 -07:00
|
|
|
if(p == nil)
|
|
|
|
runtime·throw("runtime: cannot reserve arena virtual address space");
|
2012-02-24 13:28:51 -07:00
|
|
|
if((uintptr)p & (((uintptr)1<<PageShift)-1))
|
2013-05-28 12:04:34 -06:00
|
|
|
runtime·printf("runtime: SysReserve returned unaligned address %p; asked for %p", p,
|
|
|
|
bitmap_size+spans_size+arena_size);
|
2011-01-28 13:03:26 -07:00
|
|
|
}
|
2011-02-11 12:32:34 -07:00
|
|
|
if((uintptr)p & (((uintptr)1<<PageShift)-1))
|
|
|
|
runtime·throw("runtime: SysReserve returned unaligned address");
|
|
|
|
|
2013-05-30 07:09:58 -06:00
|
|
|
runtime·mheap.spans = (MSpan**)p;
|
2013-05-28 12:14:47 -06:00
|
|
|
runtime·mheap.bitmap = p + spans_size;
|
|
|
|
runtime·mheap.arena_start = p + spans_size + bitmap_size;
|
|
|
|
runtime·mheap.arena_used = runtime·mheap.arena_start;
|
|
|
|
runtime·mheap.arena_end = runtime·mheap.arena_start + arena_size;
|
2011-01-28 13:03:26 -07:00
|
|
|
|
|
|
|
// Initialize the rest of the allocator.
|
2013-06-09 23:20:27 -06:00
|
|
|
runtime·MHeap_Init(&runtime·mheap);
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
m->mcache = runtime·allocmcache();
|
2008-12-18 16:42:28 -07:00
|
|
|
|
|
|
|
// See if it works.
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·free(runtime·malloc(1));
|
2008-12-18 16:42:28 -07:00
|
|
|
}
|
|
|
|
|
2011-01-28 13:03:26 -07:00
|
|
|
void*
|
|
|
|
runtime·MHeap_SysAlloc(MHeap *h, uintptr n)
|
|
|
|
{
|
|
|
|
byte *p;
|
2011-02-02 21:03:47 -07:00
|
|
|
|
2012-03-07 12:21:45 -07:00
|
|
|
if(n > h->arena_end - h->arena_used) {
|
|
|
|
// We are in 32-bit mode, maybe we didn't use all possible address space yet.
|
|
|
|
// Reserve some more space.
|
|
|
|
byte *new_end;
|
|
|
|
uintptr needed;
|
|
|
|
|
|
|
|
needed = (uintptr)h->arena_used + n - (uintptr)h->arena_end;
|
2013-06-13 06:02:50 -06:00
|
|
|
needed = ROUND(needed, 256<<20);
|
2012-03-07 12:21:45 -07:00
|
|
|
new_end = h->arena_end + needed;
|
|
|
|
if(new_end <= h->arena_start + MaxArena32) {
|
|
|
|
p = runtime·SysReserve(h->arena_end, new_end - h->arena_end);
|
|
|
|
if(p == h->arena_end)
|
|
|
|
h->arena_end = new_end;
|
|
|
|
}
|
|
|
|
}
|
2011-02-02 21:03:47 -07:00
|
|
|
if(n <= h->arena_end - h->arena_used) {
|
2011-01-28 13:03:26 -07:00
|
|
|
// Keep taking from our reservation.
|
|
|
|
p = h->arena_used;
|
|
|
|
runtime·SysMap(p, n);
|
|
|
|
h->arena_used += n;
|
2011-02-02 21:03:47 -07:00
|
|
|
runtime·MHeap_MapBits(h);
|
2013-05-28 12:04:34 -06:00
|
|
|
runtime·MHeap_MapSpans(h);
|
2012-11-07 01:48:58 -07:00
|
|
|
if(raceenabled)
|
|
|
|
runtime·racemapshadow(p, n);
|
2011-01-28 13:03:26 -07:00
|
|
|
return p;
|
|
|
|
}
|
2011-02-02 21:03:47 -07:00
|
|
|
|
2012-02-08 12:39:16 -07:00
|
|
|
// If using 64-bit, our reservation is all we have.
|
|
|
|
if(sizeof(void*) == 8 && (uintptr)h->bitmap >= 0xffffffffU)
|
2011-02-02 21:03:47 -07:00
|
|
|
return nil;
|
|
|
|
|
|
|
|
// On 32-bit, once the reservation is gone we can
|
|
|
|
// try to get memory at a location chosen by the OS
|
|
|
|
// and hope that it is in the range we allocated bitmap for.
|
|
|
|
p = runtime·SysAlloc(n);
|
|
|
|
if(p == nil)
|
|
|
|
return nil;
|
|
|
|
|
|
|
|
if(p < h->arena_start || p+n - h->arena_start >= MaxArena32) {
|
2012-03-07 12:21:45 -07:00
|
|
|
runtime·printf("runtime: memory allocated by OS (%p) not in usable range [%p,%p)\n",
|
|
|
|
p, h->arena_start, h->arena_start+MaxArena32);
|
2011-02-02 21:03:47 -07:00
|
|
|
runtime·SysFree(p, n);
|
|
|
|
return nil;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(p+n > h->arena_used) {
|
|
|
|
h->arena_used = p+n;
|
|
|
|
if(h->arena_used > h->arena_end)
|
|
|
|
h->arena_end = h->arena_used;
|
|
|
|
runtime·MHeap_MapBits(h);
|
2013-05-28 12:04:34 -06:00
|
|
|
runtime·MHeap_MapSpans(h);
|
2012-11-07 01:48:58 -07:00
|
|
|
if(raceenabled)
|
|
|
|
runtime·racemapshadow(p, n);
|
2011-02-02 21:03:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return p;
|
2011-01-28 13:03:26 -07:00
|
|
|
}
|
|
|
|
|
2013-05-31 00:42:30 -06:00
|
|
|
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;
|
|
|
|
|
2013-06-01 15:45:26 -06:00
|
|
|
if(align != 0) {
|
2013-05-31 00:42:30 -06:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-09-24 18:08:05 -06:00
|
|
|
static Lock settype_lock;
|
|
|
|
|
|
|
|
void
|
2012-12-18 09:30:29 -07:00
|
|
|
runtime·settype_flush(M *mp, bool sysalloc)
|
2012-09-24 18:08:05 -06:00
|
|
|
{
|
|
|
|
uintptr *buf, *endbuf;
|
|
|
|
uintptr size, ofs, j, t;
|
|
|
|
uintptr ntypes, nbytes2, nbytes3;
|
|
|
|
uintptr *data2;
|
|
|
|
byte *data3;
|
|
|
|
bool sysalloc3;
|
|
|
|
void *v;
|
|
|
|
uintptr typ, p;
|
|
|
|
MSpan *s;
|
|
|
|
|
2012-12-18 09:30:29 -07:00
|
|
|
buf = mp->settype_buf;
|
|
|
|
endbuf = buf + mp->settype_bufsize;
|
2012-09-24 18:08:05 -06:00
|
|
|
|
|
|
|
runtime·lock(&settype_lock);
|
|
|
|
while(buf < endbuf) {
|
|
|
|
v = (void*)*buf;
|
|
|
|
*buf = 0;
|
|
|
|
buf++;
|
|
|
|
typ = *buf;
|
|
|
|
buf++;
|
|
|
|
|
|
|
|
// (Manually inlined copy of runtime·MHeap_Lookup)
|
|
|
|
p = (uintptr)v>>PageShift;
|
|
|
|
if(sizeof(void*) == 8)
|
2013-05-28 12:14:47 -06:00
|
|
|
p -= (uintptr)runtime·mheap.arena_start >> PageShift;
|
2013-05-30 07:09:58 -06:00
|
|
|
s = runtime·mheap.spans[p];
|
2012-09-24 18:08:05 -06:00
|
|
|
|
|
|
|
if(s->sizeclass == 0) {
|
|
|
|
s->types.compression = MTypes_Single;
|
|
|
|
s->types.data = typ;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
size = s->elemsize;
|
|
|
|
ofs = ((uintptr)v - (s->start<<PageShift)) / size;
|
|
|
|
|
|
|
|
switch(s->types.compression) {
|
|
|
|
case MTypes_Empty:
|
|
|
|
ntypes = (s->npages << PageShift) / size;
|
|
|
|
nbytes3 = 8*sizeof(uintptr) + 1*ntypes;
|
|
|
|
|
|
|
|
if(!sysalloc) {
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
data3 = runtime·mallocgc(nbytes3, 0, FlagNoProfiling|FlagNoPointers|FlagNoInvokeGC);
|
2012-09-24 18:08:05 -06:00
|
|
|
} else {
|
|
|
|
data3 = runtime·SysAlloc(nbytes3);
|
2013-02-28 22:21:08 -07:00
|
|
|
if(data3 == nil)
|
|
|
|
runtime·throw("runtime: cannot allocate memory");
|
2012-09-24 18:08:05 -06:00
|
|
|
if(0) runtime·printf("settype(0->3): SysAlloc(%x) --> %p\n", (uint32)nbytes3, data3);
|
|
|
|
}
|
|
|
|
|
|
|
|
s->types.compression = MTypes_Bytes;
|
|
|
|
s->types.sysalloc = sysalloc;
|
|
|
|
s->types.data = (uintptr)data3;
|
|
|
|
|
|
|
|
((uintptr*)data3)[1] = typ;
|
|
|
|
data3[8*sizeof(uintptr) + ofs] = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MTypes_Words:
|
|
|
|
((uintptr*)s->types.data)[ofs] = typ;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MTypes_Bytes:
|
|
|
|
data3 = (byte*)s->types.data;
|
|
|
|
for(j=1; j<8; j++) {
|
|
|
|
if(((uintptr*)data3)[j] == typ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if(((uintptr*)data3)[j] == 0) {
|
|
|
|
((uintptr*)data3)[j] = typ;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(j < 8) {
|
|
|
|
data3[8*sizeof(uintptr) + ofs] = j;
|
|
|
|
} else {
|
|
|
|
ntypes = (s->npages << PageShift) / size;
|
|
|
|
nbytes2 = ntypes * sizeof(uintptr);
|
|
|
|
|
|
|
|
if(!sysalloc) {
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
data2 = runtime·mallocgc(nbytes2, 0, FlagNoProfiling|FlagNoPointers|FlagNoInvokeGC);
|
2012-09-24 18:08:05 -06:00
|
|
|
} else {
|
|
|
|
data2 = runtime·SysAlloc(nbytes2);
|
2013-02-28 22:21:08 -07:00
|
|
|
if(data2 == nil)
|
|
|
|
runtime·throw("runtime: cannot allocate memory");
|
2012-09-24 18:08:05 -06:00
|
|
|
if(0) runtime·printf("settype.(3->2): SysAlloc(%x) --> %p\n", (uint32)nbytes2, data2);
|
|
|
|
}
|
|
|
|
|
|
|
|
sysalloc3 = s->types.sysalloc;
|
|
|
|
|
|
|
|
s->types.compression = MTypes_Words;
|
|
|
|
s->types.sysalloc = sysalloc;
|
|
|
|
s->types.data = (uintptr)data2;
|
|
|
|
|
|
|
|
// Move the contents of data3 to data2. Then deallocate data3.
|
|
|
|
for(j=0; j<ntypes; j++) {
|
|
|
|
t = data3[8*sizeof(uintptr) + j];
|
|
|
|
t = ((uintptr*)data3)[t];
|
|
|
|
data2[j] = t;
|
|
|
|
}
|
|
|
|
if(sysalloc3) {
|
|
|
|
nbytes3 = 8*sizeof(uintptr) + 1*ntypes;
|
|
|
|
if(0) runtime·printf("settype.(3->2): SysFree(%p,%x)\n", data3, (uint32)nbytes3);
|
|
|
|
runtime·SysFree(data3, nbytes3);
|
|
|
|
}
|
|
|
|
|
|
|
|
data2[ofs] = typ;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
runtime·unlock(&settype_lock);
|
|
|
|
|
2012-12-18 09:30:29 -07:00
|
|
|
mp->settype_bufsize = 0;
|
2012-09-24 18:08:05 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
runtime·settype_sysfree(MSpan *s)
|
|
|
|
{
|
|
|
|
uintptr ntypes, nbytes;
|
|
|
|
|
|
|
|
if(!s->types.sysalloc)
|
|
|
|
return;
|
|
|
|
|
|
|
|
nbytes = (uintptr)-1;
|
|
|
|
|
|
|
|
switch (s->types.compression) {
|
|
|
|
case MTypes_Words:
|
|
|
|
ntypes = (s->npages << PageShift) / s->elemsize;
|
|
|
|
nbytes = ntypes * sizeof(uintptr);
|
|
|
|
break;
|
|
|
|
case MTypes_Bytes:
|
|
|
|
ntypes = (s->npages << PageShift) / s->elemsize;
|
|
|
|
nbytes = 8*sizeof(uintptr) + 1*ntypes;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(nbytes != (uintptr)-1) {
|
|
|
|
if(0) runtime·printf("settype: SysFree(%p,%x)\n", (void*)s->types.data, (uint32)nbytes);
|
|
|
|
runtime·SysFree((void*)s->types.data, nbytes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uintptr
|
|
|
|
runtime·gettype(void *v)
|
|
|
|
{
|
|
|
|
MSpan *s;
|
|
|
|
uintptr t, ofs;
|
|
|
|
byte *data;
|
|
|
|
|
2013-05-28 12:14:47 -06:00
|
|
|
s = runtime·MHeap_LookupMaybe(&runtime·mheap, v);
|
2012-09-24 18:08:05 -06:00
|
|
|
if(s != nil) {
|
|
|
|
t = 0;
|
|
|
|
switch(s->types.compression) {
|
|
|
|
case MTypes_Empty:
|
|
|
|
break;
|
|
|
|
case MTypes_Single:
|
|
|
|
t = s->types.data;
|
|
|
|
break;
|
|
|
|
case MTypes_Words:
|
|
|
|
ofs = (uintptr)v - (s->start<<PageShift);
|
|
|
|
t = ((uintptr*)s->types.data)[ofs/s->elemsize];
|
|
|
|
break;
|
|
|
|
case MTypes_Bytes:
|
|
|
|
ofs = (uintptr)v - (s->start<<PageShift);
|
|
|
|
data = (byte*)s->types.data;
|
|
|
|
t = data[8*sizeof(uintptr) + ofs/s->elemsize];
|
|
|
|
t = ((uintptr*)data)[t];
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
runtime·throw("runtime·gettype: invalid compression kind");
|
|
|
|
}
|
|
|
|
if(0) {
|
|
|
|
runtime·lock(&settype_lock);
|
|
|
|
runtime·printf("%p -> %d,%X\n", v, (int32)s->types.compression, (int64)t);
|
|
|
|
runtime·unlock(&settype_lock);
|
|
|
|
}
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-19 04:13:39 -07:00
|
|
|
// Runtime stubs.
|
|
|
|
|
|
|
|
void*
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·mal(uintptr n)
|
2010-03-23 21:48:23 -06:00
|
|
|
{
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
return runtime·mallocgc(n, 0, 0);
|
2008-12-19 04:13:39 -07:00
|
|
|
}
|
|
|
|
|
2012-10-07 12:05:32 -06:00
|
|
|
#pragma textflag 7
|
|
|
|
void
|
|
|
|
runtime·new(Type *typ, uint8 *ret)
|
|
|
|
{
|
2012-10-15 03:54:31 -06:00
|
|
|
if(raceenabled)
|
|
|
|
m->racepc = runtime·getcallerpc(&typ);
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
ret = runtime·mallocgc(typ->size, (uintptr)typ | TypeInfo_SingleObject, typ->kind&KindNoPointers ? FlagNoPointers : 0);
|
2011-10-13 02:06:55 -06:00
|
|
|
FLUSH(&ret);
|
2010-06-21 21:53:49 -06:00
|
|
|
}
|
|
|
|
|
2013-05-27 01:29:11 -06:00
|
|
|
static void*
|
|
|
|
cnew(Type *typ, intgo n, int32 objtyp)
|
2012-10-21 15:41:32 -06:00
|
|
|
{
|
2013-05-27 01:29:11 -06:00
|
|
|
if((objtyp&(PtrSize-1)) != objtyp)
|
|
|
|
runtime·throw("runtime: invalid objtyp");
|
|
|
|
if(n < 0 || (typ->size > 0 && n > MaxMem/typ->size))
|
|
|
|
runtime·panicstring("runtime: allocation size out of range");
|
runtime: refactor mallocgc
Make it accept type, combine flags.
Several reasons for the change:
1. mallocgc and settype must be atomic wrt GC
2. settype is called from only one place now
3. it will help performance (eventually settype
functionality must be combined with markallocated)
4. flags are easier to read now (no mallocgc(sz, 0, 1, 0) anymore)
R=golang-dev, iant, nightlyone, rsc, dave, khr, bradfitz, r
CC=golang-dev
https://golang.org/cl/10136043
2013-07-26 11:17:24 -06:00
|
|
|
return runtime·mallocgc(typ->size*n, (uintptr)typ | objtyp, typ->kind&KindNoPointers ? FlagNoPointers : 0);
|
2012-10-21 15:41:32 -06:00
|
|
|
}
|
|
|
|
|
2013-05-27 01:29:11 -06:00
|
|
|
// same as runtime·new, but callable from C
|
|
|
|
void*
|
|
|
|
runtime·cnew(Type *typ)
|
|
|
|
{
|
|
|
|
return cnew(typ, 1, TypeInfo_SingleObject);
|
|
|
|
}
|
|
|
|
|
|
|
|
void*
|
|
|
|
runtime·cnewarray(Type *typ, intgo n)
|
|
|
|
{
|
|
|
|
return cnew(typ, n, TypeInfo_Array);
|
|
|
|
}
|
|
|
|
|
2009-06-30 21:01:50 -06:00
|
|
|
func GC() {
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·gc(1);
|
2009-06-30 21:01:50 -06:00
|
|
|
}
|
2010-02-03 17:31:34 -07:00
|
|
|
|
|
|
|
func SetFinalizer(obj Eface, finalizer Eface) {
|
|
|
|
byte *base;
|
|
|
|
uintptr size;
|
|
|
|
FuncType *ft;
|
2012-09-24 12:58:34 -06:00
|
|
|
int32 i;
|
|
|
|
uintptr nret;
|
2010-02-08 22:41:54 -07:00
|
|
|
Type *t;
|
2013-07-29 09:43:08 -06:00
|
|
|
Type *fint;
|
|
|
|
PtrType *ot;
|
2010-02-10 01:00:12 -07:00
|
|
|
|
2010-02-03 17:31:34 -07:00
|
|
|
if(obj.type == nil) {
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printf("runtime.SetFinalizer: first argument is nil interface\n");
|
2011-10-06 09:42:51 -06:00
|
|
|
goto throw;
|
2010-02-03 17:31:34 -07:00
|
|
|
}
|
|
|
|
if(obj.type->kind != KindPtr) {
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printf("runtime.SetFinalizer: first argument is %S, not pointer\n", *obj.type->string);
|
2010-02-03 17:31:34 -07:00
|
|
|
goto throw;
|
|
|
|
}
|
2011-02-02 21:03:47 -07:00
|
|
|
if(!runtime·mlookup(obj.data, &base, &size, nil) || obj.data != base) {
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printf("runtime.SetFinalizer: pointer not at beginning of allocated block\n");
|
2010-02-03 17:31:34 -07:00
|
|
|
goto throw;
|
|
|
|
}
|
2010-02-08 22:41:54 -07:00
|
|
|
nret = 0;
|
2013-07-29 09:43:08 -06:00
|
|
|
ot = nil;
|
2010-02-03 17:31:34 -07:00
|
|
|
if(finalizer.type != nil) {
|
2011-10-06 09:42:51 -06:00
|
|
|
if(finalizer.type->kind != KindFunc)
|
|
|
|
goto badfunc;
|
2010-02-03 17:31:34 -07:00
|
|
|
ft = (FuncType*)finalizer.type;
|
2013-07-29 09:43:08 -06:00
|
|
|
if(ft->dotdotdot || ft->in.len != 1)
|
|
|
|
goto badfunc;
|
|
|
|
fint = *(Type**)ft->in.array;
|
|
|
|
if(fint->kind == KindInterface && ((InterfaceType*)fint)->mhdr.len == 0)
|
|
|
|
ot = (PtrType*)obj.type;
|
|
|
|
else if(fint != obj.type)
|
2010-02-03 17:31:34 -07:00
|
|
|
goto badfunc;
|
2010-02-10 01:00:12 -07:00
|
|
|
|
2010-02-08 22:41:54 -07:00
|
|
|
// compute size needed for return parameters
|
|
|
|
for(i=0; i<ft->out.len; i++) {
|
|
|
|
t = ((Type**)ft->out.array)[i];
|
2013-06-13 06:02:50 -06:00
|
|
|
nret = ROUND(nret, t->align) + t->size;
|
2010-02-08 22:41:54 -07:00
|
|
|
}
|
2013-06-13 06:02:50 -06:00
|
|
|
nret = ROUND(nret, sizeof(void*));
|
2010-02-03 17:31:34 -07:00
|
|
|
}
|
2011-10-06 09:42:51 -06:00
|
|
|
|
2013-07-29 09:43:08 -06:00
|
|
|
if(!runtime·addfinalizer(obj.data, finalizer.data, nret, ot)) {
|
2011-10-06 09:42:51 -06:00
|
|
|
runtime·printf("runtime.SetFinalizer: finalizer already set\n");
|
|
|
|
goto throw;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
badfunc:
|
2013-07-29 09:43:08 -06:00
|
|
|
runtime·printf("runtime.SetFinalizer: second argument is %S, not func(%S) or func(interface{})\n", *finalizer.type->string, *obj.type->string);
|
2011-10-06 09:42:51 -06:00
|
|
|
throw:
|
|
|
|
runtime·throw("runtime.SetFinalizer");
|
2010-02-03 17:31:34 -07:00
|
|
|
}
|