code review 46970043: runtime: allocate goroutine ids in batches

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 48 matching lines @@
 typedef struct  String          String;
 typedef struct  FuncVal         FuncVal;
 typedef struct  SigTab          SigTab;
 typedef struct  MCache          MCache;
 typedef struct  FixAlloc        FixAlloc;
 typedef struct  Iface           Iface;
 typedef struct  Itab            Itab;
 typedef struct  InterfaceType   InterfaceType;
 typedef struct  Eface           Eface;
 typedef struct  Type            Type;
+typedef struct  PtrType         PtrType;
 typedef struct  ChanType                ChanType;
 typedef struct  MapType         MapType;
 typedef struct  Defer           Defer;
-typedef struct  DeferChunk      DeferChunk;
 typedef struct  Panic           Panic;
 typedef struct  Hmap            Hmap;
 typedef struct  Hchan           Hchan;
 typedef struct  Complex64       Complex64;
 typedef struct  Complex128      Complex128;
-typedef struct  WinCall         WinCall;
+typedef struct  LibCall         LibCall;
 typedef struct  SEH             SEH;
 typedef struct  WinCallbackContext      WinCallbackContext;
 typedef struct  Timers          Timers;
 typedef struct  Timer           Timer;
 typedef struct  GCStats         GCStats;
 typedef struct  LFNode          LFNode;
 typedef struct  ParFor          ParFor;
 typedef struct  ParForThread    ParForThread;
 typedef struct  CgoMal          CgoMal;
 typedef struct  PollDesc        PollDesc;
@@ skipping 127 matching lines @@
 {
         // the struct must consist of only uint64's,
         // because it is casted to uint64[].
         uint64  nhandoff;
         uint64  nhandoffcnt;
         uint64  nprocyield;
         uint64  nosyield;
         uint64  nsleep;
 };
 
-struct  WinCall
+struct  LibCall
 {
         void    (*fn)(void*);
         uintptr n;      // number of parameters
         void*   args;   // parameters
         uintptr r1;     // return values
         uintptr r2;
         uintptr err;    // error number
 };
 struct  SEH
 {
@@ skipping 19 matching lines @@
         Defer*  defer;
         Panic*  panic;
         Gobuf   sched;
         uintptr syscallstack;   // if status==Gsyscall, syscallstack = stackbase to use during gc
         uintptr syscallsp;      // if status==Gsyscall, syscallsp = sched.sp to use during gc
         uintptr syscallpc;      // if status==Gsyscall, syscallpc = sched.pc to use during gc
         uintptr syscallguard;   // if status==Gsyscall, syscallguard = stackguard to use during gc
         uintptr stackguard;     // same as stackguard0, but not set to StackPreempt
         uintptr stack0;
         uintptr stacksize;
-        G*      alllink;        // on allg
         void*   param;          // passed parameter on wakeup
         int16   status;
         int64   goid;
+        int64   waitsince;      // approx time when the G become blocked
         int8*   waitreason;     // if status==Gwaiting
         G*      schedlink;
         bool    ispanic;
         bool    issystem;       // do not output in stack dump
         bool    isbackground;   // ignore in deadlock detector
         bool    preempt;        // preemption signal, duplicates stackguard0 = StackPreempt
         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;
         uintptr gopc;           // pc of go statement that created this goroutine
         uintptr racectx;
         uintptr end[];
 };
 struct  M
 {
         G*      g0;             // goroutine with scheduling stack
@@ skipping 48 matching lines @@
         bool    racecall;
         bool    needextram;
         void    (*waitunlockf)(Lock*);
         void*   waitlock;
 
         uintptr settype_buf[1024];
         uintptr settype_bufsize;
 
 #ifdef GOOS_windows
         void*   thread;         // thread handle
-        WinCall wincall;
+        // these are here because they are too large to be on the stack
+        // of low-level NOSPLIT functions.
+        LibCall libcall;
+#endif
+#ifdef GOOS_solaris
+        int32*  perrno;         // pointer to TLS errno
+        // these are here because they are too large to be on the stack
+        // of low-level NOSPLIT functions.
+        LibCall libcall;
+        struct {
+                int64   tv_sec;
+                int64   tv_nsec;
+        } ts;
+        struct {
+                uintptr v[6];
+        } scratch;
 #endif
 #ifdef GOOS_plan9
         int8*   notesig;
         byte*   errstr;
 #endif
         SEH*    seh;
         uintptr end[];
 };
 
 struct P
 {
         Lock;
 
         int32   id;
         uint32  status;         // one of Pidle/Prunning/...
         P*      link;
         uint32  schedtick;      // incremented on every scheduler call
         uint32  syscalltick;    // incremented on every system call
         M*      m;              // back-link to associated M (nil if idle)
         MCache* mcache;
+        Defer*  deferpool[5];   // pool of available Defer structs of different sizes (see panic.c)
 
         // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
         uint64  goidcache;
         uint64  goidcacheend;
 
         // Queue of runnable goroutines.
-        G**     runq;
-        int32   runqhead;
-        int32   runqtail;
-        int32   runqsize;
+        uint32  runqhead;
+        uint32  runqtail;
+        G*      runq[256];
 
         // Available G's (status == Gdead)
         G*      gfree;
         int32   gfreecnt;
 
         byte    pad[64];
 };
 
 // The m->locked word holds two pieces of state counting active calls to LockOSThread/lockOSThread.
 // The low bit (LockExternal) is a boolean reporting whether any LockOSThread call is active.
@@ skipping 68 matching lines @@
         void    (*fun[])(void);
 };
 
 #ifdef GOOS_windows
 enum {
    Windows = 1
 };
 #else
 enum {
    Windows = 0
+};
+#endif
+#ifdef GOOS_solaris
+enum {
+   Solaris = 1
+};
+#else
+enum {
+   Solaris = 0
 };
 #endif
 
 struct  Timers
 {
         Lock;
         G       *timerproc;
         bool            sleeping;
         bool            rescheduling;
         Note    waitnote;
@@ skipping 167 matching lines @@
 void    runtime·intercopy(uintptr, void*, void*);
 void    runtime·nilintercopy(uintptr, void*, void*);
 
 /*
  * deferred subroutine calls
  */
 struct Defer
 {
         int32   siz;
         bool    special;        // not part of defer frame
-        bool    free;           // if special, free when done
         byte*   argp;           // where args were copied from
         byte*   pc;
         FuncVal*        fn;
         Defer*  link;
         void*   args[1];        // padded to actual size
-};
-
-struct DeferChunk
-{
-        DeferChunk      *prev;
-        uintptr off;
 };
 
 /*
  * panics
  */
 struct Panic
 {
         Eface   arg;            // argument to panic
         uintptr stackbase;      // g->stackbase in panic
         Panic*  link;           // link to earlier panic
@@ skipping 20 matching lines @@
 void    runtime·traceback(uintptr pc, uintptr sp, uintptr lr, G* gp);
 void    runtime·tracebackothers(G*);
 bool    runtime·haszeroargs(uintptr pc);
 bool    runtime·topofstack(Func*);
 
 /*
  * external data
  */
 extern  String  runtime·emptystring;
 extern  uintptr runtime·zerobase;
-extern  G*      runtime·allg;
+extern  G**     runtime·allg;
+extern  uintptr runtime·allglen;
 extern  G*      runtime·lastg;
 extern  M*      runtime·allm;
 extern  P**     runtime·allp;
 extern  int32   runtime·gomaxprocs;
 extern  uint32  runtime·needextram;
 extern  uint32  runtime·panicking;
 extern  int8*   runtime·goos;
 extern  int32   runtime·ncpu;
 extern  bool    runtime·iscgo;
 extern  void    (*runtime·sysargs)(int32, uint8**);
@@ skipping 86 matching lines @@
 int32   runtime·funcline(Func*, uintptr, String*);
 int32   runtime·funcarglen(Func*, uintptr);
 int32   runtime·funcspdelta(Func*, uintptr);
 int8*   runtime·funcname(Func*);
 int32   runtime·pcdatavalue(Func*, int32, uintptr);
 void*   runtime·stackalloc(uint32);
 void    runtime·stackfree(void*, uintptr);
 MCache* runtime·allocmcache(void);
 void    runtime·freemcache(MCache*);
 void    runtime·mallocinit(void);
-void    runtime·mprofinit(void);
 bool    runtime·ifaceeq_c(Iface, Iface);
 bool    runtime·efaceeq_c(Eface, Eface);
 uintptr runtime·ifacehash(Iface, uintptr);
 uintptr runtime·efacehash(Eface, uintptr);
 void*   runtime·malloc(uintptr size);
 void    runtime·free(void *v);
 void    runtime·runpanic(Panic*);
 uintptr runtime·getcallersp(void*);
 int32   runtime·mcount(void);
 int32   runtime·gcount(void);
@@ skipping 18 matching lines @@
 void    runtime·entersyscallblock(void);
 void    runtime·exitsyscall(void);
 G*      runtime·newproc1(FuncVal*, byte*, int32, int32, void*);
 bool    runtime·sigsend(int32 sig);
 int32   runtime·callers(int32, uintptr*, int32);
 int64   runtime·nanotime(void);
 void    runtime·dopanic(int32);
 void    runtime·startpanic(void);
 void    runtime·freezetheworld(void);
 void    runtime·unwindstack(G*, byte*);
-void    runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp);
+void    runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp);
 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);
 void    runtime·netpollinit(void);
 int32   runtime·netpollopen(uintptr, PollDesc*);
 int32   runtime·netpollclose(uintptr);
 void    runtime·netpollready(G**, PollDesc*, int32);
 uintptr runtime·netpollfd(PollDesc*);
+void    runtime·netpollarmread(uintptr fd);
+void    runtime·netpollarmwrite(uintptr fd);
 void    runtime·crash(void);
 void    runtime·parsedebugvars(void);
 void    _rt0_go(void);
 void*   runtime·funcdata(Func*, int32);
 
 #pragma varargck        argpos  runtime·printf  1
 #pragma varargck        type    "c"     int32
 #pragma varargck        type    "d"     int32
 #pragma varargck        type    "d"     uint32
 #pragma varargck        type    "D"     int64
@@ skipping 178 matching lines @@
 extern float64 runtime·neginf;
 extern uint64 ·nan;
 extern uint64 ·posinf;
 extern uint64 ·neginf;
 #define ISNAN(f) ((f) != (f))
 
 enum
 {
         UseSpanType = 1,
 };