github.com/4ad/go@v0.0.0-20161219182952-69a12818b605/src/runtime/extern.go (about) 1 // Copyright 2009 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 /* 6 Package runtime contains operations that interact with Go's runtime system, 7 such as functions to control goroutines. It also includes the low-level type information 8 used by the reflect package; see reflect's documentation for the programmable 9 interface to the run-time type system. 10 11 Environment Variables 12 13 The following environment variables ($name or %name%, depending on the host 14 operating system) control the run-time behavior of Go programs. The meanings 15 and use may change from release to release. 16 17 The GOGC variable sets the initial garbage collection target percentage. 18 A collection is triggered when the ratio of freshly allocated data to live data 19 remaining after the previous collection reaches this percentage. The default 20 is GOGC=100. Setting GOGC=off disables the garbage collector entirely. 21 The runtime/debug package's SetGCPercent function allows changing this 22 percentage at run time. See https://golang.org/pkg/runtime/debug/#SetGCPercent. 23 24 The GODEBUG variable controls debugging variables within the runtime. 25 It is a comma-separated list of name=val pairs setting these named variables: 26 27 allocfreetrace: setting allocfreetrace=1 causes every allocation to be 28 profiled and a stack trace printed on each object's allocation and free. 29 30 cgocheck: setting cgocheck=0 disables all checks for packages 31 using cgo to incorrectly pass Go pointers to non-Go code. 32 Setting cgocheck=1 (the default) enables relatively cheap 33 checks that may miss some errors. Setting cgocheck=2 enables 34 expensive checks that should not miss any errors, but will 35 cause your program to run slower. 36 37 efence: setting efence=1 causes the allocator to run in a mode 38 where each object is allocated on a unique page and addresses are 39 never recycled. 40 41 gccheckmark: setting gccheckmark=1 enables verification of the 42 garbage collector's concurrent mark phase by performing a 43 second mark pass while the world is stopped. If the second 44 pass finds a reachable object that was not found by concurrent 45 mark, the garbage collector will panic. 46 47 gcpacertrace: setting gcpacertrace=1 causes the garbage collector to 48 print information about the internal state of the concurrent pacer. 49 50 gcshrinkstackoff: setting gcshrinkstackoff=1 disables moving goroutines 51 onto smaller stacks. In this mode, a goroutine's stack can only grow. 52 53 gcstackbarrieroff: setting gcstackbarrieroff=1 disables the use of stack barriers 54 that allow the garbage collector to avoid repeating a stack scan during the 55 mark termination phase. 56 57 gcstackbarrierall: setting gcstackbarrierall=1 installs stack barriers 58 in every stack frame, rather than in exponentially-spaced frames. 59 60 gcstoptheworld: setting gcstoptheworld=1 disables concurrent garbage collection, 61 making every garbage collection a stop-the-world event. Setting gcstoptheworld=2 62 also disables concurrent sweeping after the garbage collection finishes. 63 64 gctrace: setting gctrace=1 causes the garbage collector to emit a single line to standard 65 error at each collection, summarizing the amount of memory collected and the 66 length of the pause. Setting gctrace=2 emits the same summary but also 67 repeats each collection. The format of this line is subject to change. 68 Currently, it is: 69 gc # @#s #%: #+#+# ms clock, #+#/#/#+# ms cpu, #->#-># MB, # MB goal, # P 70 where the fields are as follows: 71 gc # the GC number, incremented at each GC 72 @#s time in seconds since program start 73 #% percentage of time spent in GC since program start 74 #+...+# wall-clock/CPU times for the phases of the GC 75 #->#-># MB heap size at GC start, at GC end, and live heap 76 # MB goal goal heap size 77 # P number of processors used 78 The phases are stop-the-world (STW) sweep termination, concurrent 79 mark and scan, and STW mark termination. The CPU times 80 for mark/scan are broken down in to assist time (GC performed in 81 line with allocation), background GC time, and idle GC time. 82 If the line ends with "(forced)", this GC was forced by a 83 runtime.GC() call and all phases are STW. 84 85 Setting gctrace to any value > 0 also causes the garbage collector 86 to emit a summary when memory is released back to the system. 87 This process of returning memory to the system is called scavenging. 88 The format of this summary is subject to change. 89 Currently it is: 90 scvg#: # MB released printed only if non-zero 91 scvg#: inuse: # idle: # sys: # released: # consumed: # (MB) 92 where the fields are as follows: 93 scvg# the scavenge cycle number, incremented at each scavenge 94 inuse: # MB used or partially used spans 95 idle: # MB spans pending scavenging 96 sys: # MB mapped from the system 97 released: # MB released to the system 98 consumed: # MB allocated from the system 99 100 memprofilerate: setting memprofilerate=X will update the value of runtime.MemProfileRate. 101 When set to 0 memory profiling is disabled. Refer to the description of 102 MemProfileRate for the default value. 103 104 invalidptr: defaults to invalidptr=1, causing the garbage collector and stack 105 copier to crash the program if an invalid pointer value (for example, 1) 106 is found in a pointer-typed location. Setting invalidptr=0 disables this check. 107 This should only be used as a temporary workaround to diagnose buggy code. 108 The real fix is to not store integers in pointer-typed locations. 109 110 sbrk: setting sbrk=1 replaces the memory allocator and garbage collector 111 with a trivial allocator that obtains memory from the operating system and 112 never reclaims any memory. 113 114 scavenge: scavenge=1 enables debugging mode of heap scavenger. 115 116 scheddetail: setting schedtrace=X and scheddetail=1 causes the scheduler to emit 117 detailed multiline info every X milliseconds, describing state of the scheduler, 118 processors, threads and goroutines. 119 120 schedtrace: setting schedtrace=X causes the scheduler to emit a single line to standard 121 error every X milliseconds, summarizing the scheduler state. 122 123 The net and net/http packages also refer to debugging variables in GODEBUG. 124 See the documentation for those packages for details. 125 126 The GOMAXPROCS variable limits the number of operating system threads that 127 can execute user-level Go code simultaneously. There is no limit to the number of threads 128 that can be blocked in system calls on behalf of Go code; those do not count against 129 the GOMAXPROCS limit. This package's GOMAXPROCS function queries and changes 130 the limit. 131 132 The GOTRACEBACK variable controls the amount of output generated when a Go 133 program fails due to an unrecovered panic or an unexpected runtime condition. 134 By default, a failure prints a stack trace for the current goroutine, 135 eliding functions internal to the run-time system, and then exits with exit code 2. 136 The failure prints stack traces for all goroutines if there is no current goroutine 137 or the failure is internal to the run-time. 138 GOTRACEBACK=none omits the goroutine stack traces entirely. 139 GOTRACEBACK=single (the default) behaves as described above. 140 GOTRACEBACK=all adds stack traces for all user-created goroutines. 141 GOTRACEBACK=system is like ``all'' but adds stack frames for run-time functions 142 and shows goroutines created internally by the run-time. 143 GOTRACEBACK=crash is like ``system'' but crashes in an operating system-specific 144 manner instead of exiting. For example, on Unix systems, the crash raises 145 SIGABRT to trigger a core dump. 146 For historical reasons, the GOTRACEBACK settings 0, 1, and 2 are synonyms for 147 none, all, and system, respectively. 148 The runtime/debug package's SetTraceback function allows increasing the 149 amount of output at run time, but it cannot reduce the amount below that 150 specified by the environment variable. 151 See https://golang.org/pkg/runtime/debug/#SetTraceback. 152 153 The GOARCH, GOOS, GOPATH, and GOROOT environment variables complete 154 the set of Go environment variables. They influence the building of Go programs 155 (see https://golang.org/cmd/go and https://golang.org/pkg/go/build). 156 GOARCH, GOOS, and GOROOT are recorded at compile time and made available by 157 constants or functions in this package, but they do not influence the execution 158 of the run-time system. 159 */ 160 package runtime 161 162 import "runtime/internal/sys" 163 164 // Caller reports file and line number information about function invocations on 165 // the calling goroutine's stack. The argument skip is the number of stack frames 166 // to ascend, with 0 identifying the caller of Caller. (For historical reasons the 167 // meaning of skip differs between Caller and Callers.) The return values report the 168 // program counter, file name, and line number within the file of the corresponding 169 // call. The boolean ok is false if it was not possible to recover the information. 170 func Caller(skip int) (pc uintptr, file string, line int, ok bool) { 171 // Ask for two PCs: the one we were asked for 172 // and what it called, so that we can see if it 173 // "called" sigpanic. 174 var rpc [2]uintptr 175 if callers(1+skip-1, rpc[:]) < 2 { 176 return 177 } 178 f := findfunc(rpc[1]) 179 if f == nil { 180 // TODO(rsc): Probably a bug? 181 // The C version said "have retpc at least" 182 // but actually returned pc=0. 183 ok = true 184 return 185 } 186 pc = rpc[1] 187 xpc := pc 188 g := findfunc(rpc[0]) 189 // All architectures turn faults into apparent calls to sigpanic. 190 // If we see a call to sigpanic, we do not back up the PC to find 191 // the line number of the call instruction, because there is no call. 192 // SPARC64's PC holds the address of the *current* instruction. 193 if xpc > f.entry && (g == nil || g.entry != funcPC(sigpanic)) && sys.GoarchSparc64 == 0 { 194 xpc-- 195 } 196 file, line32 := funcline(f, xpc) 197 line = int(line32) 198 ok = true 199 return 200 } 201 202 // Callers fills the slice pc with the return program counters of function invocations 203 // on the calling goroutine's stack. The argument skip is the number of stack frames 204 // to skip before recording in pc, with 0 identifying the frame for Callers itself and 205 // 1 identifying the caller of Callers. 206 // It returns the number of entries written to pc. 207 // 208 // Note that since each slice entry pc[i] is a return program counter, 209 // looking up the file and line for pc[i] (for example, using (*Func).FileLine) 210 // will normally return the file and line number of the instruction immediately 211 // following the call. 212 // To easily look up file/line information for the call sequence, use Frames. 213 func Callers(skip int, pc []uintptr) int { 214 // runtime.callers uses pc.array==nil as a signal 215 // to print a stack trace. Pick off 0-length pc here 216 // so that we don't let a nil pc slice get to it. 217 if len(pc) == 0 { 218 return 0 219 } 220 return callers(skip, pc) 221 } 222 223 // GOROOT returns the root of the Go tree. 224 // It uses the GOROOT environment variable, if set, 225 // or else the root used during the Go build. 226 func GOROOT() string { 227 s := gogetenv("GOROOT") 228 if s != "" { 229 return s 230 } 231 return sys.DefaultGoroot 232 } 233 234 // Version returns the Go tree's version string. 235 // It is either the commit hash and date at the time of the build or, 236 // when possible, a release tag like "go1.3". 237 func Version() string { 238 return sys.TheVersion 239 } 240 241 // GOOS is the running program's operating system target: 242 // one of darwin, freebsd, linux, and so on. 243 const GOOS string = sys.GOOS 244 245 // GOARCH is the running program's architecture target: 246 // 386, amd64, arm, or s390x. 247 const GOARCH string = sys.GOARCH