code review 123700044: runtime: convert timers to Go

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 45 matching lines @@
 #define double                  XXdouble / / /
 
 /*
  * defined types
  */
 typedef uint8                   bool;
 typedef uint8                   byte;
 typedef struct  Func            Func;
 typedef struct  G               G;
 typedef struct  Gobuf           Gobuf;
+typedef struct  SudoG           SudoG;
 typedef struct  Lock            Lock;
 typedef struct  M               M;
 typedef struct  P               P;
 typedef struct  Note            Note;
 typedef struct  Slice           Slice;
 typedef struct  Stktop          Stktop;
 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  Panic           Panic;
 typedef struct  Hmap            Hmap;
 typedef struct  Hiter                   Hiter;
 typedef struct  Hchan           Hchan;
 typedef struct  Complex64       Complex64;
 typedef struct  Complex128      Complex128;
 typedef struct  LibCall         LibCall;
 typedef struct  WinCallbackContext      WinCallbackContext;
-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;
 typedef struct  DebugVars       DebugVars;
 
 /*
  * Per-CPU declaration.
@@ skipping 103 matching lines @@
 };
 struct  Gobuf
 {
         // The offsets of sp, pc, and g are known to (hard-coded in) libmach.
         uintptr sp;
         uintptr pc;
         G*      g;
         void*   ctxt; // this has to be a pointer so that GC scans it
         uintreg ret;
         uintptr lr;
+};
+// Known to compiler.
+// Changes here must also be made in src/cmd/gc/select.c's selecttype.
+struct  SudoG
+{
+        G*      g;
+        uint32* selectdone;
+        SudoG*  next;
+        SudoG*  prev;
+        void*   elem;           // data element
+        int64   releasetime;
+        int32   nrelease;       // -1 for acquire
+        SudoG*  waitlink;       // G.waiting list
 };
 struct  GCStats
 {
         // the struct must consist of only uint64's,
         // because it is casted to uint64[].
         uint64  nhandoff;
         uint64  nhandoffcnt;
         uint64  nprocyield;
         uint64  nosyield;
         uint64  nsleep;
@@ skipping 31 matching lines @@
         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;
         void*   param;          // passed parameter on wakeup
         int16   status;
         int64   goid;
         int64   waitsince;      // approx time when the G become blocked
-        int8*   waitreason;     // if status==Gwaiting
+        String  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
         bool    paniconfault;   // panic (instead of crash) on unexpected fault address
         int8    raceignore;     // ignore race detection events
         M*      m;              // for debuggers, but offset not hard-coded
         M*      lockedm;
         int32   sig;
         int32   writenbuf;
         byte*   writebuf;
         uintptr sigcode0;
         uintptr sigcode1;
         uintptr sigpc;
         uintptr gopc;           // pc of go statement that created this goroutine
         uintptr racectx;
+        SudoG   *waiting;       // sudog structures this G is waiting on (that have a valid elem ptr)
         uintptr end[];
 };
 
 struct  M
 {
         G*      g0;             // goroutine with scheduling stack
         void*   moreargp;       // argument pointer for more stack
         Gobuf   morebuf;        // gobuf arg to morestack
 
         // Fields not known to debuggers.
@@ skipping 142 matching lines @@
         SigPanic = 1<<3,        // if the signal is from the kernel, panic
         SigDefault = 1<<4,      // if the signal isn't explicitly requested, don't monitor it
         SigHandling = 1<<5,     // our signal handler is registered
         SigIgnored = 1<<6,      // the signal was ignored before we registered for it
         SigGoExit = 1<<7,       // cause all runtime procs to exit (only used on Plan 9).
 };
 
 // Layout of in-memory per-function information prepared by linker
 // See http://golang.org/s/go12symtab.
 // Keep in sync with linker and with ../../libmach/sym.c
-// and with package debug/gosym.
+// and with package debug/gosym and with symtab.go in package runtime.
 struct  Func
 {
         uintptr entry;  // start pc
         int32   nameoff;// function name
 ········
         int32   args;   // in/out args size
         int32   frame;  // legacy frame size; use pcsp if possible
 
         int32   pcsp;
         int32   pcfile;
@@ skipping 284 matching lines @@
 extern  int32   runtime·ncpu;
 extern  bool    runtime·iscgo;
 extern  void    (*runtime·sysargs)(int32, uint8**);
 extern  uintptr runtime·maxstring;
 extern  uint32  runtime·cpuid_ecx;
 extern  uint32  runtime·cpuid_edx;
 extern  DebugVars       runtime·debug;
 extern  uintptr runtime·maxstacksize;
 extern  byte*   runtime·gcdatamask;
 extern  byte*   runtime·gcbssmask;
+extern  Note    runtime·signote;
 
 /*
  * common functions and data
  */
 int32   runtime·strcmp(byte*, byte*);
 int32   runtime·strncmp(byte*, byte*, uintptr);
 byte*   runtime·strstr(byte*, byte*);
 intgo   runtime·findnull(byte*);
 intgo   runtime·findnullw(uint16*);
 void    runtime·dump(byte*, int32);
@@ skipping 82 matching lines @@
 int8*   runtime·funcname(Func*);
 int32   runtime·pcdatavalue(Func*, int32, uintptr);
 void    runtime·stackinit(void);
 void*   runtime·stackalloc(G*, uint32);
 void    runtime·stackfree(G*, void*, Stktop*);
 void    runtime·shrinkstack(G*);
 MCache* runtime·allocmcache(void);
 void    runtime·freemcache(MCache*);
 void    runtime·mallocinit(void);
 void    runtime·gcinit(void);
-void    runtime·chaninit(void);
 void*   runtime·mallocgc(uintptr size, Type* typ, uint32 flag);
 void    runtime·runpanic(Panic*);
 uintptr runtime·getcallersp(void*);
 int32   runtime·mcount(void);
 int32   runtime·gcount(void);
 void    runtime·mcall(void(*)(G*));
 void    runtime·onM(void(*)(void));
 uint32  runtime·fastrand1(void);
 void    runtime·rewindmorestack(Gobuf*);
 int32   runtime·timediv(int64, int32, int32*);
@@ skipping 18 matching lines @@
 void    runtime·atomicstorep(void* volatile*, void*);
 void    runtime·atomicor8(byte volatile*, byte);
 
 void    runtime·setg(G*);
 void    runtime·newextram(void);
 void    runtime·exit(int32);
 void    runtime·breakpoint(void);
 void    runtime·gosched(void);
 void    runtime·gosched_m(G*);
 void    runtime·schedtrace(bool);
-void    runtime·park(bool(*)(G*, void*), void*, int8*);
-void    runtime·parkunlock(Lock*, int8*);
-void    runtime·tsleep(int64, int8*);
+void    runtime·park(bool(*)(G*, void*), void*, String);
+void    runtime·parkunlock(Lock*, String);
+void    runtime·tsleep(int64, String);
 M*      runtime·newm(void);
 void    runtime·goexit(void);
 void    runtime·asmcgocall(void (*fn)(void*), void*);
 void    runtime·entersyscall(void);
 void    runtime·entersyscallblock(void);
 void    runtime·exitsyscall(void);
+void    runtime·entersyscallblock_m(void);
 G*      runtime·newproc1(FuncVal*, byte*, int32, int32, void*);
 bool    runtime·sigsend(int32 sig);
 int32   runtime·callers(int32, uintptr*, int32);
 int32   runtime·gcallers(G*, int32, uintptr*, int32);
 int64   runtime·nanotime(void); // monotonic time
 int64   runtime·unixnanotime(void); // real time, can skip
 void    runtime·dopanic(int32);
 void    runtime·startpanic(void);
 void    runtime·freezetheworld(void);
 void    runtime·unwindstack(G*, byte*);
@@ skipping 13 matching lines @@
 uintptr runtime·netpollfd(PollDesc*);
 void    runtime·netpollarm(PollDesc*, int32);
 void**  runtime·netpolluser(PollDesc*);
 bool    runtime·netpollclosing(PollDesc*);
 void    runtime·netpolllock(PollDesc*);
 void    runtime·netpollunlock(PollDesc*);
 void    runtime·crash(void);
 void    runtime·parsedebugvars(void);
 void    _rt0_go(void);
 void*   runtime·funcdata(Func*, int32);
-int32   runtime·setmaxthreads(int32);
+void    runtime·setmaxthreads_m(void);
 G*      runtime·timejump(void);
 void    runtime·iterate_itabs(void (*callback)(Itab*));
 void    runtime·iterate_finq(void (*callback)(FuncVal*, byte*, uintptr, Type*, PtrType*));
 
 #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
 #pragma varargck        type    "D"     uint64
@@ skipping 170 matching lines @@
 extern float64 runtime·neginf;
 extern uint64 ·nan;
 extern uint64 ·posinf;
 extern uint64 ·neginf;
 #define ISNAN(f) ((f) != (f))
 
 enum
 {
         UseSpanType = 1,
 };