code review 5279048: runtime: faster and more scalable GC

src/pkg/runtime/runtime.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 "stack.h"
 
 enum {
         maxround = sizeof(uintptr),
 };
@@ skipping 101 matching lines @@
         runtime·printf("throw: %s\n", s);
         runtime·dopanic(0);
         *(int32*)0 = 0; // not reached
         runtime·exit(1);        // even more not reached
 }
 
 void
 runtime·panicstring(int8 *s)
 {
         Eface err;
-        
+
         if(m->gcing) {
                 runtime·printf("panic: %s\n", s);
                 runtime·throw("panic during gc");
         }
         runtime·newErrorString(runtime·gostringnocopy((byte*)s), &err);
         runtime·panic(err);
 }
 
 int32
 runtime·mcmp(byte *s1, byte *s2, uint32 n)
@@ skipping 49 matching lines @@
 }
 
 int32 runtime·isplan9;
 int32 runtime·iswindows;
 
 void
 runtime·goargs(void)
 {
         String *s;
         int32 i;
-        
+
         // for windows implementation see "os" package
         if(Windows)
                 return;
 
         s = runtime·malloc(argc*sizeof s[0]);
         for(i=0; i<argc; i++)
                 s[i] = runtime·gostringnocopy(argv[i]);
         os·Args.array = (byte*)s;
         os·Args.len = argc;
         os·Args.cap = argc;
 }
 
 void
 runtime·goenvs_unix(void)
 {
         String *s;
         int32 i, n;
-        
+
         for(n=0; argv[argc+1+n] != 0; n++)
                 ;
 
         s = runtime·malloc(n*sizeof s[0]);
         for(i=0; i<n; i++)
                 s[i] = runtime·gostringnocopy(argv[argc+1+i]);
         syscall·envs.array = (byte*)s;
         syscall·envs.len = n;
         syscall·envs.cap = n;
 }
@@ skipping 50 matching lines @@
 runtime·check(void)
 {
         int8 a;
         uint8 b;
         int16 c;
         uint16 d;
         int32 e;
         uint32 f;
         int64 g;
         uint64 h;
-        float32 i;
-        float64 j;
+        float32 i, i1;
+        float64 j, j1;
         void* k;
         uint16* l;
         struct x1 {
                 byte x;
         };
         struct y1 {
                 struct x1 x1;
                 byte y;
         };
 
@@ skipping 19 matching lines @@
                 runtime·throw("cas1");
         if(z != 2)
                 runtime·throw("cas2");
 
         z = 4;
         if(runtime·cas(&z, 5, 6))
                 runtime·throw("cas3");
         if(z != 4)
                 runtime·throw("cas4");
 
-        runtime·initsig(0);
-}
-
-void
-runtime·CTestAtomic64(void)
-{
-        uint64 z64 = 42;
-        uint64 x64 = 0;
- ·······
+        *(uint64*)&j = ~0ULL;
+        if(j == j)
+                runtime·throw("float64nan");
+        if(!(j != j))
+                runtime·throw("float64nan1");
+
+        *(uint64*)&j1 = ~1ULL;
+        if(j == j1)
+                runtime·throw("float64nan2");
+        if(!(j != j1))
+                runtime·throw("float64nan3");
+
+        *(uint32*)&i = ~0UL;
+        if(i == i)
+                runtime·throw("float32nan");
+        if(!(i != i))
+                runtime·throw("float32nan1");
+
+        *(uint32*)&i1 = ~1UL;
+        if(i == i1)
+                runtime·throw("float32nan2");
+        if(!(i != i1))
+                runtime·throw("float32nan3");
+}
+
+void
+runtime·CTestAtomic64(bool isShort)
+{
+        uint64 z64, x64;
+
+        USED(isShort);
+
         z64 = 42;
         x64 = 0;
         if(runtime·cas64(&z64, &x64, 1))
                 runtime·panicstring("cas64 failed");
         if(x64 != 42)
                 runtime·panicstring("cas64 failed");
         if(!runtime·cas64(&z64, &x64, 1))
                 runtime·panicstring("cas64 failed");
         if(x64 != 42 || z64 != 1)
                 runtime·panicstring("cas64 failed");
         if(runtime·atomicload64(&z64) != 1)
                 runtime·panicstring("load64 failed");
         runtime·atomicstore64(&z64, (1ull<<40)+1);
         if(runtime·atomicload64(&z64) != (1ull<<40)+1)
                 runtime·panicstring("store64 failed");
         if(runtime·xadd64(&z64, (1ull<<40)+1) != (2ull<<40)+2)
                 runtime·panicstring("xadd64 failed");
         if(runtime·atomicload64(&z64) != (2ull<<40)+2)
                 runtime·panicstring("xadd64 failed");
 }
-
-/*
- * map and chan helpers for
- * dealing with unknown types
- */
-static uintptr
-memhash(uint32 s, void *a)
-{
-        byte *b;
-        uintptr hash;
-
-        b = a;
-        if(sizeof(hash) == 4)
-                hash = 2860486313U;
-        else
-                hash = 33054211828000289ULL;
-        while(s > 0) {
-                if(sizeof(hash) == 4)
-                        hash = (hash ^ *b) * 3267000013UL;
-                else
-                        hash = (hash ^ *b) * 23344194077549503ULL;
-                b++;
-                s--;
-        }
-        return hash;
-}
-
-static uint32
-memequal(uint32 s, void *a, void *b)
-{
-        byte *ba, *bb, *aend;
-
-        if(a == b)
-          return 1;
-        ba = a;
-        bb = b;
-        aend = ba+s;
-        while(ba != aend) {
-                if(*ba != *bb)
-                        return 0;
-                ba++;
-                bb++;
-        }
-        return 1;
-}
-
-static void
-memprint(uint32 s, void *a)
-{
-        uint64 v;
-
-        v = 0xbadb00b;
-        switch(s) {
-        case 1:
-                v = *(uint8*)a;
-                break;
-        case 2:
-                v = *(uint16*)a;
-                break;
-        case 4:
-                v = *(uint32*)a;
-                break;
-        case 8:
-                v = *(uint64*)a;
-                break;
-        }
-        runtime·printint(v);
-}
-
-static void
-memcopy(uint32 s, void *a, void *b)
-{
-        if(b == nil) {
-                runtime·memclr(a,s);
-                return;
-        }
-        runtime·memmove(a,b,s);
-}
-
-static uint32
-memequal8(uint32 s, uint8 *a, uint8 *b)
-{
-        USED(s);
-        return *a == *b;
-}
-
-static void
-memcopy8(uint32 s, uint8 *a, uint8 *b)
-{
-        USED(s);
-        if(b == nil) {
-                *a = 0;
-                return;
-        }
-        *a = *b;
-}
-
-static uint32
-memequal16(uint32 s, uint16 *a, uint16 *b)
-{
-        USED(s);
-        return *a == *b;
-}
-
-static void
-memcopy16(uint32 s, uint16 *a, uint16 *b)
-{
-        USED(s);
-        if(b == nil) {
-                *a = 0;
-                return;
-        }
-        *a = *b;
-}
-
-static uint32
-memequal32(uint32 s, uint32 *a, uint32 *b)
-{
-        USED(s);
-        return *a == *b;
-}
-
-static void
-memcopy32(uint32 s, uint32 *a, uint32 *b)
-{
-        USED(s);
-        if(b == nil) {
-                *a = 0;
-                return;
-        }
-        *a = *b;
-}
-
-static uint32
-memequal64(uint32 s, uint64 *a, uint64 *b)
-{
-        USED(s);
-        return *a == *b;
-}
-
-static void
-memcopy64(uint32 s, uint64 *a, uint64 *b)
-{
-        USED(s);
-        if(b == nil) {
-                *a = 0;
-                return;
-        }
-        *a = *b;
-}
-
-static uint32
-memequal128(uint32 s, uint64 *a, uint64 *b)
-{
-        USED(s);
-        return a[0] == b[0] && a[1] == b[1];
-}
-
-static void
-memcopy128(uint32 s, uint64 *a, uint64 *b)
-{
-        USED(s);
-        if(b == nil) {
-                a[0] = 0;
-                a[1] = 0;
-                return;
-        }
-        a[0] = b[0];
-        a[1] = b[1];
-}
-
-static void
-slicecopy(uint32 s, Slice *a, Slice *b)
-{
-        USED(s);
-        if(b == nil) {
-                a->array = 0;
-                a->len = 0;
-                a->cap = 0;
-                return;
-        }
-        a->array = b->array;
-        a->len = b->len;
-        a->cap = b->cap;
-}
-
-static uintptr
-strhash(uint32 s, String *a)
-{
-        USED(s);
-        return memhash((*a).len, (*a).str);
-}
-
-static uint32
-strequal(uint32 s, String *a, String *b)
-{
-        int32 alen;
-
-        USED(s);
-        alen = a->len;
-        if(alen != b->len)
-                return false;
-        return memequal(alen, a->str, b->str);
-}
-
-static void
-strprint(uint32 s, String *a)
-{
-        USED(s);
-        runtime·printstring(*a);
-}
-
-static void
-strcopy(uint32 s, String *a, String *b)
-{
-        USED(s);
-        if(b == nil) {
-                a->str = 0;
-                a->len = 0;
-                return;
-        }
-        a->str = b->str;
-        a->len = b->len;
-}
-
-static uintptr
-interhash(uint32 s, Iface *a)
-{
-        USED(s);
-        return runtime·ifacehash(*a);
-}
-
-static void
-interprint(uint32 s, Iface *a)
-{
-        USED(s);
-        runtime·printiface(*a);
-}
-
-static uint32
-interequal(uint32 s, Iface *a, Iface *b)
-{
-        USED(s);
-        return runtime·ifaceeq_c(*a, *b);
-}
-
-static void
-intercopy(uint32 s, Iface *a, Iface *b)
-{
-        USED(s);
-        if(b == nil) {
-                a->tab = 0;
-                a->data = 0;
-                return;
-        }
-        a->tab = b->tab;
-        a->data = b->data;
-}
-
-static uintptr
-nilinterhash(uint32 s, Eface *a)
-{
-        USED(s);
-        return runtime·efacehash(*a);
-}
-
-static void
-nilinterprint(uint32 s, Eface *a)
-{
-        USED(s);
-        runtime·printeface(*a);
-}
-
-static uint32
-nilinterequal(uint32 s, Eface *a, Eface *b)
-{
-        USED(s);
-        return runtime·efaceeq_c(*a, *b);
-}
-
-static void
-nilintercopy(uint32 s, Eface *a, Eface *b)
-{
-        USED(s);
-        if(b == nil) {
-                a->type = 0;
-                a->data = 0;
-                return;
-        }
-        a->type = b->type;
-        a->data = b->data;
-}
-
-uintptr
-runtime·nohash(uint32 s, void *a)
-{
-        USED(s);
-        USED(a);
-        runtime·panicstring("hash of unhashable type");
-        return 0;
-}
-
-uint32
-runtime·noequal(uint32 s, void *a, void *b)
-{
-        USED(s);
-        USED(a);
-        USED(b);
-        runtime·panicstring("comparing uncomparable types");
-        return 0;
-}
-
-Alg
-runtime·algarray[] =
-{
-[AMEM]  { memhash, memequal, memprint, memcopy },
-[ANOEQ] { runtime·nohash, runtime·noequal, memprint, memcopy },
-[ASTRING]       { (void*)strhash, (void*)strequal, (void*)strprint, (void*)strcopy },
-[AINTER]                { (void*)interhash, (void*)interequal, (void*)interprint, (void*)intercopy },
-[ANILINTER]     { (void*)nilinterhash, (void*)nilinterequal, (void*)nilinterprint, (void*)nilintercopy },
-[ASLICE]        { (void*)runtime·nohash, (void*)runtime·noequal, (void*)memprint, (void*)slicecopy },
-[AMEM8]         { memhash, (void*)memequal8, memprint, (void*)memcopy8 },
-[AMEM16]        { memhash, (void*)memequal16, memprint, (void*)memcopy16 },
-[AMEM32]        { memhash, (void*)memequal32, memprint, (void*)memcopy32 },
-[AMEM64]        { memhash, (void*)memequal64, memprint, (void*)memcopy64 },
-[AMEM128]       { memhash, (void*)memequal128, memprint, (void*)memcopy128 },
-[ANOEQ8]        { runtime·nohash, runtime·noequal, memprint, (void*)memcopy8 },
-[ANOEQ16]       { runtime·nohash, runtime·noequal, memprint, (void*)memcopy16 },
-[ANOEQ32]       { runtime·nohash, runtime·noequal, memprint, (void*)memcopy32 },
-[ANOEQ64]       { runtime·nohash, runtime·noequal, memprint, (void*)memcopy64 },
-[ANOEQ128]      { runtime·nohash, runtime·noequal, memprint, (void*)memcopy128 },
-};
 
 void
 runtime·Caller(int32 skip, uintptr retpc, String retfile, int32 retline, bool retbool)
 {
         Func *f, *g;
         uintptr pc;
         uintptr rpc[2];
 
         /*
          * Ask for two PCs: the one we were asked for
@@ skipping 50 matching lines @@
 {
         uint32 x;
 
         x = m->fastrand;
         x += x;
         if(x & 0x80000000L)
                 x ^= 0x88888eefUL;
         m->fastrand = x;
         return x;
 }