code review 123640043: runtime: convert common scheduler functions to Go

src/pkg/runtime/stubs.go

 // Copyright 2014 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.
 
 package runtime
 
 import "unsafe"
 
 // Declarations for runtime services implemented in C or assembly.
 // C implementations of these functions are in stubs.goc.
@@ skipping 23 matching lines @@
 func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
         return unsafe.Pointer(uintptr(p) + x)
 }
 
 // n must be a power of 2
 func roundup(p unsafe.Pointer, n uintptr) unsafe.Pointer {
         return unsafe.Pointer((uintptr(p) + n - 1) &^ (n - 1))
 }
 
 // in stubs.goc
+func getg() *g
 func acquirem() *m
 func releasem(mp *m)
 func gomcache() *mcache
 
 // An mFunction represents a C function that runs on the M stack.  It
 // can be called from Go using mcall or onM.  Through the magic of
 // linking, an mFunction variable and the corresponding C code entry
 // point live at the same address.
 type mFunction byte
 
 // in asm_*.s
 func mcall(fn *mFunction)
 func onM(fn *mFunction)
 
 // C functions that run on the M stack.  Call these like
 //   mcall(&mcacheRefill_m)
 // Arguments should be passed in m->scalararg[x] and
 // m->ptrarg[x].  Return values can be passed in those
 // same slots.
 var (
         mcacheRefill_m,
         largeAlloc_m,
         mprofMalloc_m,
         gc_m,
         setFinalizer_m,
         markallocated_m,
         unrollgcprog_m,
         unrollgcproginplace_m,
-        gosched_m mFunction
+        gosched_m,
+        ready_m,
+        park_m,
+        blockevent_m mFunction
 )
 
 // memclr clears n bytes starting at ptr.
 // in memclr_*.s
 //go:noescape
 func memclr(ptr unsafe.Pointer, n uintptr)
 
 func racemalloc(p unsafe.Pointer, size uintptr)
 func tracealloc(p unsafe.Pointer, size uintptr, typ *_type)
 
@@ skipping 73 matching lines @@
 // compiles down to a single xor instruction.
 // USE CAREFULLY!
 func noescape(p unsafe.Pointer) unsafe.Pointer {
         x := uintptr(p)
         return unsafe.Pointer(x ^ 0)
 }
 
 // gopersistentalloc allocates a permanent (not garbage collected)
 // memory region of size n.  Use wisely!
 func gopersistentalloc(n uintptr) unsafe.Pointer
+
+func gocputicks() int64