code review 10136043: runtime: refactor mallocgc

src/pkg/runtime/malloc.goc

 // 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.
 
 package runtime
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "type.h"
 #include "typekind.h"
 #include "race.h"
-
+#include "stack.h"
+
+// Mark mheap as 'no pointers', it does not contain interesting pointers but occupies ~45K.
+#pragma dataflag 16
 MHeap runtime·mheap;
 
 int32   runtime·checking;
 
 extern MStats mstats;   // defined in zruntime_def_$GOOS_$GOARCH.go
 
 extern volatile intgo runtime·MemProfileRate;
 
 // 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.
 // If the block will be freed with runtime·free(), typ must be 0.

[rsc, 2013/07/22 18:52:36]

s/()//

 void*
 runtime·mallocgc(uintptr size, uintptr typ, uint32 flag)
 {
         int32 sizeclass;
         intgo rate;
         MCache *c;
         MCacheList *l;
         uintptr npages;
         MSpan *s;
         MLink *v;
 
         if(runtime·gcwaiting && g != m->g0 && m->locks == 0 && !(flag & FlagNoInvokeGC))
                 runtime·gosched();
         if(size == 0) {
                 // All 0-length allocations use this pointer.
                 // The language does not require the allocations to
                 // have distinct values.
                 return &runtime·zerobase;
         }
         if(m->mallocing)
                 runtime·throw("malloc/free - deadlock");
+        // Disable preemption during settype_flush.
+        // We can not use m->mallocing for this, because settype_flush calls mallocgc.
+        m->locks++;
         m->mallocing = 1;
 
         if(DebugTypeAtBlockEnd)
                 size += sizeof(uintptr);
 
         c = m->mcache;
         if(size <= MaxSmallSize) {
                 // Allocate from mcache free lists.
                 // 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];
                 size = runtime·class_to_size[sizeclass];
                 l = &c->list[sizeclass];
                 if(l->list == nil)
                         runtime·MCache_Refill(c, sizeclass);
                 v = l->list;
                 l->list = v->next;
                 l->nlist--;
-                if(!(flag & FlagNoZeroize)) {
+                if(!(flag & FlagNoZero)) {
                         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;
         } else {
                 // TODO(rsc): Report tracebacks for very large allocations.
 
                 // Allocate directly from heap.
                 npages = size >> PageShift;
                 if((size & PageMask) != 0)
                         npages++;
-                s = runtime·MHeap_Alloc(&runtime·mheap, npages, 0, 1, !(flag & FlagNoZeroize));
+                s = runtime·MHeap_Alloc(&runtime·mheap, npages, 0, 1, !(flag & FlagNoZero));
                 if(s == nil)
                         runtime·throw("out of memory");
                 s->limit = (byte*)(s->start<<PageShift) + size;
                 size = npages<<PageShift;
                 v = (void*)(s->start << PageShift);
 
                 // setup for mark sweep
                 runtime·markspan(v, 0, 0, true);
         }
 
         if(!(flag & FlagNoGC))
                 runtime·markallocated(v, size, (flag&FlagNoPointers) != 0);
 
         if(DebugTypeAtBlockEnd)
                 *(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;
         }
 
         m->mallocing = 0;
-
         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
+                g->stackguard0 = StackPreempt;
 
         if(!(flag & FlagNoProfiling) && (rate = runtime·MemProfileRate) > 0) {
                 if(size >= rate)
                         goto profile;
                 if(m->mcache->next_sample > size)
                         m->mcache->next_sample -= size;
                 else {
                         // pick next profile time
                         // If you change this, also change allocmcache.
                         if(rate > 0x3fffffff)   // make 2*rate not overflow
@@ skipping 699 matching lines @@
                 runtime·printf("runtime.SetFinalizer: finalizer already set\n");
                 goto throw;
         }
         return;
 
 badfunc:
         runtime·printf("runtime.SetFinalizer: second argument is %S, not func(%S)\n", *finalizer.type->string, *obj.type->string);
 throw:
         runtime·throw("runtime.SetFinalizer");
 }