code review 10136043: runtime: refactor mallocgc

src/pkg/runtime/hashmap.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.
 
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "hashmap.h"
 #include "type.h"
 #include "race.h"
@@ skipping 241 matching lines @@
         while(hint > BUCKETSIZE && hint > LOAD * ((uintptr)1 << B))
                 B++;
 
         // allocate initial hash table
         // If hint is large zeroing this memory could take a while.
         if(checkgc) mstats.next_gc = mstats.heap_alloc;
         if(B == 0) {
                 // done lazily later.
                 buckets = nil;
         } else {
-                buckets = runtime·mallocgc(bucketsize << B, 0, 1, 0);
+                buckets = runtime·mallocgc(bucketsize << B, 0, FlagNoZero);
                 for(i = 0; i < (uintptr)1 << B; i++) {
                         b = (Bucket*)(buckets + i * bucketsize);
                         clearbucket(b);
                 }
         }
 
         // initialize Hmap
         // Note: we save all these stores to the end so gciter doesn't see
         // a partially initialized map.
         h->count = 0;
@@ skipping 50 matching lines @@
                                 if(b->tophash[i] == 0)
                                         continue;
                                 hash = h->hash0;
                                 t->key->alg->hash(&hash, t->key->size, IK(h, k));
                                 // NOTE: if key != key, then this hash could be (and probably will be)
                                 // entirely different from the old hash.  We effectively only update
                                 // the B'th bit of the hash in this case.
                                 if((hash & newbit) == 0) {
                                         if(xi == BUCKETSIZE) {
                                                 if(checkgc) mstats.next_gc = mstats.heap_alloc;
-                                                newx = runtime·mallocgc(h->bucketsize, 0, 1, 0);
+                                                newx = runtime·mallocgc(h->bucketsize, 0, FlagNoZero);
                                                 clearbucket(newx);
                                                 x->overflow = newx;
                                                 x = newx;
                                                 xi = 0;
                                                 xk = x->data;
                                                 xv = xk + h->keysize * BUCKETSIZE;
                                         }
                                         x->tophash[xi] = b->tophash[i];
                                         if((h->flags & IndirectKey) != 0) {
                                                 *(byte**)xk = *(byte**)k;               // copy pointer
                                         } else {
                                                 t->key->alg->copy(t->key->size, xk, k); // copy value
                                         }
                                         if((h->flags & IndirectValue) != 0) {
                                                 *(byte**)xv = *(byte**)v;
                                         } else {
                                                 t->elem->alg->copy(t->elem->size, xv, v);
                                         }
                                         xi++;
                                         xk += h->keysize;
                                         xv += h->valuesize;
                                 } else {
                                         if(yi == BUCKETSIZE) {
                                                 if(checkgc) mstats.next_gc = mstats.heap_alloc;
-                                                newy = runtime·mallocgc(h->bucketsize, 0, 1, 0);
+                                                newy = runtime·mallocgc(h->bucketsize, 0, FlagNoZero);
                                                 clearbucket(newy);
                                                 y->overflow = newy;
                                                 y = newy;
                                                 yi = 0;
                                                 yk = y->data;
                                                 yv = yk + h->keysize * BUCKETSIZE;
                                         }
                                         y->tophash[yi] = b->tophash[i];
                                         if((h->flags & IndirectKey) != 0) {
                                                 *(byte**)yk = *(byte**)k;
@@ skipping 75 matching lines @@
         byte *old_buckets;
         byte *new_buckets;
         uint8 flags;
 
         // allocate a bigger hash table
         if(h->oldbuckets != nil)
                 runtime·throw("evacuation not done in time");
         old_buckets = h->buckets;
         // NOTE: this could be a big malloc, but since we don't need zeroing it is probably fast.
         if(checkgc) mstats.next_gc = mstats.heap_alloc;
-        new_buckets = runtime·mallocgc((uintptr)h->bucketsize << (h->B + 1), 0, 1, 0);
+        new_buckets = runtime·mallocgc((uintptr)h->bucketsize << (h->B + 1), 0, FlagNoZero);
         flags = (h->flags & ~(Iterator | OldIterator));
         if((h->flags & Iterator) != 0) {
                 flags |= OldIterator;
                 // We can't free indirect keys any more, as
                 // they are potentially aliased across buckets.
                 flags &= ~CanFreeKey;
         }
 
         // commit the grow (atomic wrt gc)
         h->B++;
@@ skipping 125 matching lines @@
         byte *insertk, *insertv;
         uint8 top;
         byte *k, *v;
         byte *kmem, *vmem;
 
         if(docheck)
                 check(t, h);
         hash = h->hash0;
         t->key->alg->hash(&hash, t->key->size, key);
         if(h->buckets == nil) {
-                h->buckets = runtime·mallocgc(h->bucketsize, 0, 1, 0);
+                h->buckets = runtime·mallocgc(h->bucketsize, 0, FlagNoZero);
                 b = (Bucket*)(h->buckets);
                 clearbucket(b);
         }
 
  again:
         bucket = hash & (((uintptr)1 << h->B) - 1);
         if(h->oldbuckets != nil)
                 grow_work(t, h, bucket);
         b = (Bucket*)(h->buckets + bucket * h->bucketsize);
         top = hash >> (sizeof(uintptr)*8 - 8);
         if(top == 0)
                 top = 1;
-        inserti = 0;
+        inserti = nil;
         insertk = nil;
         insertv = nil;
         while(true) {
                 for(i = 0, k = b->data, v = k + h->keysize * BUCKETSIZE; i < BUCKETSIZE; i++, k += h->keysize, v += h->valuesize) {
                         if(b->tophash[i] != top) {
                                 if(b->tophash[i] == 0 && inserti == nil) {
                                         inserti = &b->tophash[i];
                                         insertk = k;
                                         insertv = v;
                                 }
@@ skipping 16 matching lines @@
 
         // did not find mapping for key.  Allocate new cell & add entry.
         if(h->count >= LOAD * ((uintptr)1 << h->B) && h->count >= BUCKETSIZE) {
                 hash_grow(t, h);
                 goto again; // Growing the table invalidates everything, so try again
         }
 
         if(inserti == nil) {
                 // all current buckets are full, allocate a new one.
                 if(checkgc) mstats.next_gc = mstats.heap_alloc;
-                newb = runtime·mallocgc(h->bucketsize, 0, 1, 0);
+                newb = runtime·mallocgc(h->bucketsize, 0, FlagNoZero);
                 clearbucket(newb);
                 b->overflow = newb;
                 inserti = newb->tophash;
                 insertk = newb->data;
                 insertv = insertk + h->keysize * BUCKETSIZE;
         }
 
         // store new key/value at insert position
         if((h->flags & IndirectKey) != 0) {
                 if(checkgc) mstats.next_gc = mstats.heap_alloc;
-                kmem = runtime·mallocgc(t->key->size, 0, 1, 0);
+                kmem = runtime·mallocgc(t->key->size, 0, FlagNoZero);
                 *(byte**)insertk = kmem;
                 insertk = kmem;
         }
         if((h->flags & IndirectValue) != 0) {
                 if(checkgc) mstats.next_gc = mstats.heap_alloc;
-                vmem = runtime·mallocgc(t->elem->size, 0, 1, 0);
+                vmem = runtime·mallocgc(t->elem->size, 0, FlagNoZero);
                 *(byte**)insertv = vmem;
                 insertv = vmem;
         }
         t->key->alg->copy(t->key->size, insertk, key);
         t->elem->alg->copy(t->elem->size, insertv, value);
         *inserti = top;
         h->count++;
         if(docheck)
                 check(t, h);
 }
@@ skipping 417 matching lines @@
         Type *key;
 
         key = typ->key;
 
         if(hint < 0 || (int32)hint != hint)
                 runtime·panicstring("makemap: size out of range");
 
         if(key->alg->hash == runtime·nohash)
                 runtime·throw("runtime.makemap: unsupported map key type");
 
-        m->locks++;  // disable preemption to not expose inconsistent Hmap to GC
-        h = runtime·mal(sizeof(*h));
-        if(UseSpanType) {
-                if(false)
-                        runtime·printf("makemap %S: %p\n", *typ->string, h);
-                runtime·settype(h, (uintptr)typ | TypeInfo_Map);
-        }
+        h = runtime·mallocgc(sizeof(*h), (uintptr)typ | TypeInfo_Map, 0);
         hash_init(typ, h, hint);
-        m->locks--;
 
         // these calculations are compiler dependent.
         // figure out offsets of map call arguments.
 
         if(debug) {
                 runtime·printf("makemap: map=%p; keysize=%p; valsize=%p; keyalg=%p; valalg=%p\n",
                                h, key->size, typ->elem->size, key->alg, typ->elem->alg);
         }
 
         return h;
@@ skipping 353 matching lines @@
 // the actual data if it fits, or else a pointer to the data.
 void
 reflect·mapiterkey(struct hash_iter *it, uintptr key, bool ok)
 {
         byte *res;
         Type *tkey;
 
         key = 0;
         ok = false;
         res = it->key;
-        if(res == nil) {
-                key = 0;
-                ok = false;
-        } else {
+        if(res != nil) {
                 tkey = it->t->key;
-                key = 0;
                 if(tkey->size <= sizeof(key))
                         tkey->alg->copy(tkey->size, (byte*)&key, res);
                 else
                         key = (uintptr)res;
                 ok = true;
         }
         FLUSH(&key);
         FLUSH(&ok);
 }
 
@@ skipping 33 matching lines @@
         t->elem->alg->copy(t->elem->size, av, it->value);
 
         if(debug) {
                 runtime·prints("mapiter2: iter=");
                 runtime·printpointer(it);
                 runtime·prints("; map=");
                 runtime·printpointer(it->h);
                 runtime·prints("\n");
         }
 }