File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.17.2/src/runtime

📁 ..
📄 HACKING.md(13.07 KB)
📄 Makefile(178 B)
📄 abi_test.go(2.88 KB)
📄 alg.go(9.45 KB)
📄 asm.s(715 B)
📄 asm_386.s(40.27 KB)
📄 asm_amd64.s(56.93 KB)
📄 asm_arm.s(30.23 KB)
📄 asm_arm64.s(33 KB)
📄 asm_mips64x.s(22.43 KB)
📄 asm_mipsx.s(24.39 KB)
📄 asm_ppc64x.h(1023 B)
📄 asm_ppc64x.s(29.16 KB)
📄 asm_riscv64.s(22.43 KB)
📄 asm_s390x.s(26.04 KB)
📄 asm_wasm.s(9.8 KB)
📄 atomic_arm64.s(259 B)
📄 atomic_mips64x.s(326 B)
📄 atomic_mipsx.s(284 B)
📄 atomic_pointer.go(2.62 KB)
📄 atomic_ppc64x.s(461 B)
📄 atomic_riscv64.s(275 B)
📄 auxv_none.go(360 B)
📄 callers_test.go(7.72 KB)
📁 cgo
📄 cgo.go(2.01 KB)
📄 cgo_mmap.go(2.42 KB)
📄 cgo_ppc64x.go(439 B)
📄 cgo_sigaction.go(3.17 KB)
📄 cgocall.go(18.88 KB)
📄 cgocallback.go(317 B)
📄 cgocheck.go(6.83 KB)
📄 chan.go(23.54 KB)
📄 chan_test.go(23.01 KB)
📄 chanbarrier_test.go(1.4 KB)
📄 checkptr.go(3.29 KB)
📄 checkptr_test.go(1.62 KB)
📄 closure_test.go(937 B)
📄 compiler.go(413 B)
📄 complex.go(1.59 KB)
📄 complex_test.go(1.05 KB)
📄 conv_wasm_test.go(2.96 KB)
📄 cpuflags.go(800 B)
📄 cpuflags_amd64.go(533 B)
📄 cpuflags_arm64.go(334 B)
📄 cpuprof.go(6.92 KB)
📄 cputicks.go(497 B)
📄 crash_cgo_test.go(16.17 KB)
📄 crash_nonunix_test.go(429 B)
📄 crash_test.go(20.96 KB)
📄 crash_unix_test.go(8.52 KB)
📁 debug
📄 debug.go(1.63 KB)
📄 debug_test.go(6.82 KB)
📄 debugcall.go(6.21 KB)
📄 debuglog.go(17.49 KB)
📄 debuglog_off.go(377 B)
📄 debuglog_on.go(1.11 KB)
📄 debuglog_test.go(4.56 KB)
📄 defer_test.go(10.32 KB)
📄 defs1_linux.go(862 B)
📄 defs1_netbsd_386.go(2.84 KB)
📄 defs1_netbsd_amd64.go(3.07 KB)
📄 defs1_netbsd_arm.go(2.96 KB)
📄 defs1_netbsd_arm64.go(3.18 KB)
📄 defs1_solaris_amd64.go(4.02 KB)
📄 defs2_linux.go(3.52 KB)
📄 defs3_linux.go(1.11 KB)
📄 defs_aix.go(4.18 KB)
📄 defs_aix_ppc64.go(3.63 KB)
📄 defs_arm_linux.go(2.69 KB)
📄 defs_darwin.go(3.79 KB)
📄 defs_darwin_amd64.go(6.07 KB)
📄 defs_darwin_arm64.go(3.89 KB)
📄 defs_dragonfly.go(2.63 KB)
📄 defs_dragonfly_amd64.go(3.31 KB)
📄 defs_freebsd.go(3.86 KB)
📄 defs_freebsd_386.go(4.38 KB)
📄 defs_freebsd_amd64.go(4.65 KB)
📄 defs_freebsd_arm.go(3.71 KB)
📄 defs_freebsd_arm64.go(4.03 KB)
📄 defs_illumos_amd64.go(285 B)
📄 defs_linux.go(3.05 KB)
📄 defs_linux_386.go(3.77 KB)
📄 defs_linux_amd64.go(4.28 KB)
📄 defs_linux_arm.go(3.45 KB)
📄 defs_linux_arm64.go(3.21 KB)
📄 defs_linux_mips64x.go(3.24 KB)
📄 defs_linux_mipsx.go(3.21 KB)
📄 defs_linux_ppc64.go(3.28 KB)
📄 defs_linux_ppc64le.go(3.28 KB)
📄 defs_linux_riscv64.go(3.27 KB)
📄 defs_linux_s390x.go(2.76 KB)
📄 defs_netbsd.go(2.76 KB)
📄 defs_netbsd_386.go(872 B)
📄 defs_netbsd_amd64.go(1.03 KB)
📄 defs_netbsd_arm.go(781 B)
📄 defs_openbsd.go(3.1 KB)
📄 defs_openbsd_386.go(2.89 KB)
📄 defs_openbsd_amd64.go(3.09 KB)
📄 defs_openbsd_arm.go(3 KB)
📄 defs_openbsd_arm64.go(2.76 KB)
📄 defs_openbsd_mips64.go(2.66 KB)
📄 defs_plan9_386.go(1.63 KB)
📄 defs_plan9_amd64.go(1.82 KB)
📄 defs_plan9_arm.go(1.73 KB)
📄 defs_solaris.go(3.35 KB)
📄 defs_solaris_amd64.go(1021 B)
📄 defs_windows.go(2.09 KB)
📄 defs_windows_386.go(1.98 KB)
📄 defs_windows_amd64.go(2.71 KB)
📄 defs_windows_arm.go(2.11 KB)
📄 defs_windows_arm64.go(2.63 KB)
📄 duff_386.s(8.24 KB)
📄 duff_amd64.s(5.62 KB)
📄 duff_arm.s(7.11 KB)
📄 duff_arm64.s(5.25 KB)
📄 duff_mips64x.s(11.31 KB)
📄 duff_ppc64x.s(2.43 KB)
📄 duff_riscv64.s(11.38 KB)
📄 duff_s390x.s(507 B)
📄 env_plan9.go(2.99 KB)
📄 env_posix.go(1.95 KB)
📄 env_test.go(1.16 KB)
📄 error.go(9.23 KB)
📄 example_test.go(1.55 KB)
📄 export_aix_test.go(204 B)
📄 export_arm_test.go(226 B)
📄 export_darwin_test.go(351 B)
📄 export_debug_regabiargs_off_test.go(416 B)
📄 export_debug_regabiargs_on_test.go(1.39 KB)
📄 export_debug_test.go(5.86 KB)
📄 export_debuglog_test.go(1.27 KB)
📄 export_futex_test.go(570 B)
📄 export_linux_test.go(429 B)
📄 export_mmap_test.go(571 B)
📄 export_pipe2_test.go(436 B)
📄 export_pipe_test.go(240 B)
📄 export_solaris_test.go(282 B)
📄 export_test.go(30.12 KB)
📄 export_unix_test.go(2.35 KB)
📄 export_windows_test.go(652 B)
📄 extern.go(12.58 KB)
📄 fastlog2.go(1.22 KB)
📄 fastlog2_test.go(784 B)
📄 fastlog2table.go(904 B)
📄 float.go(1.35 KB)
📄 funcdata.h(2.47 KB)
📄 futex_test.go(2.15 KB)
📄 gc_test.go(19.21 KB)
📄 gcinfo_test.go(5.69 KB)
📄 go_tls.h(366 B)
📄 hash32.go(1.61 KB)
📄 hash64.go(2.01 KB)
📄 hash_test.go(16.5 KB)
📄 heapdump.go(17.74 KB)
📄 histogram.go(6.42 KB)
📄 histogram_test.go(1.85 KB)
📄 iface.go(16.13 KB)
📄 iface_test.go(7.51 KB)
📁 internal
📄 lfstack.go(1.77 KB)
📄 lfstack_32bit.go(562 B)
📄 lfstack_64bit.go(2.24 KB)
📄 lfstack_test.go(2.78 KB)
📄 libfuzzer.go(2.6 KB)
📄 libfuzzer_amd64.s(961 B)
📄 libfuzzer_arm64.s(772 B)
📄 lock_futex.go(5.22 KB)
📄 lock_js.go(5.81 KB)
📄 lock_sema.go(6.8 KB)
📄 lockrank.go(11.62 KB)
📄 lockrank_off.go(1.17 KB)
📄 lockrank_on.go(9.84 KB)
📄 lockrank_test.go(1.15 KB)
📄 malloc.go(52.33 KB)
📄 malloc_test.go(10.83 KB)
📄 map.go(42.47 KB)
📄 map_benchmark_test.go(10.51 KB)
📄 map_fast32.go(12.63 KB)
📄 map_fast64.go(12.82 KB)
📄 map_faststr.go(14.15 KB)
📄 map_test.go(27.52 KB)
📄 mbarrier.go(12.2 KB)
📄 mbitmap.go(65.27 KB)
📄 mcache.go(9.68 KB)
📄 mcentral.go(7.8 KB)
📄 mcheckmark.go(2.81 KB)
📄 mem_aix.go(1.94 KB)
📄 mem_bsd.go(2.12 KB)
📄 mem_darwin.go(1.88 KB)
📄 mem_js.go(2.35 KB)
📄 mem_linux.go(5.59 KB)
📄 mem_plan9.go(4.53 KB)
📄 mem_windows.go(3.87 KB)
📄 memclr_386.s(2.42 KB)
📄 memclr_amd64.s(3.89 KB)
📄 memclr_arm.s(2.6 KB)
📄 memclr_arm64.s(3.65 KB)
📄 memclr_mips64x.s(1.75 KB)
📄 memclr_mipsx.s(1.35 KB)
📄 memclr_plan9_386.s(983 B)
📄 memclr_plan9_amd64.s(511 B)
📄 memclr_ppc64x.s(4.31 KB)
📄 memclr_riscv64.s(926 B)
📄 memclr_s390x.s(1.96 KB)
📄 memclr_wasm.s(622 B)
📄 memmove_386.s(4.46 KB)
📄 memmove_amd64.s(12.66 KB)
📄 memmove_arm.s(5.9 KB)
📄 memmove_arm64.s(6 KB)
📄 memmove_linux_amd64_test.go(1.6 KB)
📄 memmove_mips64x.s(1.85 KB)
📄 memmove_mipsx.s(4.42 KB)
📄 memmove_plan9_386.s(3.06 KB)
📄 memmove_plan9_amd64.s(3.04 KB)
📄 memmove_ppc64x.s(4.11 KB)
📄 memmove_riscv64.s(1.81 KB)
📄 memmove_s390x.s(2.92 KB)
📄 memmove_test.go(12.04 KB)
📄 memmove_wasm.s(1.74 KB)
📁 metrics
📄 metrics.go(17.69 KB)
📄 metrics_test.go(12.48 KB)
📄 mfinal.go(15.76 KB)
📄 mfinal_test.go(5.85 KB)
📄 mfixalloc.go(2.73 KB)
📄 mgc.go(55.18 KB)
📄 mgcmark.go(45.54 KB)
📄 mgcpacer.go(29.56 KB)
📄 mgcscavenge.go(35.05 KB)
📄 mgcscavenge_test.go(12.74 KB)
📄 mgcstack.go(10.58 KB)
📄 mgcsweep.go(23.56 KB)
📄 mgcwork.go(12.82 KB)
📄 mheap.go(66.31 KB)
📄 mkduff.go(7.19 KB)
📄 mkfastlog2table.go(1.32 KB)
📄 mkpreempt.go(14.17 KB)
📄 mksizeclasses.go(9.31 KB)
📄 mmap.go(990 B)
📄 mpagealloc.go(36.77 KB)
📄 mpagealloc_32bit.go(3.81 KB)
📄 mpagealloc_64bit.go(6.65 KB)
📄 mpagealloc_test.go(32.38 KB)
📄 mpagecache.go(5.28 KB)
📄 mpagecache_test.go(9.93 KB)
📄 mpallocbits.go(12.01 KB)
📄 mpallocbits_test.go(13.69 KB)
📄 mprof.go(25.82 KB)
📄 mranges.go(11.84 KB)
📄 mranges_test.go(5.68 KB)
📁 msan
📄 msan.go(1.51 KB)
📄 msan0.go(741 B)
📄 msan_amd64.s(2.32 KB)
📄 msan_arm64.s(2.01 KB)
📄 msize.go(777 B)
📄 mspanset.go(12.2 KB)
📄 mstats.go(30.65 KB)
📄 mwbbuf.go(9.3 KB)
📄 nbpipe_fcntl_libc_test.go(499 B)
📄 nbpipe_fcntl_unix_test.go(507 B)
📄 nbpipe_pipe.go(426 B)
📄 nbpipe_pipe2.go(592 B)
📄 nbpipe_test.go(2.26 KB)
📄 net_plan9.go(645 B)
📄 netpoll.go(16.24 KB)
📄 netpoll_aix.go(4.87 KB)
📄 netpoll_epoll.go(4.21 KB)
📄 netpoll_fake.go(670 B)
📄 netpoll_kqueue.go(4.64 KB)
📄 netpoll_os_test.go(360 B)
📄 netpoll_solaris.go(10.75 KB)
📄 netpoll_stub.go(1.42 KB)
📄 netpoll_windows.go(3.75 KB)
📄 norace_linux_test.go(905 B)
📄 norace_test.go(996 B)
📄 numcpu_freebsd_test.go(381 B)
📄 os2_aix.go(20.45 KB)
📄 os2_freebsd.go(302 B)
📄 os2_openbsd.go(296 B)
📄 os2_plan9.go(1.48 KB)
📄 os2_solaris.go(320 B)
📄 os3_plan9.go(3.88 KB)
📄 os3_solaris.go(17.02 KB)
📄 os_aix.go(8.06 KB)
📄 os_android.go(463 B)
📄 os_darwin.go(11.54 KB)
📄 os_darwin_arm64.go(416 B)
📄 os_dragonfly.go(6.46 KB)
📄 os_freebsd.go(11.2 KB)
📄 os_freebsd2.go(507 B)
📄 os_freebsd_amd64.go(529 B)
📄 os_freebsd_arm.go(1.32 KB)
📄 os_freebsd_arm64.go(398 B)
📄 os_freebsd_noauxv.go(264 B)
📄 os_illumos.go(3.93 KB)
📄 os_js.go(3.26 KB)
📄 os_linux.go(13.47 KB)
📄 os_linux_arm.go(1.35 KB)
📄 os_linux_arm64.go(572 B)
📄 os_linux_be64.go(862 B)
📄 os_linux_generic.go(950 B)
📄 os_linux_mips64x.go(1.11 KB)
📄 os_linux_mipsx.go(1.09 KB)
📄 os_linux_noauxv.go(408 B)
📄 os_linux_novdso.go(387 B)
📄 os_linux_ppc64x.go(566 B)
📄 os_linux_riscv64.go(198 B)
📄 os_linux_s390x.go(316 B)
📄 os_linux_x86.go(270 B)
📄 os_netbsd.go(9.09 KB)
📄 os_netbsd_386.go(588 B)
📄 os_netbsd_amd64.go(585 B)
📄 os_netbsd_arm.go(1.13 KB)
📄 os_netbsd_arm64.go(827 B)
📄 os_nonopenbsd.go(456 B)
📄 os_only_solaris.go(376 B)
📄 os_openbsd.go(6.01 KB)
📄 os_openbsd_arm.go(749 B)
📄 os_openbsd_arm64.go(416 B)
📄 os_openbsd_libc.go(1.7 KB)
📄 os_openbsd_mips64.go(416 B)
📄 os_openbsd_syscall.go(1.27 KB)
📄 os_openbsd_syscall1.go(466 B)
📄 os_openbsd_syscall2.go(2.5 KB)
📄 os_plan9.go(10.2 KB)
📄 os_plan9_arm.go(462 B)
📄 os_solaris.go(6.49 KB)
📄 os_windows.go(43.68 KB)
📄 os_windows_arm.go(511 B)
📄 os_windows_arm64.go(339 B)
📄 panic.go(44.28 KB)
📄 panic32.go(4.83 KB)
📄 panic_test.go(1.71 KB)
📄 plugin.go(4.27 KB)
📁 pprof
📄 preempt.go(15.4 KB)
📄 preempt_386.s(1.07 KB)
📄 preempt_amd64.s(1.81 KB)
📄 preempt_arm.s(1.66 KB)
📄 preempt_arm64.s(2.99 KB)
📄 preempt_mips64x.s(2.93 KB)
📄 preempt_mipsx.s(2.89 KB)
📄 preempt_nonwindows.go(309 B)
📄 preempt_ppc64x.s(2.92 KB)
📄 preempt_riscv64.s(2.48 KB)
📄 preempt_s390x.s(1.19 KB)
📄 preempt_wasm.s(365 B)
📄 print.go(5.95 KB)
📄 proc.go(181.46 KB)
📄 proc_runtime_test.go(820 B)
📄 proc_test.go(25.02 KB)
📄 profbuf.go(18.26 KB)
📄 profbuf_test.go(8.65 KB)
📄 proflabel.go(1.52 KB)
📁 race
📄 race.go(18.56 KB)
📄 race0.go(2.81 KB)
📄 race_amd64.s(14.46 KB)
📄 race_arm64.s(13.71 KB)
📄 race_ppc64le.s(17.72 KB)
📄 rand_test.go(783 B)
📄 rdebug.go(553 B)
📄 relax_stub.go(617 B)
📄 rt0_aix_ppc64.s(4.33 KB)
📄 rt0_android_386.s(822 B)
📄 rt0_android_amd64.s(754 B)
📄 rt0_android_arm.s(843 B)
📄 rt0_android_arm64.s(941 B)
📄 rt0_darwin_amd64.s(399 B)
📄 rt0_darwin_arm64.s(2.27 KB)
📄 rt0_dragonfly_amd64.s(448 B)
📄 rt0_freebsd_386.s(454 B)
📄 rt0_freebsd_amd64.s(442 B)
📄 rt0_freebsd_arm.s(298 B)
📄 rt0_freebsd_arm64.s(2.46 KB)
📄 rt0_illumos_amd64.s(311 B)
📄 rt0_ios_amd64.s(425 B)
📄 rt0_ios_arm64.s(425 B)
📄 rt0_js_wasm.s(2.3 KB)
📄 rt0_linux_386.s(450 B)
📄 rt0_linux_amd64.s(307 B)
📄 rt0_linux_arm.s(1007 B)
📄 rt0_linux_arm64.s(2.39 KB)
📄 rt0_linux_mips64x.s(1.03 KB)
📄 rt0_linux_mipsx.s(835 B)
📄 rt0_linux_ppc64.s(865 B)
📄 rt0_linux_ppc64le.s(3.88 KB)
📄 rt0_linux_riscv64.s(370 B)
📄 rt0_linux_s390x.s(676 B)
📄 rt0_netbsd_386.s(452 B)
📄 rt0_netbsd_amd64.s(309 B)
📄 rt0_netbsd_arm.s(296 B)
📄 rt0_netbsd_arm64.s(2.38 KB)
📄 rt0_openbsd_386.s(454 B)
📄 rt0_openbsd_amd64.s(311 B)
📄 rt0_openbsd_arm.s(298 B)
📄 rt0_openbsd_arm64.s(2.54 KB)
📄 rt0_openbsd_mips64.s(976 B)
📄 rt0_plan9_386.s(523 B)
📄 rt0_plan9_amd64.s(481 B)
📄 rt0_plan9_arm.s(397 B)
📄 rt0_solaris_amd64.s(311 B)
📄 rt0_windows_386.s(1.28 KB)
📄 rt0_windows_amd64.s(986 B)
📄 rt0_windows_arm.s(386 B)
📄 rt0_windows_arm64.s(725 B)
📄 runtime-gdb.py(15.02 KB)
📄 runtime-gdb_test.go(20.19 KB)
📄 runtime-lldb_test.go(4.95 KB)
📄 runtime.go(1.42 KB)
📄 runtime1.go(12.63 KB)
📄 runtime2.go(42.27 KB)
📄 runtime_linux_test.go(1.46 KB)
📄 runtime_mmap_test.go(1.91 KB)
📄 runtime_test.go(7.81 KB)
📄 runtime_unix_test.go(1.29 KB)
📄 rwmutex.go(3.53 KB)
📄 rwmutex_test.go(4.03 KB)
📄 select.go(14.45 KB)
📄 sema.go(16.08 KB)
📄 sema_test.go(2.5 KB)
📄 semasleep_test.go(1.65 KB)
📄 sigaction.go(543 B)
📄 signal_386.go(1.72 KB)
📄 signal_aix_ppc64.go(3.56 KB)
📄 signal_amd64.go(2.71 KB)
📄 signal_arm.go(2.56 KB)
📄 signal_arm64.go(3.16 KB)
📄 signal_darwin.go(2.13 KB)
📄 signal_darwin_amd64.go(3.85 KB)
📄 signal_darwin_arm64.go(3.6 KB)
📄 signal_dragonfly.go(2.17 KB)
📄 signal_dragonfly_amd64.go(2.01 KB)
📄 signal_freebsd.go(2.2 KB)
📄 signal_freebsd_386.go(1.55 KB)
📄 signal_freebsd_amd64.go(2.03 KB)
📄 signal_freebsd_arm.go(2.18 KB)
📄 signal_freebsd_arm64.go(3.23 KB)
📄 signal_linux_386.go(1.59 KB)
📄 signal_linux_amd64.go(2.05 KB)
📄 signal_linux_arm.go(2.13 KB)
📄 signal_linux_arm64.go(2.95 KB)
📄 signal_linux_mips64x.go(3.39 KB)
📄 signal_linux_mipsx.go(3.7 KB)
📄 signal_linux_ppc64x.go(3.46 KB)
📄 signal_linux_riscv64.go(2.92 KB)
📄 signal_linux_s390x.go(4.43 KB)
📄 signal_mips64x.go(3.2 KB)
📄 signal_mipsx.go(3.07 KB)
📄 signal_netbsd.go(2.18 KB)
📄 signal_netbsd_386.go(1.76 KB)
📄 signal_netbsd_amd64.go(2.33 KB)
📄 signal_netbsd_arm.go(2.3 KB)
📄 signal_netbsd_arm64.go(3.4 KB)
📄 signal_openbsd.go(2.18 KB)
📄 signal_openbsd_386.go(1.58 KB)
📄 signal_openbsd_amd64.go(2.04 KB)
📄 signal_openbsd_arm.go(2.12 KB)
📄 signal_openbsd_arm64.go(3.38 KB)
📄 signal_openbsd_mips64.go(3.28 KB)
📄 signal_plan9.go(1.93 KB)
📄 signal_ppc64x.go(3.64 KB)
📄 signal_riscv64.go(2.88 KB)
📄 signal_solaris.go(4.5 KB)
📄 signal_solaris_amd64.go(2.47 KB)
📄 signal_unix.go(37.82 KB)
📄 signal_windows.go(9.2 KB)
📄 signal_windows_test.go(5.73 KB)
📄 sigqueue.go(8.76 KB)
📄 sigqueue_note.go(673 B)
📄 sigqueue_plan9.go(3.39 KB)
📄 sigtab_aix.go(11.3 KB)
📄 sigtab_linux_generic.go(3.56 KB)
📄 sigtab_linux_mipsx.go(6.01 KB)
📄 sizeclasses.go(9.14 KB)
📄 sizeof_test.go(905 B)
📄 slice.go(8.94 KB)
📄 slice_test.go(10.32 KB)
📄 softfloat64.go(10.78 KB)
📄 softfloat64_test.go(4.05 KB)
📄 stack.go(41.92 KB)
📄 stack_test.go(21.05 KB)
📄 string.go(10.85 KB)
📄 string_test.go(9.62 KB)
📄 stubs.go(18.17 KB)
📄 stubs2.go(1.14 KB)
📄 stubs3.go(331 B)
📄 stubs_386.go(550 B)
📄 stubs_amd64.go(1.2 KB)
📄 stubs_arm.go(531 B)
📄 stubs_arm64.go(351 B)
📄 stubs_linux.go(663 B)
📄 stubs_mips64x.go(390 B)
📄 stubs_mipsx.go(305 B)
📄 stubs_nonlinux.go(315 B)
📄 stubs_ppc64.go(383 B)
📄 stubs_ppc64le.go(271 B)
📄 stubs_s390x.go(256 B)
📄 symtab.go(32.29 KB)
📄 symtab_test.go(6.78 KB)
📄 sys_aix_ppc64.s(7.13 KB)
📄 sys_arm.go(521 B)
📄 sys_arm64.go(469 B)
📄 sys_darwin.go(15.91 KB)
📄 sys_darwin_amd64.s(18.52 KB)
📄 sys_darwin_arm64.go(1.68 KB)
📄 sys_darwin_arm64.s(17.23 KB)
📄 sys_dragonfly_amd64.s(8.42 KB)
📄 sys_freebsd_386.s(8.98 KB)
📄 sys_freebsd_amd64.s(10.55 KB)
📄 sys_freebsd_arm.s(10.69 KB)
📄 sys_freebsd_arm64.s(10.33 KB)
📄 sys_libc.go(1.87 KB)
📄 sys_linux_386.s(18.17 KB)
📄 sys_linux_amd64.s(16.25 KB)
📄 sys_linux_arm.s(15.84 KB)
📄 sys_linux_arm64.s(15.26 KB)
📄 sys_linux_mips64x.s(13.4 KB)
📄 sys_linux_mipsx.s(11.16 KB)
📄 sys_linux_ppc64x.s(21.48 KB)
📄 sys_linux_riscv64.s(10.35 KB)
📄 sys_linux_s390x.s(10.52 KB)
📄 sys_mips64x.go(526 B)
📄 sys_mipsx.go(518 B)
📄 sys_netbsd_386.s(10.13 KB)
📄 sys_netbsd_amd64.s(9.91 KB)
📄 sys_netbsd_arm.s(10.94 KB)
📄 sys_netbsd_arm64.s(10.42 KB)
📄 sys_nonppc64x.go(271 B)
📄 sys_openbsd.go(2.3 KB)
📄 sys_openbsd1.go(1.16 KB)
📄 sys_openbsd2.go(7.31 KB)
📄 sys_openbsd3.go(3.29 KB)
📄 sys_openbsd_386.s(19.97 KB)
📄 sys_openbsd_amd64.s(16.44 KB)
📄 sys_openbsd_arm.s(18.09 KB)
📄 sys_openbsd_arm64.s(15.92 KB)
📄 sys_openbsd_mips64.s(9.22 KB)
📄 sys_plan9_386.s(4.4 KB)
📄 sys_plan9_amd64.s(4.47 KB)
📄 sys_plan9_arm.s(7.03 KB)
📄 sys_ppc64x.go(556 B)
📄 sys_riscv64.go(469 B)
📄 sys_s390x.go(469 B)
📄 sys_solaris_amd64.s(6.69 KB)
📄 sys_wasm.go(732 B)
📄 sys_wasm.s(2.65 KB)
📄 sys_windows_386.s(7.74 KB)
📄 sys_windows_amd64.s(9.16 KB)
📄 sys_windows_arm.s(12.02 KB)
📄 sys_windows_arm64.s(12.51 KB)
📄 sys_x86.go(574 B)
📄 syscall2_solaris.go(1.65 KB)
📄 syscall_aix.go(5.99 KB)
📄 syscall_solaris.go(8.26 KB)
📄 syscall_windows.go(16.48 KB)
📄 syscall_windows_test.go(32.53 KB)
📁 testdata
📄 textflag.h(1.52 KB)
📄 time.go(30.56 KB)
📄 time_fake.go(2.38 KB)
📄 time_linux_amd64.s(2.18 KB)
📄 time_nofake.go(587 B)
📄 time_test.go(2.03 KB)
📄 time_windows.h(694 B)
📄 time_windows_386.s(1.81 KB)
📄 time_windows_amd64.s(1.07 KB)
📄 time_windows_arm.s(2.07 KB)
📄 time_windows_arm64.s(1.33 KB)
📄 timeasm.go(468 B)
📄 timestub.go(595 B)
📄 timestub2.go(447 B)
📄 tls_arm.s(3.33 KB)
📄 tls_arm64.h(1.22 KB)
📄 tls_arm64.s(1.2 KB)
📄 tls_mips64x.s(759 B)
📄 tls_mipsx.s(731 B)
📄 tls_ppc64x.s(1.52 KB)
📄 tls_riscv64.s(726 B)
📄 tls_s390x.s(1.55 KB)
📄 tls_stub.go(294 B)
📄 tls_windows_amd64.go(294 B)
📁 trace
📄 trace.go(38.36 KB)
📄 traceback.go(46.51 KB)
📄 traceback_test.go(8.04 KB)
📄 type.go(18.59 KB)
📄 typekind.go(742 B)
📄 utf8.go(3.39 KB)
📄 vdso_elf32.go(2.79 KB)
📄 vdso_elf64.go(2.87 KB)
📄 vdso_freebsd.go(2.46 KB)
📄 vdso_freebsd_arm.go(454 B)
📄 vdso_freebsd_arm64.go(443 B)
📄 vdso_freebsd_x86.go(1.89 KB)
📄 vdso_in_none.go(490 B)
📄 vdso_linux.go(7.77 KB)
📄 vdso_linux_386.go(669 B)
📄 vdso_linux_amd64.go(685 B)
📄 vdso_linux_arm.go(669 B)
📄 vdso_linux_arm64.go(670 B)
📄 vdso_linux_mips64x.go(892 B)
📄 vdso_linux_ppc64x.go(712 B)
📄 vlop_386.s(2.02 KB)
📄 vlop_arm.s(7.06 KB)
📄 vlop_arm_test.go(3.75 KB)
📄 vlrt.go(5.91 KB)
📄 wincallback.go(3.52 KB)
📄 write_err.go(310 B)
📄 write_err_android.go(4.65 KB)
📄 zcallback_windows.go(155 B)
📄 zcallback_windows.s(63.05 KB)
📄 zcallback_windows_arm.s(89.34 KB)
📄 zcallback_windows_arm64.s(89.34 KB)

Editing: proc_test.go

// Copyright 2011 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_test

import (
	"fmt"
	"internal/race"
	"internal/testenv"
	"math"
	"net"
	"runtime"
	"runtime/debug"
	"strings"
	"sync"
	"sync/atomic"
	"syscall"
	"testing"
	"time"
)

var stop = make(chan bool, 1)

func perpetuumMobile() {
	select {
	case <-stop:
	default:
		go perpetuumMobile()
	}
}

func TestStopTheWorldDeadlock(t *testing.T) {
	if runtime.GOARCH == "wasm" {
		t.Skip("no preemption on wasm yet")
	}
	if testing.Short() {
		t.Skip("skipping during short test")
	}
	maxprocs := runtime.GOMAXPROCS(3)
	compl := make(chan bool, 2)
	go func() {
		for i := 0; i != 1000; i += 1 {
			runtime.GC()
		}
		compl <- true
	}()
	go func() {
		for i := 0; i != 1000; i += 1 {
			runtime.GOMAXPROCS(3)
		}
		compl <- true
	}()
	go perpetuumMobile()
	<-compl
	<-compl
	stop <- true
	runtime.GOMAXPROCS(maxprocs)
}

func TestYieldProgress(t *testing.T) {
	testYieldProgress(false)
}

func TestYieldLockedProgress(t *testing.T) {
	testYieldProgress(true)
}

func testYieldProgress(locked bool) {
	c := make(chan bool)
	cack := make(chan bool)
	go func() {
		if locked {
			runtime.LockOSThread()
		}
		for {
			select {
			case <-c:
				cack <- true
				return
			default:
				runtime.Gosched()
			}
		}
	}()
	time.Sleep(10 * time.Millisecond)
	c <- true
	<-cack
}

func TestYieldLocked(t *testing.T) {
	const N = 10
	c := make(chan bool)
	go func() {
		runtime.LockOSThread()
		for i := 0; i < N; i++ {
			runtime.Gosched()
			time.Sleep(time.Millisecond)
		}
		c <- true
		// runtime.UnlockOSThread() is deliberately omitted
	}()
	<-c
}

func TestGoroutineParallelism(t *testing.T) {
	if runtime.NumCPU() == 1 {
		// Takes too long, too easy to deadlock, etc.
		t.Skip("skipping on uniprocessor")
	}
	P := 4
	N := 10
	if testing.Short() {
		P = 3
		N = 3
	}
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P))
	// If runtime triggers a forced GC during this test then it will deadlock,
	// since the goroutines can't be stopped/preempted.
	// Disable GC for this test (see issue #10958).
	defer debug.SetGCPercent(debug.SetGCPercent(-1))
	for try := 0; try < N; try++ {
		done := make(chan bool)
		x := uint32(0)
		for p := 0; p < P; p++ {
			// Test that all P goroutines are scheduled at the same time
			go func(p int) {
				for i := 0; i < 3; i++ {
					expected := uint32(P*i + p)
					for atomic.LoadUint32(&x) != expected {
					}
					atomic.StoreUint32(&x, expected+1)
				}
				done <- true
			}(p)
		}
		for p := 0; p < P; p++ {
			<-done
		}
	}
}

// Test that all runnable goroutines are scheduled at the same time.
func TestGoroutineParallelism2(t *testing.T) {
	//testGoroutineParallelism2(t, false, false)
	testGoroutineParallelism2(t, true, false)
	testGoroutineParallelism2(t, false, true)
	testGoroutineParallelism2(t, true, true)
}

func testGoroutineParallelism2(t *testing.T, load, netpoll bool) {
	if runtime.NumCPU() == 1 {
		// Takes too long, too easy to deadlock, etc.
		t.Skip("skipping on uniprocessor")
	}
	P := 4
	N := 10
	if testing.Short() {
		N = 3
	}
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P))
	// If runtime triggers a forced GC during this test then it will deadlock,
	// since the goroutines can't be stopped/preempted.
	// Disable GC for this test (see issue #10958).
	defer debug.SetGCPercent(debug.SetGCPercent(-1))
	for try := 0; try < N; try++ {
		if load {
			// Create P goroutines and wait until they all run.
			// When we run the actual test below, worker threads
			// running the goroutines will start parking.
			done := make(chan bool)
			x := uint32(0)
			for p := 0; p < P; p++ {
				go func() {
					if atomic.AddUint32(&x, 1) == uint32(P) {
						done <- true
						return
					}
					for atomic.LoadUint32(&x) != uint32(P) {
					}
				}()
			}
			<-done
		}
		if netpoll {
			// Enable netpoller, affects schedler behavior.
			laddr := "localhost:0"
			if runtime.GOOS == "android" {
				// On some Android devices, there are no records for localhost,
				// see https://golang.org/issues/14486.
				// Don't use 127.0.0.1 for every case, it won't work on IPv6-only systems.
				laddr = "127.0.0.1:0"
			}
			ln, err := net.Listen("tcp", laddr)
			if err != nil {
				defer ln.Close() // yup, defer in a loop
			}
		}
		done := make(chan bool)
		x := uint32(0)
		// Spawn P goroutines in a nested fashion just to differ from TestGoroutineParallelism.
		for p := 0; p < P/2; p++ {
			go func(p int) {
				for p2 := 0; p2 < 2; p2++ {
					go func(p2 int) {
						for i := 0; i < 3; i++ {
							expected := uint32(P*i + p*2 + p2)
							for atomic.LoadUint32(&x) != expected {
							}
							atomic.StoreUint32(&x, expected+1)
						}
						done <- true
					}(p2)
				}
			}(p)
		}
		for p := 0; p < P; p++ {
			<-done
		}
	}
}

func TestBlockLocked(t *testing.T) {
	const N = 10
	c := make(chan bool)
	go func() {
		runtime.LockOSThread()
		for i := 0; i < N; i++ {
			c <- true
		}
		runtime.UnlockOSThread()
	}()
	for i := 0; i < N; i++ {
		<-c
	}
}

func TestTimerFairness(t *testing.T) {
	if runtime.GOARCH == "wasm" {
		t.Skip("no preemption on wasm yet")
	}

done := make(chan bool)
	c := make(chan bool)
	for i := 0; i < 2; i++ {
		go func() {
			for {
				select {
				case c <- true:
				case <-done:
					return
				}
			}
		}()
	}

timer := time.After(20 * time.Millisecond)
	for {
		select {
		case <-c:
		case <-timer:
			close(done)
			return
		}
	}
}

func TestTimerFairness2(t *testing.T) {
	if runtime.GOARCH == "wasm" {
		t.Skip("no preemption on wasm yet")
	}

done := make(chan bool)
	c := make(chan bool)
	for i := 0; i < 2; i++ {
		go func() {
			timer := time.After(20 * time.Millisecond)
			var buf [1]byte
			for {
				syscall.Read(0, buf[0:0])
				select {
				case c <- true:
				case <-c:
				case <-timer:
					done <- true
					return
				}
			}
		}()
	}
	<-done
	<-done
}

// The function is used to test preemption at split stack checks.
// Declaring a var avoids inlining at the call site.
var preempt = func() int {
	var a [128]int
	sum := 0
	for _, v := range a {
		sum += v
	}
	return sum
}

func TestPreemption(t *testing.T) {
	if runtime.GOARCH == "wasm" {
		t.Skip("no preemption on wasm yet")
	}

// Test that goroutines are preempted at function calls.
	N := 5
	if testing.Short() {
		N = 2
	}
	c := make(chan bool)
	var x uint32
	for g := 0; g < 2; g++ {
		go func(g int) {
			for i := 0; i < N; i++ {
				for atomic.LoadUint32(&x) != uint32(g) {
					preempt()
				}
				atomic.StoreUint32(&x, uint32(1-g))
			}
			c <- true
		}(g)
	}
	<-c
	<-c
}

func TestPreemptionGC(t *testing.T) {
	if runtime.GOARCH == "wasm" {
		t.Skip("no preemption on wasm yet")
	}

// Test that pending GC preempts running goroutines.
	P := 5
	N := 10
	if testing.Short() {
		P = 3
		N = 2
	}
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P + 1))
	var stop uint32
	for i := 0; i < P; i++ {
		go func() {
			for atomic.LoadUint32(&stop) == 0 {
				preempt()
			}
		}()
	}
	for i := 0; i < N; i++ {
		runtime.Gosched()
		runtime.GC()
	}
	atomic.StoreUint32(&stop, 1)
}

func TestAsyncPreempt(t *testing.T) {
	if !runtime.PreemptMSupported {
		t.Skip("asynchronous preemption not supported on this platform")
	}
	output := runTestProg(t, "testprog", "AsyncPreempt")
	want := "OK\n"
	if output != want {
		t.Fatalf("want %s, got %s\n", want, output)
	}
}

func TestGCFairness(t *testing.T) {
	output := runTestProg(t, "testprog", "GCFairness")
	want := "OK\n"
	if output != want {
		t.Fatalf("want %s, got %s\n", want, output)
	}
}

func TestGCFairness2(t *testing.T) {
	output := runTestProg(t, "testprog", "GCFairness2")
	want := "OK\n"
	if output != want {
		t.Fatalf("want %s, got %s\n", want, output)
	}
}

func TestNumGoroutine(t *testing.T) {
	output := runTestProg(t, "testprog", "NumGoroutine")
	want := "1\n"
	if output != want {
		t.Fatalf("want %q, got %q", want, output)
	}

buf := make([]byte, 1<<20)

// Try up to 10 times for a match before giving up.
	// This is a fundamentally racy check but it's important
	// to notice if NumGoroutine and Stack are _always_ out of sync.
	for i := 0; ; i++ {
		// Give goroutines about to exit a chance to exit.
		// The NumGoroutine and Stack below need to see
		// the same state of the world, so anything we can do
		// to keep it quiet is good.
		runtime.Gosched()

n := runtime.NumGoroutine()
		buf = buf[:runtime.Stack(buf, true)]

nstk := strings.Count(string(buf), "goroutine ")
		if n == nstk {
			break
		}
		if i >= 10 {
			t.Fatalf("NumGoroutine=%d, but found %d goroutines in stack dump: %s", n, nstk, buf)
		}
	}
}

func TestPingPongHog(t *testing.T) {
	if runtime.GOARCH == "wasm" {
		t.Skip("no preemption on wasm yet")
	}
	if testing.Short() {
		t.Skip("skipping in -short mode")
	}
	if race.Enabled {
		// The race detector randomizes the scheduler,
		// which causes this test to fail (#38266).
		t.Skip("skipping in -race mode")
	}

defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
	done := make(chan bool)
	hogChan, lightChan := make(chan bool), make(chan bool)
	hogCount, lightCount := 0, 0

run := func(limit int, counter *int, wake chan bool) {
		for {
			select {
			case <-done:
				return

case <-wake:
				for i := 0; i < limit; i++ {
					*counter++
				}
				wake <- true
			}
		}
	}

// Start two co-scheduled hog goroutines.
	for i := 0; i < 2; i++ {
		go run(1e6, &hogCount, hogChan)
	}

// Start two co-scheduled light goroutines.
	for i := 0; i < 2; i++ {
		go run(1e3, &lightCount, lightChan)
	}

// Start goroutine pairs and wait for a few preemption rounds.
	hogChan <- true
	lightChan <- true
	time.Sleep(100 * time.Millisecond)
	close(done)
	<-hogChan
	<-lightChan

// Check that hogCount and lightCount are within a factor of
	// 5, which indicates that both pairs of goroutines handed off
	// the P within a time-slice to their buddy. We can use a
	// fairly large factor here to make this robust: if the
	// scheduler isn't working right, the gap should be ~1000X.
	const factor = 5
	if hogCount > lightCount*factor || lightCount > hogCount*factor {
		t.Fatalf("want hogCount/lightCount in [%v, %v]; got %d/%d = %g", 1.0/factor, factor, hogCount, lightCount, float64(hogCount)/float64(lightCount))
	}
}

func BenchmarkPingPongHog(b *testing.B) {
	if b.N == 0 {
		return
	}
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))

// Create a CPU hog
	stop, done := make(chan bool), make(chan bool)
	go func() {
		for {
			select {
			case <-stop:
				done <- true
				return
			default:
			}
		}
	}()

// Ping-pong b.N times
	ping, pong := make(chan bool), make(chan bool)
	go func() {
		for j := 0; j < b.N; j++ {
			pong <- <-ping
		}
		close(stop)
		done <- true
	}()
	go func() {
		for i := 0; i < b.N; i++ {
			ping <- <-pong
		}
		done <- true
	}()
	b.ResetTimer()
	ping <- true // Start ping-pong
	<-stop
	b.StopTimer()
	<-ping // Let last ponger exit
	<-done // Make sure goroutines exit
	<-done
	<-done
}

var padData [128]uint64

func stackGrowthRecursive(i int) {
	var pad [128]uint64
	pad = padData
	for j := range pad {
		if pad[j] != 0 {
			return
		}
	}
	if i != 0 {
		stackGrowthRecursive(i - 1)
	}
}

func TestPreemptSplitBig(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping in -short mode")
	}
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
	stop := make(chan int)
	go big(stop)
	for i := 0; i < 3; i++ {
		time.Sleep(10 * time.Microsecond) // let big start running
		runtime.GC()
	}
	close(stop)
}

func big(stop chan int) int {
	n := 0
	for {
		// delay so that gc is sure to have asked for a preemption
		for i := 0; i < 1e9; i++ {
			n++
		}

// call bigframe, which used to miss the preemption in its prologue.
		bigframe(stop)

// check if we've been asked to stop.
		select {
		case <-stop:
			return n
		}
	}
}

func bigframe(stop chan int) int {
	// not splitting the stack will overflow.
	// small will notice that it needs a stack split and will
	// catch the overflow.
	var x [8192]byte
	return small(stop, &x)
}

func small(stop chan int, x *[8192]byte) int {
	for i := range x {
		x[i] = byte(i)
	}
	sum := 0
	for i := range x {
		sum += int(x[i])
	}

// keep small from being a leaf function, which might
	// make it not do any stack check at all.
	nonleaf(stop)

return sum
}

func nonleaf(stop chan int) bool {
	// do something that won't be inlined:
	select {
	case <-stop:
		return true
	default:
		return false
	}
}

func TestSchedLocalQueue(t *testing.T) {
	runtime.RunSchedLocalQueueTest()
}

func TestSchedLocalQueueSteal(t *testing.T) {
	runtime.RunSchedLocalQueueStealTest()
}

func TestSchedLocalQueueEmpty(t *testing.T) {
	if runtime.NumCPU() == 1 {
		// Takes too long and does not trigger the race.
		t.Skip("skipping on uniprocessor")
	}
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))

// If runtime triggers a forced GC during this test then it will deadlock,
	// since the goroutines can't be stopped/preempted during spin wait.
	defer debug.SetGCPercent(debug.SetGCPercent(-1))

iters := int(1e5)
	if testing.Short() {
		iters = 1e2
	}
	runtime.RunSchedLocalQueueEmptyTest(iters)
}

func benchmarkStackGrowth(b *testing.B, rec int) {
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			stackGrowthRecursive(rec)
		}
	})
}

func BenchmarkStackGrowth(b *testing.B) {
	benchmarkStackGrowth(b, 10)
}

func BenchmarkStackGrowthDeep(b *testing.B) {
	benchmarkStackGrowth(b, 1024)
}

func BenchmarkCreateGoroutines(b *testing.B) {
	benchmarkCreateGoroutines(b, 1)
}

func BenchmarkCreateGoroutinesParallel(b *testing.B) {
	benchmarkCreateGoroutines(b, runtime.GOMAXPROCS(-1))
}

func benchmarkCreateGoroutines(b *testing.B, procs int) {
	c := make(chan bool)
	var f func(n int)
	f = func(n int) {
		if n == 0 {
			c <- true
			return
		}
		go f(n - 1)
	}
	for i := 0; i < procs; i++ {
		go f(b.N / procs)
	}
	for i := 0; i < procs; i++ {
		<-c
	}
}

func BenchmarkCreateGoroutinesCapture(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		const N = 4
		var wg sync.WaitGroup
		wg.Add(N)
		for i := 0; i < N; i++ {
			i := i
			go func() {
				if i >= N {
					b.Logf("bad") // just to capture b
				}
				wg.Done()
			}()
		}
		wg.Wait()
	}
}

// warmupScheduler ensures the scheduler has at least targetThreadCount threads
// in its thread pool.
func warmupScheduler(targetThreadCount int) {
	var wg sync.WaitGroup
	var count int32
	for i := 0; i < targetThreadCount; i++ {
		wg.Add(1)
		go func() {
			atomic.AddInt32(&count, 1)
			for atomic.LoadInt32(&count) < int32(targetThreadCount) {
				// spin until all threads started
			}

// spin a bit more to ensure they are all running on separate CPUs.
			doWork(time.Millisecond)
			wg.Done()
		}()
	}
	wg.Wait()
}

func doWork(dur time.Duration) {
	start := time.Now()
	for time.Since(start) < dur {
	}
}

// BenchmarkCreateGoroutinesSingle creates many goroutines, all from a single
// producer (the main benchmark goroutine).
//
// Compared to BenchmarkCreateGoroutines, this causes different behavior in the
// scheduler because Ms are much more likely to need to steal work from the
// main P rather than having work in the local run queue.
func BenchmarkCreateGoroutinesSingle(b *testing.B) {
	// Since we are interested in stealing behavior, warm the scheduler to
	// get all the Ps running first.
	warmupScheduler(runtime.GOMAXPROCS(0))
	b.ResetTimer()

var wg sync.WaitGroup
	wg.Add(b.N)
	for i := 0; i < b.N; i++ {
		go func() {
			wg.Done()
		}()
	}
	wg.Wait()
}

func BenchmarkClosureCall(b *testing.B) {
	sum := 0
	off1 := 1
	for i := 0; i < b.N; i++ {
		off2 := 2
		func() {
			sum += i + off1 + off2
		}()
	}
	_ = sum
}

func benchmarkWakeupParallel(b *testing.B, spin func(time.Duration)) {
	if runtime.GOMAXPROCS(0) == 1 {
		b.Skip("skipping: GOMAXPROCS=1")
	}

wakeDelay := 5 * time.Microsecond
	for _, delay := range []time.Duration{
		0,
		1 * time.Microsecond,
		2 * time.Microsecond,
		5 * time.Microsecond,
		10 * time.Microsecond,
		20 * time.Microsecond,
		50 * time.Microsecond,
		100 * time.Microsecond,
	} {
		b.Run(delay.String(), func(b *testing.B) {
			if b.N == 0 {
				return
			}
			// Start two goroutines, which alternate between being
			// sender and receiver in the following protocol:
			//
			// - The receiver spins for `delay` and then does a
			// blocking receive on a channel.
			//
			// - The sender spins for `delay+wakeDelay` and then
			// sends to the same channel. (The addition of
			// `wakeDelay` improves the probability that the
			// receiver will be blocking when the send occurs when
			// the goroutines execute in parallel.)
			//
			// In each iteration of the benchmark, each goroutine
			// acts once as sender and once as receiver, so each
			// goroutine spins for delay twice.
			//
			// BenchmarkWakeupParallel is used to estimate how
			// efficiently the scheduler parallelizes goroutines in
			// the presence of blocking:
			//
			// - If both goroutines are executed on the same core,
			// an increase in delay by N will increase the time per
			// iteration by 4*N, because all 4 delays are
			// serialized.
			//
			// - Otherwise, an increase in delay by N will increase
			// the time per iteration by 2*N, and the time per
			// iteration is 2 * (runtime overhead + chan
			// send/receive pair + delay + wakeDelay). This allows
			// the runtime overhead, including the time it takes
			// for the unblocked goroutine to be scheduled, to be
			// estimated.
			ping, pong := make(chan struct{}), make(chan struct{})
			start := make(chan struct{})
			done := make(chan struct{})
			go func() {
				<-start
				for i := 0; i < b.N; i++ {
					// sender
					spin(delay + wakeDelay)
					ping <- struct{}{}
					// receiver
					spin(delay)
					<-pong
				}
				done <- struct{}{}
			}()
			go func() {
				for i := 0; i < b.N; i++ {
					// receiver
					spin(delay)
					<-ping
					// sender
					spin(delay + wakeDelay)
					pong <- struct{}{}
				}
				done <- struct{}{}
			}()
			b.ResetTimer()
			start <- struct{}{}
			<-done
			<-done
		})
	}
}

func BenchmarkWakeupParallelSpinning(b *testing.B) {
	benchmarkWakeupParallel(b, func(d time.Duration) {
		end := time.Now().Add(d)
		for time.Now().Before(end) {
			// do nothing
		}
	})
}

// sysNanosleep is defined by OS-specific files (such as runtime_linux_test.go)
// to sleep for the given duration. If nil, dependent tests are skipped.
// The implementation should invoke a blocking system call and not
// call time.Sleep, which would deschedule the goroutine.
var sysNanosleep func(d time.Duration)

func BenchmarkWakeupParallelSyscall(b *testing.B) {
	if sysNanosleep == nil {
		b.Skipf("skipping on %v; sysNanosleep not defined", runtime.GOOS)
	}
	benchmarkWakeupParallel(b, func(d time.Duration) {
		sysNanosleep(d)
	})
}

type Matrix [][]float64

func BenchmarkMatmult(b *testing.B) {
	b.StopTimer()
	// matmult is O(N**3) but testing expects O(b.N),
	// so we need to take cube root of b.N
	n := int(math.Cbrt(float64(b.N))) + 1
	A := makeMatrix(n)
	B := makeMatrix(n)
	C := makeMatrix(n)
	b.StartTimer()
	matmult(nil, A, B, C, 0, n, 0, n, 0, n, 8)
}

func makeMatrix(n int) Matrix {
	m := make(Matrix, n)
	for i := 0; i < n; i++ {
		m[i] = make([]float64, n)
		for j := 0; j < n; j++ {
			m[i][j] = float64(i*n + j)
		}
	}
	return m
}

func matmult(done chan<- struct{}, A, B, C Matrix, i0, i1, j0, j1, k0, k1, threshold int) {
	di := i1 - i0
	dj := j1 - j0
	dk := k1 - k0
	if di >= dj && di >= dk && di >= threshold {
		// divide in two by y axis
		mi := i0 + di/2
		done1 := make(chan struct{}, 1)
		go matmult(done1, A, B, C, i0, mi, j0, j1, k0, k1, threshold)
		matmult(nil, A, B, C, mi, i1, j0, j1, k0, k1, threshold)
		<-done1
	} else if dj >= dk && dj >= threshold {
		// divide in two by x axis
		mj := j0 + dj/2
		done1 := make(chan struct{}, 1)
		go matmult(done1, A, B, C, i0, i1, j0, mj, k0, k1, threshold)
		matmult(nil, A, B, C, i0, i1, mj, j1, k0, k1, threshold)
		<-done1
	} else if dk >= threshold {
		// divide in two by "k" axis
		// deliberately not parallel because of data races
		mk := k0 + dk/2
		matmult(nil, A, B, C, i0, i1, j0, j1, k0, mk, threshold)
		matmult(nil, A, B, C, i0, i1, j0, j1, mk, k1, threshold)
	} else {
		// the matrices are small enough, compute directly
		for i := i0; i < i1; i++ {
			for j := j0; j < j1; j++ {
				for k := k0; k < k1; k++ {
					C[i][j] += A[i][k] * B[k][j]
				}
			}
		}
	}
	if done != nil {
		done <- struct{}{}
	}
}

func TestStealOrder(t *testing.T) {
	runtime.RunStealOrderTest()
}

func TestLockOSThreadNesting(t *testing.T) {
	if runtime.GOARCH == "wasm" {
		t.Skip("no threads on wasm yet")
	}

go func() {
		e, i := runtime.LockOSCounts()
		if e != 0 || i != 0 {
			t.Errorf("want locked counts 0, 0; got %d, %d", e, i)
			return
		}
		runtime.LockOSThread()
		runtime.LockOSThread()
		runtime.UnlockOSThread()
		e, i = runtime.LockOSCounts()
		if e != 1 || i != 0 {
			t.Errorf("want locked counts 1, 0; got %d, %d", e, i)
			return
		}
		runtime.UnlockOSThread()
		e, i = runtime.LockOSCounts()
		if e != 0 || i != 0 {
			t.Errorf("want locked counts 0, 0; got %d, %d", e, i)
			return
		}
	}()
}

func TestLockOSThreadExit(t *testing.T) {
	testLockOSThreadExit(t, "testprog")
}

func testLockOSThreadExit(t *testing.T, prog string) {
	output := runTestProg(t, prog, "LockOSThreadMain", "GOMAXPROCS=1")
	want := "OK\n"
	if output != want {
		t.Errorf("want %q, got %q", want, output)
	}

output = runTestProg(t, prog, "LockOSThreadAlt")
	if output != want {
		t.Errorf("want %q, got %q", want, output)
	}
}

func TestLockOSThreadAvoidsStatePropagation(t *testing.T) {
	want := "OK\n"
	skip := "unshare not permitted\n"
	output := runTestProg(t, "testprog", "LockOSThreadAvoidsStatePropagation", "GOMAXPROCS=1")
	if output == skip {
		t.Skip("unshare syscall not permitted on this system")
	} else if output != want {
		t.Errorf("want %q, got %q", want, output)
	}
}

func TestLockOSThreadTemplateThreadRace(t *testing.T) {
	testenv.MustHaveGoRun(t)

exe, err := buildTestProg(t, "testprog")
	if err != nil {
		t.Fatal(err)
	}

iterations := 100
	if testing.Short() {
		// Reduce run time to ~100ms, with much lower probability of
		// catching issues.
		iterations = 5
	}
	for i := 0; i < iterations; i++ {
		want := "OK\n"
		output := runBuiltTestProg(t, exe, "LockOSThreadTemplateThreadRace")
		if output != want {
			t.Fatalf("run %d: want %q, got %q", i, want, output)
		}
	}
}

// fakeSyscall emulates a system call.
//go:nosplit
func fakeSyscall(duration time.Duration) {
	runtime.Entersyscall()
	for start := runtime.Nanotime(); runtime.Nanotime()-start < int64(duration); {
	}
	runtime.Exitsyscall()
}

// Check that a goroutine will be preempted if it is calling short system calls.
func testPreemptionAfterSyscall(t *testing.T, syscallDuration time.Duration) {
	if runtime.GOARCH == "wasm" {
		t.Skip("no preemption on wasm yet")
	}

defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))

interations := 10
	if testing.Short() {
		interations = 1
	}
	const (
		maxDuration = 3 * time.Second
		nroutines   = 8
	)

for i := 0; i < interations; i++ {
		c := make(chan bool, nroutines)
		stop := uint32(0)

start := time.Now()
		for g := 0; g < nroutines; g++ {
			go func(stop *uint32) {
				c <- true
				for atomic.LoadUint32(stop) == 0 {
					fakeSyscall(syscallDuration)
				}
				c <- true
			}(&stop)
		}
		// wait until all goroutines have started.
		for g := 0; g < nroutines; g++ {
			<-c
		}
		atomic.StoreUint32(&stop, 1)
		// wait until all goroutines have finished.
		for g := 0; g < nroutines; g++ {
			<-c
		}
		duration := time.Since(start)

if duration > maxDuration {
			t.Errorf("timeout exceeded: %v (%v)", duration, maxDuration)
		}
	}
}

func TestPreemptionAfterSyscall(t *testing.T) {
	for _, i := range []time.Duration{10, 100, 1000} {
		d := i * time.Microsecond
		t.Run(fmt.Sprint(d), func(t *testing.T) {
			testPreemptionAfterSyscall(t, d)
		})
	}
}

func TestGetgThreadSwitch(t *testing.T) {
	runtime.RunGetgThreadSwitchTest()
}

// TestNetpollBreak tests that netpollBreak can break a netpoll.
// This test is not particularly safe since the call to netpoll
// will pick up any stray files that are ready, but it should work
// OK as long it is not run in parallel.
func TestNetpollBreak(t *testing.T) {
	if runtime.GOMAXPROCS(0) == 1 {
		t.Skip("skipping: GOMAXPROCS=1")
	}

// Make sure that netpoll is initialized.
	runtime.NetpollGenericInit()

start := time.Now()
	c := make(chan bool, 2)
	go func() {
		c <- true
		runtime.Netpoll(10 * time.Second.Nanoseconds())
		c <- true
	}()
	<-c
	// Loop because the break might get eaten by the scheduler.
	// Break twice to break both the netpoll we started and the
	// scheduler netpoll.
loop:
	for {
		runtime.Usleep(100)
		runtime.NetpollBreak()
		runtime.NetpollBreak()
		select {
		case <-c:
			break loop
		default:
		}
	}
	if dur := time.Since(start); dur > 5*time.Second {
		t.Errorf("netpollBreak did not interrupt netpoll: slept for: %v", dur)
	}
}

// TestBigGOMAXPROCS tests that setting GOMAXPROCS to a large value
// doesn't cause a crash at startup. See issue 38474.
func TestBigGOMAXPROCS(t *testing.T) {
	t.Parallel()
	output := runTestProg(t, "testprog", "NonexistentTest", "GOMAXPROCS=1024")
	// Ignore error conditions on small machines.
	for _, errstr := range []string{
		"failed to create new OS thread",
		"cannot allocate memory",
	} {
		if strings.Contains(output, errstr) {
			t.Skipf("failed to create 1024 threads")
		}
	}
	if !strings.Contains(output, "unknown function: NonexistentTest") {
		t.Errorf("output:\n%s\nwanted:\nunknown function: NonexistentTest", output)
	}
}

X7ROOT File Manager

Editing: proc_test.go

Upload File

Create Folder