code review 7543043: runtime: faster & safer hash function

src/pkg/runtime/runtime.h

 // 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.
 
 /*
  * basic types
  */
 typedef signed char             int8;
 typedef unsigned char           uint8;
 typedef signed short            int16;
@@ skipping 217 matching lines @@
         uintptr stack0;
         FuncVal*        fnstart;                // initial function
         G*      alllink;        // on allg
         void*   param;          // passed parameter on wakeup
         int16   status;
         int64   goid;
         uint32  selgen;         // valid sudog pointer
         int8*   waitreason;     // if status==Gwaiting
         G*      schedlink;
         bool    ispanic;
-        bool    issystem;
-        int8    raceignore; // ignore race detection events
+        bool    issystem;       // do not output in stack dump
+        bool    isbackground;   // ignore in deadlock detector
+        int8    raceignore;     // ignore race detection events
         M*      m;              // for debuggers, but offset not hard-coded
         M*      lockedm;
         int32   sig;
         int32   writenbuf;
         byte*   writebuf;
         DeferChunk      *dchunk;
         DeferChunk      *dchunknext;
         uintptr sigcode0;
         uintptr sigcode1;
         uintptr sigpc;
@@ skipping 63 matching lines @@
         uint32  moreframesize_minalloc;
 
         uintptr settype_buf[1024];
         uintptr settype_bufsize;
 
 #ifdef GOOS_windows
         void*   thread;         // thread handle
 #endif
 #ifdef GOOS_plan9
         int8*           notesig;
+        byte*   errstr;
 #endif
         SEH*    seh;
         uintptr end[];
 };
 
 struct P
 {
         Lock;
 
         uint32  status;  // one of Pidle/Prunning/...
@@ skipping 142 matching lines @@
         void (*body)(ParFor*, uint32);  // executed for each element
         uint32 done;                    // number of idle threads
         uint32 nthr;                    // total number of threads
         uint32 nthrmax;                 // maximum number of threads
         uint32 thrseq;                  // thread id sequencer
         uint32 cnt;                     // iteration space [0, cnt)
         void *ctx;                      // arbitrary user context
         bool wait;                      // if true, wait while all threads finish processing,
                                         // otherwise parfor may return while other threads are still working
         ParForThread *thr;              // array of thread descriptors
+        uint32 pad;                     // to align ParForThread.pos for 64-bit atomic operations
         // stats
         uint64 nsteal;
         uint64 nstealcnt;
         uint64 nprocyield;
         uint64 nosyield;
         uint64 nsleep;
 };
 
 // Track memory allocated by code not written in Go during a cgo call,
 // so that the garbage collector can see them.
@@ skipping 53 matching lines @@
 struct  Alg
 {
         void    (*hash)(uintptr*, uintptr, void*);
         void    (*equal)(bool*, uintptr, void*, void*);
         void    (*print)(uintptr, void*);
         void    (*copy)(uintptr, void*, void*);
 };
 
 extern  Alg     runtime·algarray[Amax];
 
+byte*   runtime·startup_random_data;
+uint32  runtime·startup_random_data_len;
+void    runtime·get_random_data(byte**, int32*);
 
 enum {
         // hashinit wants this many random bytes
-        hash_random_bytes = 32
-};
-void    runtime·hashinit(uint8*);
+        HashRandomBytes = 32
+};
+void    runtime·hashinit(void);
 
 void    runtime·memhash(uintptr*, uintptr, void*);
 void    runtime·nohash(uintptr*, uintptr, void*);
 void    runtime·strhash(uintptr*, uintptr, void*);
 void    runtime·interhash(uintptr*, uintptr, void*);
 void    runtime·nilinterhash(uintptr*, uintptr, void*);
 void    runtime·aeshash(uintptr*, uintptr, void*);
 void    runtime·aeshash32(uintptr*, uintptr, void*);
 void    runtime·aeshash64(uintptr*, uintptr, void*);
 void    runtime·aeshashstr(uintptr*, uintptr, void*);
@@ skipping 98 matching lines @@
 void    runtime·goargs(void);
 void    runtime·goenvs(void);
 void    runtime·goenvs_unix(void);
 void*   runtime·getu(void);
 void    runtime·throw(int8*);
 void    runtime·panicstring(int8*);
 void    runtime·prints(int8*);
 void    runtime·printf(int8*, ...);
 byte*   runtime·mchr(byte*, byte, byte*);
 int32   runtime·mcmp(byte*, byte*, uint32);
-void    runtime·memmove(void*, void*, uint32);
+void    runtime·memmove(void*, void*, uintptr);
 void*   runtime·mal(uintptr);
 String  runtime·catstring(String, String);
 String  runtime·gostring(byte*);
 String  runtime·gostringn(byte*, intgo);
 Slice   runtime·gobytes(byte*, intgo);
 String  runtime·gostringnocopy(byte*);
 String  runtime·gostringw(uint16*);
 void    runtime·initsig(void);
 void    runtime·sigenable(uint32 sig);
 int32   runtime·gotraceback(void);
 void    runtime·goroutineheader(G*);
 void    runtime·traceback(uint8 *pc, uint8 *sp, uint8 *lr, G* gp);
 void    runtime·tracebackothers(G*);
+int32   runtime·open(int8*, int32, int32);
+int32   runtime·read(int32, void*, int32);
 int32   runtime·write(int32, void*, int32);
+int32   runtime·close(int32);
 int32   runtime·mincore(void*, uintptr, byte*);
 bool    runtime·cas(uint32*, uint32, uint32);
 bool    runtime·cas64(uint64*, uint64*, uint64);
 bool    runtime·casp(void**, void*, void*);
 // Don't confuse with XADD x86 instruction,
 // this one is actually 'addx', that is, add-and-fetch.
 uint32  runtime·xadd(uint32 volatile*, int32);
 uint64  runtime·xadd64(uint64 volatile*, int64);
 uint32  runtime·xchg(uint32 volatile*, uint32);
+uint64  runtime·xchg64(uint64 volatile*, uint64);
 uint32  runtime·atomicload(uint32 volatile*);
 void    runtime·atomicstore(uint32 volatile*, uint32);
 void    runtime·atomicstore64(uint64 volatile*, uint64);
 uint64  runtime·atomicload64(uint64 volatile*);
 void*   runtime·atomicloadp(void* volatile*);
 void    runtime·atomicstorep(void* volatile*, void*);
 void    runtime·jmpdefer(FuncVal*, void*);
 void    runtime·exit1(int32);
 void    runtime·ready(G*);
 byte*   runtime·getenv(int8*);
@@ skipping 50 matching lines @@
 void    runtime·startpanic(void);
 void    runtime·unwindstack(G*, byte*);
 void    runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp);
 void    runtime·resetcpuprofiler(int32);
 void    runtime·setcpuprofilerate(void(*)(uintptr*, int32), int32);
 void    runtime·usleep(uint32);
 int64   runtime·cputicks(void);
 int64   runtime·tickspersecond(void);
 void    runtime·blockevent(int64, int32);
 extern int64 runtime·blockprofilerate;
+void    runtime·addtimer(Timer*);
+bool    runtime·deltimer(Timer*);
+G*      runtime·netpoll(bool);
 
 #pragma varargck        argpos  runtime·printf  1
 #pragma varargck        type    "d"     int32
 #pragma varargck        type    "d"     uint32
 #pragma varargck        type    "D"     int64
 #pragma varargck        type    "D"     uint64
 #pragma varargck        type    "x"     int32
 #pragma varargck        type    "x"     uint32
 #pragma varargck        type    "X"     int64
 #pragma varargck        type    "X"     uint64
@@ skipping 181 matching lines @@
 extern float64 runtime·nan;
 extern float64 runtime·posinf;
 extern float64 runtime·neginf;
 extern uint64 ·nan;
 extern uint64 ·posinf;
 extern uint64 ·neginf;
 #define ISNAN(f) ((f) != (f))
 
 enum
 {
-        UseSpanType = 1,
-};
+        UseSpanType = 0,
+};