github.com/riscv/riscv-go@v0.0.0-20200123204226-124ebd6fcc8e/src/runtime/export_test.go (about) 1 // Copyright 2010 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // Export guts for testing. 6 7 package runtime 8 9 import ( 10 "runtime/internal/atomic" 11 "runtime/internal/sys" 12 "unsafe" 13 ) 14 15 var Fadd64 = fadd64 16 var Fsub64 = fsub64 17 var Fmul64 = fmul64 18 var Fdiv64 = fdiv64 19 var F64to32 = f64to32 20 var F32to64 = f32to64 21 var Fcmp64 = fcmp64 22 var Fintto64 = fintto64 23 var F64toint = f64toint 24 var Sqrt = sqrt 25 26 var Entersyscall = entersyscall 27 var Exitsyscall = exitsyscall 28 var LockedOSThread = lockedOSThread 29 var Xadduintptr = atomic.Xadduintptr 30 31 var FuncPC = funcPC 32 33 var Fastlog2 = fastlog2 34 35 var Atoi = atoi 36 var Atoi32 = atoi32 37 38 type LFNode struct { 39 Next uint64 40 Pushcnt uintptr 41 } 42 43 func LFStackPush(head *uint64, node *LFNode) { 44 lfstackpush(head, (*lfnode)(unsafe.Pointer(node))) 45 } 46 47 func LFStackPop(head *uint64) *LFNode { 48 return (*LFNode)(unsafe.Pointer(lfstackpop(head))) 49 } 50 51 func GCMask(x interface{}) (ret []byte) { 52 systemstack(func() { 53 ret = getgcmask(x) 54 }) 55 return 56 } 57 58 func RunSchedLocalQueueTest() { 59 _p_ := new(p) 60 gs := make([]g, len(_p_.runq)) 61 for i := 0; i < len(_p_.runq); i++ { 62 if g, _ := runqget(_p_); g != nil { 63 throw("runq is not empty initially") 64 } 65 for j := 0; j < i; j++ { 66 runqput(_p_, &gs[i], false) 67 } 68 for j := 0; j < i; j++ { 69 if g, _ := runqget(_p_); g != &gs[i] { 70 print("bad element at iter ", i, "/", j, "\n") 71 throw("bad element") 72 } 73 } 74 if g, _ := runqget(_p_); g != nil { 75 throw("runq is not empty afterwards") 76 } 77 } 78 } 79 80 func RunSchedLocalQueueStealTest() { 81 p1 := new(p) 82 p2 := new(p) 83 gs := make([]g, len(p1.runq)) 84 for i := 0; i < len(p1.runq); i++ { 85 for j := 0; j < i; j++ { 86 gs[j].sig = 0 87 runqput(p1, &gs[j], false) 88 } 89 gp := runqsteal(p2, p1, true) 90 s := 0 91 if gp != nil { 92 s++ 93 gp.sig++ 94 } 95 for { 96 gp, _ = runqget(p2) 97 if gp == nil { 98 break 99 } 100 s++ 101 gp.sig++ 102 } 103 for { 104 gp, _ = runqget(p1) 105 if gp == nil { 106 break 107 } 108 gp.sig++ 109 } 110 for j := 0; j < i; j++ { 111 if gs[j].sig != 1 { 112 print("bad element ", j, "(", gs[j].sig, ") at iter ", i, "\n") 113 throw("bad element") 114 } 115 } 116 if s != i/2 && s != i/2+1 { 117 print("bad steal ", s, ", want ", i/2, " or ", i/2+1, ", iter ", i, "\n") 118 throw("bad steal") 119 } 120 } 121 } 122 123 func RunSchedLocalQueueEmptyTest(iters int) { 124 // Test that runq is not spuriously reported as empty. 125 // Runq emptiness affects scheduling decisions and spurious emptiness 126 // can lead to underutilization (both runnable Gs and idle Ps coexist 127 // for arbitrary long time). 128 done := make(chan bool, 1) 129 p := new(p) 130 gs := make([]g, 2) 131 ready := new(uint32) 132 for i := 0; i < iters; i++ { 133 *ready = 0 134 next0 := (i & 1) == 0 135 next1 := (i & 2) == 0 136 runqput(p, &gs[0], next0) 137 go func() { 138 for atomic.Xadd(ready, 1); atomic.Load(ready) != 2; { 139 } 140 if runqempty(p) { 141 println("next:", next0, next1) 142 throw("queue is empty") 143 } 144 done <- true 145 }() 146 for atomic.Xadd(ready, 1); atomic.Load(ready) != 2; { 147 } 148 runqput(p, &gs[1], next1) 149 runqget(p) 150 <-done 151 runqget(p) 152 } 153 } 154 155 var StringHash = stringHash 156 var BytesHash = bytesHash 157 var Int32Hash = int32Hash 158 var Int64Hash = int64Hash 159 var EfaceHash = efaceHash 160 var IfaceHash = ifaceHash 161 162 func MemclrBytes(b []byte) { 163 s := (*slice)(unsafe.Pointer(&b)) 164 memclrNoHeapPointers(s.array, uintptr(s.len)) 165 } 166 167 var HashLoad = &hashLoad 168 169 // entry point for testing 170 func GostringW(w []uint16) (s string) { 171 systemstack(func() { 172 s = gostringw(&w[0]) 173 }) 174 return 175 } 176 177 type Uintreg sys.Uintreg 178 179 var Open = open 180 var Close = closefd 181 var Read = read 182 var Write = write 183 184 func Envs() []string { return envs } 185 func SetEnvs(e []string) { envs = e } 186 187 var BigEndian = sys.BigEndian 188 189 // For benchmarking. 190 191 func BenchSetType(n int, x interface{}) { 192 e := *efaceOf(&x) 193 t := e._type 194 var size uintptr 195 var p unsafe.Pointer 196 switch t.kind & kindMask { 197 case kindPtr: 198 t = (*ptrtype)(unsafe.Pointer(t)).elem 199 size = t.size 200 p = e.data 201 case kindSlice: 202 slice := *(*struct { 203 ptr unsafe.Pointer 204 len, cap uintptr 205 })(e.data) 206 t = (*slicetype)(unsafe.Pointer(t)).elem 207 size = t.size * slice.len 208 p = slice.ptr 209 } 210 allocSize := roundupsize(size) 211 systemstack(func() { 212 for i := 0; i < n; i++ { 213 heapBitsSetType(uintptr(p), allocSize, size, t) 214 } 215 }) 216 } 217 218 const PtrSize = sys.PtrSize 219 220 var ForceGCPeriod = &forcegcperiod 221 222 // SetTracebackEnv is like runtime/debug.SetTraceback, but it raises 223 // the "environment" traceback level, so later calls to 224 // debug.SetTraceback (e.g., from testing timeouts) can't lower it. 225 func SetTracebackEnv(level string) { 226 setTraceback(level) 227 traceback_env = traceback_cache 228 } 229 230 var ReadUnaligned32 = readUnaligned32 231 var ReadUnaligned64 = readUnaligned64 232 233 func CountPagesInUse() (pagesInUse, counted uintptr) { 234 stopTheWorld("CountPagesInUse") 235 236 pagesInUse = uintptr(mheap_.pagesInUse) 237 238 for _, s := range mheap_.allspans { 239 if s.state == mSpanInUse { 240 counted += s.npages 241 } 242 } 243 244 startTheWorld() 245 246 return 247 }