Go runtime 调度器精讲（一）：Go 程序初始化

于 2024-09-11 11:53:54 发布
阅读量115 收藏
点赞数
文章标签： golang java 前端 服务器 数据库

原创文章，欢迎转载，转载请注明出处，谢谢。

0. 前言

本系列将介绍 Go runtime 调度器。要学好 Go 语言，runtime 运行时是绕不过去的，它相当于一层“操作系统”对我们的程序做“各种类型”的处理。其中，调度器作为运行时的核心，是必须要了解的内容。本系列会结合 Go plan9 汇编，深入到 runtime 调度器的源码层面去看程序运行时，goroutine 协程创建等各种场景下 runtime 调度器是如何工作的。

本系列会运用到 Go plan9 汇编相关的知识，不熟悉的同学可先看看 这里 了解下。

1. Go 程序初始化

首先，从一个经典的 Hello World 程序入手，查看程序的启动，以及启动该程序时调度器做了什么。

package main

func main() {
	println("Hello World")
}

1.1 准备

程序启动经过编译和链接两个阶段，我们可以通过 go build -x hello.go 查看构建程序的过程：

# go build -x hello.go 
...
// compile 编译 hello.go
/usr/local/go/pkg/tool/linux_amd64/compile -o $WORK/b001/_pkg_.a -trimpath "$WORK/b001=>" -p main -complete -buildid uHBjeIlqt1oQO9TLC5SE/uHBjeIlqt1oQO9TLC5SE -goversion go1.21.0 -c=3 -nolocalimports -importcfg $WORK/b001/importcfg -pack ./hello.go
...
// link 链接库文件生成可执行文件
/usr/local/go/pkg/tool/linux_amd64/link -o $WORK/b001/exe/a.out -importcfg $WORK/b001/importcfg.link -buildmode=exe -buildid=27kmwBgRtsWy6cL5ofDV/uHBjeIlqt1oQO9TLC5SE/Ye3W7EEwzML-FanTsWbe/27kmwBgRtsWy6cL5ofDV -extld=gcc $WORK/b001/_pkg_.a

这里省略了不相关的输出，经过编译，链接过程之后得到可执行文件 hello：

# ls
go.mod  hello  hello.go
# ./hello 
Hello World

1.2 进入程序

上一节生成了可执行程序 hello。接下来进入本文的主题，通过 dlv 进入 hello 程序，查看在执行 Go 程序时，运行时做了什么。

我们可以通过 readelf 查看可执行程序的入口：

# readelf -h ./hello
ELF Header:
  ...
  Entry point address:               0x455e40

省略了不相关的信息，重点看 Entry point address，它是进入 hello 程序的入口点。通过 dlv 进入该入口点：

# dlv exec ./hello
Type 'help' for list of commands.
(dlv) b *0x455e40
Breakpoint 1 set at 0x455e40 for _rt0_amd64_linux() /usr/local/go/src/runtime/rt0_linux_amd64.s:8

可以看到入口点指向的是 /go/src/runtime/rt0_linux_amd64.s 中的 _rt0_amd64_linux() 函数。

接下来，进入该函数查看启动 Go 程序时，运行时做了什么。

// c 命令执行到入口点位置
(dlv) c
> _rt0_amd64_linux() /usr/local/go/src/runtime/rt0_linux_amd64.s:8 (hits total:1) (PC: 0x455e40)
Warning: debugging optimized function
     3: // license that can be found in the LICENSE file.
     4:
     5: #include "textflag.h"
     6:
     7: TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
=>   8:         JMP     _rt0_amd64(SB)      // 跳转到 _rt0_amd64

// si 单步执行指令
(dlv) si
> _rt0_amd64() /usr/local/go/src/runtime/asm_amd64.s:16 (PC: 0x454200)
Warning: debugging optimized function
TEXT _rt0_amd64(SB) /usr/local/go/src/runtime/asm_amd64.s
=>      asm_amd64.s:16  0x454200        488b3c24        mov rdi, qword ptr [rsp]
        asm_amd64.s:17  0x454204        488d742408      lea rsi, ptr [rsp+0x8]
        asm_amd64.s:18  0x454209        e912000000      jmp $runtime.rt0_go     // 这里跳转到 runtime 的 rt0_go

// 进入 rt0_go
(dlv) si
> runtime.rt0_go() /usr/local/go/src/runtime/asm_amd64.s:161 (PC: 0x454220)
Warning: debugging optimized function
TEXT runtime.rt0_go(SB) /usr/local/go/src/runtime/asm_amd64.s
=>      asm_amd64.s:161 0x454220        4889f8          mov rax, rdi
        asm_amd64.s:162 0x454223        4889f3          mov rbx, rsi
        asm_amd64.s:163 0x454226        4883ec28        sub rsp, 0x28
        asm_amd64.s:164 0x45422a        4883e4f0        and rsp, -0x10
        asm_amd64.s:165 0x45422e        4889442418      mov qword ptr [rsp+0x18], rax
        asm_amd64.s:166 0x454233        48895c2420      mov qword ptr [rsp+0x20], rbx

rt0_go 是 runtime 执行 Go 程序的入口。

需要补充说明的是：我们使用的 si 显示的是 CPU 单步执行的指令，是 CPU 真正执行的指令。而 Go plan9 汇编是“优化”了的汇编指令，所以会发现 si 显示的输出和 asm_amd64.s 中定义的不一样。在实际分析的时候可以结合两者一起分析。

结合着 asm_amd64.s/rt0_go 分析 si 输出的 CPU 指令：

=>      asm_amd64.s:161 0x454220        4889f8          mov rax, rdi                    // 将 rdi 寄存器中的 argc 移到 rax 寄存器：rax = argc
        asm_amd64.s:162 0x454223        4889f3          mov rbx, rsi                    // 将 rsi 寄存器中的 argv 移到 rbx 寄存器：rbx = argv
        asm_amd64.s:163 0x454226        4883ec28        sub rsp, 0x28                   // 开辟栈空间
        asm_amd64.s:164 0x45422a        4883e4f0        and rsp, -0x10                  // 对齐栈空间为 16 字节的整数倍（因为 CPU 的一组 SSE 指令需要内存地址必须是 16 字节的倍数）
        asm_amd64.s:165 0x45422e        4889442418      mov qword ptr [rsp+0x18], rax   // 将 argc 移到栈空间 [rsp+0x18]
        asm_amd64.s:166 0x454233        48895c2420      mov qword ptr [rsp+0x20], rbx   // 将 argv 移到栈空间 [rsp+0x20]

画出栈空间如下图：

image

继续分析:

(dlv) si
> runtime.rt0_go() /usr/local/go/src/runtime/asm_amd64.s:170 (PC: 0x454238)
Warning: debugging optimized function
        asm_amd64.s:166 0x454233        48895c2420              mov qword ptr [rsp+0x20], rbx
=>      asm_amd64.s:170 0x454238        488d3d815b0700          lea rdi, ptr [runtime.g0]           // 将 runtime.g0 的地址移到 rdi 寄存器中，rdi = &g0
        asm_amd64.s:171 0x45423f        488d9c240000ffff        lea rbx, ptr [rsp+0xffff0000]       // 将 [rsp+0xffff0000] 地址的值移到 rbx 中，后面会讲
        asm_amd64.s:172 0x454247        48895f10                mov qword ptr [rdi+0x10], rbx       // 将 rbx 中的地址，移到 [rdi+0x10]，实际是移到 g0.stackguard0
        asm_amd64.s:173 0x45424b        48895f18                mov qword ptr [rdi+0x18], rbx       // 将 rbx 中的地址，移到 [rdi+0x18]，实际是移到 g0.stackguard1
        asm_amd64.s:174 0x45424f        48891f                  mov qword ptr [rdi], rbx            // 将 rbx 中的地址，移到 [rdi]，实际是移到 g0.stack.lo
        asm_amd64.s:175 0x454252        48896708                mov qword ptr [rdi+0x8], rsp        // 将 rsp 中的地址，移到 [rdi+0x8]，实际是移到 g0.stack.hi

指令中 runtime.g0 为运行时主线程提供运行的执行环境，它并不是执行用户代码的 goroutine。

使用 regs 查看寄存器 rbx 存储的是什么：

(dlv) regs
    Rip = 0x000000000045423f
    Rsp = 0x00007ffec8d155f0
    Rbx = 0x00007ffec8d15628

(dlv) si
> runtime.rt0_go() /usr/local/go/src/runtime/asm_amd64.s:172 (PC: 0x454247)
Warning: debugging optimized function
        asm_amd64.s:171 0x45423f        488d9c240000ffff        lea rbx, ptr [rsp+0xffff0000]
=>      asm_amd64.s:172 0x454247        48895f10                mov qword ptr [rdi+0x10], rbx

(dlv) regs
    Rip = 0x0000000000454247
    Rsp = 0x00007ffec8d155f0
    Rbx = 0x00007ffec8d055f0

可以看到，这段指令实际指向的是一段栈空间，rsp:0x00007ffec8d155f0 指向的是栈底，rbx:0x00007ffec8d055f0 指向的是栈顶，它们的内存空间是 64KB。

根据上述分析，画出栈空间布局如下图：

image

继续往下分析，省略一些不相关的汇编代码。直接从 asm_amd64.s/runtime·rt0_go:258 开始看：

258	    LEAQ	runtime·m0+m_tls(SB), DI
259	    CALL	runtime·settls(SB)
260
261	    // store through it, to make sure it works
262	    get_tls(BX)
263	    MOVQ	$0x123, g(BX)
264	    MOVQ	runtime·m0+m_tls(SB), AX
265	    CMPQ	AX, $0x123
266	    JEQ 2(PC)
267	    CALL	runtime·abort(SB)

dlv 打断点，进入 258 行汇编指令处：

(dlv) b /usr/local/go/src/runtime/asm_amd64.s:258
Breakpoint 2 set at 0x4542cb for runtime.rt0_go() /usr/local/go/src/runtime/asm_amd64.s:258
(dlv) c
(dlv) si
> runtime.rt0_go() /usr/local/go/src/runtime/asm_amd64.s:259 (PC: 0x4542d2)
Warning: debugging optimized function
        // 将 [runtime.m0+136] 地址移到 rdi，rdi = &runtime.m0.tls
        asm_amd64.s:258 0x4542cb*       488d3d565f0700                  lea rdi, ptr [runtime.m0+136]
        // 调用 runtime.settls 设置线程本地存储
=>      asm_amd64.s:259 0x4542d2        e809240000                      call $runtime.settls
        // 将 0x123 移到 fs:[0xfffffff8]
        asm_amd64.s:263 0x4542d7        6448c70425f8ffffff23010000      mov qword ptr fs:[0xfffffff8], 0x123
        // 将 [runtime.m0+136] 的值移到 rax 寄存器中
        asm_amd64.s:264 0x4542e4        488b053d5f0700                  mov rax, qword ptr [runtime.m0+136]
        // 比较 rax 寄存器的值是否等于 0x123，如果不等于则执行 call $runtime.abort
        asm_amd64.s:265 0x4542eb        483d23010000                    cmp rax, 0x123
        asm_amd64.s:266 0x4542f1        7405                            jz 0x4542f8
        asm_amd64.s:267 0x4542f3        e808040000                      call $runtime.abort

这段指令涉及到线程本地存储的知识。线程本地存储（TLS）是一种机制，允许每个线程有自己独立的一组变量，即使这些变量在多个线程之间共享相同的代码。在 Go runtime 中，每个操作系统线程（M）都需要知道自己当前正在执行哪个 goroutine（G）。为了高效地访问这些信息，Go runtime 使用 TLS 来存储 G 的指针。这样每个线程都可以通过 TLS 快速找到自己当前运行的 G。m0 是 Go 程序启动时的第一个操作系统线程，并且负责初始化整个 Go runtime。在其他线程通过 Go runtime 的调度器创建时，调度器会自动为它们设置 TLS，并将 G 的指针写入 TLS。但 m0 是一个特殊的线程，它直接由操作系统创建，而没有经过 Go 调度器，因此需要通过汇编指令设置 TLS。

这段指令的逻辑是将 runtime.m0.tls 的地址送到 rdi 寄存器中，接着调用 runtime.settls 设置 fs 段基址寄存器的值，使得通过段基址和偏移量就能访问到 m0.tls。最后验证设置的 [段基址：偏移量] 能否正确的访问到 m0.tls，将 0x123 传到 [段基址：偏移量]，这时如果访问正确，应该传给的是 m0.tls[0] = 0x123，然后将 [runtime.m0+136] 的内容，即 m0.tls[0] 拿出来移到 rax 寄存器做比较，如果一样，则说明通过 [段基址：偏移量] 可以正确访问到 m0.tls，否则调用 runtime.abort 退出 runtime。

每个线程都有自己的一组 CPU 寄存器值，不同的线程通过不同的段 fs 基址寄存器私有的存储全局变量。更详细的信息请参考 Go语言调度器源代码情景分析之十：线程本地存储。

为加深这块理解，我们从汇编角度看具体是怎么设置的。

asm_amd64.s:258 0x4542cb*       488d3d565f0700                  lea rdi, ptr [runtime.m0+136]
=> rdi = &runtime.m0.tls = 0x00000000004ca228

asm_amd64.s:259 0x4542d2        e809240000                      call $runtime.settls
=> 设置的是 Fs_base 段基址寄存器的值，regs 查看 Fs_base=0x00000000004ca230

asm_amd64.s:263 0x4542d7        6448c70425f8ffffff23010000      mov qword ptr fs:[0xfffffff8], 0x123
=> fs:[0xfffffff8]，fs 是段基址，实际是 Fs_base 段基址寄存器的值，[0xfffffff8] 是偏移量。fs:[0xfffffff8] = 0x00000000004ca230:[0xfffffff8] = 0x00000000004ca228
=> 实际通过段基址寄存器 fs:[0xfffffff8] 访问的内存地址就是 m0.tls 的地址 0x00000000004ca228

继续往下执行：

=>      asm_amd64.s:271 0x4542f8        488d0dc15a0700                  lea rcx, ptr [runtime.g0]               // 将 runtime.g0 的地址移到 rcx，rcx = &runtime.g0
        asm_amd64.s:272 0x4542ff        6448890c25f8ffffff              mov qword ptr fs:[0xfffffff8], rcx      // 将 rcx 移到 m0.tls，实际是 m0.tls[0] = &runtime.g0
        asm_amd64.s:273 0x454308        488d05915e0700                  lea rax, ptr [runtime.m0]               // 将 runtime.m0 的地址移到 rax，rax = &runtime.m0
        asm_amd64.s:276 0x45430f        488908                          mov qword ptr [rax], rcx                // 将 runtime.g0 的地址移到 runtime.m0，实际是 runtime.m0.g0 = &runtime.g0
        asm_amd64.s:278 0x454312        48894130                        mov qword ptr [rcx+0x30], rax           // 将 runtime.m0 的地址移到 runtime.g0.m，实际是 runtime.g0.m = &runtime.m0

上述指令做的是关联主线程 m0 和 g0，这样 m0 就有了运行时执行环境。画出内存布局如下图：

image

2. 小结

至此，我们的程序初始化部分就告一段落了，下一篇将正式进入调度器的部分。

原创作者: xingzheanan 转载于: https://www.cnblogs.com/xingzheanan/p/18407990
碧野兮朱桥
关注
Go并发编程-runtime包
技术原始积累
02-03 1126
一、前言Go的运行时包runtime中包含了一些列的可以设置go运行时的环境的函数，比如运行最大有多少逻辑处理器（P），最多可以创建多少OS线程（M）等。二、运行时环境设置函数runti...
Go语言面试题
wang的博客
05-17 7526
1.Go有哪些数据类型 2.方法与函数的区别 在Go语言中，函数和方法不太一样，有明确的概念区分；函数是指不属于任何结构体、类型的方法，也就是说函数是没有接收者的；而方法是有接收者的。 3.方法值接收者和指针接收者的区别 如果方法的接收者是指针类型，无论调用者是对象还是对象指针，修改的都是对象本身，会影响调用者； 如果方法的接收者是值类型，无论调用者是对象还是对象指针，修改的都是对象的副本，不影响调用者； 4.函数返回局部变量的指针是否安全 一般来说，局部变量会在函数返回后被销毁，因此被返回的引用就成为了
[golang]runtime!!!!
小小李的博客
01-31 483
本文转自:https://zhuanlan.zhihu.com/p/95056679 万字长文深入浅出 Golang Runtime 腾讯技术工程 ​ 已认证的官方帐号 已关注 718 人赞同了该文章 介绍 本文主要内容如下: Golang Runtime 是个什么? Golang Runtime 的发展历程, 每个版本的改进 Go 调度: 协程结构体, 上下文切换, 调度队列, 大致调度流程, 同步执行流又不阻塞线程的网络实现等 Go 内存: 内存结构, mspan 结构, 全.
go runtime
General_zy的博客
01-31 1497
runtime.Gosched()用于将当前的goroutine让出CPU时间片，让其它的goroutine获得执行机会。同时，当前的goroutine会在未来某个时间点继续运行。上面的Callers只是获取栈的程序计数器，如果想获得整个栈的信息，可以使用CallersFrames函数，省去遍历调用FuncForPC。它可以把程序计数器地址对应的函数的信息获取出来。如果因为内联程序计数器对应多个函数，它返回最外面的函数。Func可以获得函数地址、文件行、函数名等信息。Func类型的值，通过。
go学习之runtime
chant的博客
06-05 2175
runtime包包含了一些对go的runtime系统相互作用的一系列操作，例如操作goroutines的函数。它还包括一些反射包用的低级类型信息（请查阅反射文档）。
【Go并发模型精讲】：goroutine和channel的深层工作原理
在这一章节中，我们将对Go语言的并发模型进行一个概述，为读者建立起一个宏观的认识框架。 首先，我们将讨论Go并发模型的基本概念和特点。我们会了解到，Go语言是如何在没有直接暴露操作系统的线程模型
Go Context设计模式精讲：构建响应式与可取消的服务架构
Go 语言中的 Context 是一种处理并发请求、数据传递和取消信号的接口类型。它允许我们在函数间传递请求范围的值、取消信号和截止时间，这对于控制多个 Goroutines 的行为至关重要。 ## 1.1 Context 的用途 Context...
Java并行数据处理精讲：Fork_Join框架深入理解与应用
传统的单线程处理数据方法在面对大规模数据集时显得力不从心，而并行数据处理则能有效利用多核处理器的计算能力，加快数据处理速度，提高应用程序的吞吐量。 ## 1.2 并行数据处理的优势 采用并行处理技术，数据可以...
一篇文章掌握整个JVM，JVM超详细解析！！！
uuqaz的博客
06-24 4164
首先先了解电脑是二进制的系统，他只认识 01010101比如我们经常要编写 HelloWord.java 电脑是怎么认识运行的 HelloWord.java是我们程序员编写的，我们人可以认识，但是电脑不认识Java文件编译的过程 因此就需要编译：（这是一个大概的观念 抽象画的概念）这个夸平台是中间语言（JVM）实现的夸平台 java有JVM从软件层面屏蔽了底层硬件、指令层面的细节让他兼容各种系统难道 C 和 C++ 不能夸平台吗 其实也可以 C和C++需要在编译器层面去兼容不同操作系统的不同层面，写过C和C
GoRuntime_DotNetFramework_4.0_4.5整合包
01-04
GoRuntime_DotNetFramework_4.0_4.5
go语言部分runtime库函数
dghpgyss的博客
05-29 2691
runtime库函数
Go runtime
JunChow
04-22 922
Golang中的runtime类似Java中的JVM虚拟机，不过runtime并非是虚拟机。 Golang程序生成的可执行文件在指定平台即可运行效率很高，它和C/C++一样编译出来的是二进制可执行文件，运行Golang的程序并不需要安装类似Java虚拟机之类的东西，是因为编译时Golang会将runtime部分代码编译进去。 Golang应用程序、runtime、可执行程序与操作系统之间的关系 ...
Go Runtime
最新发布
weixin_56259766的博客
09-01 218
对于很多需要重复分配、回收内存的地方，sync.Pool是一个很好的选择。频繁地分配、回收内存会给 GC 带来一定的负担，严重的时候会引起 CPU 的毛刺。而sync.Pool可以将暂时将不用的对象缓存起来，待下次需要的时候直接使用， 不用再次经过内存分配，复用对象的内存，减轻 GC 的压力，提升系统的性能。Golang 在语言级别支持协程，称之为 Goroutine。Golang 标准库提供的所有系统。
Go RunTime
weixin_40426261的博客
11-02 604
Goroutine 原理 内存分配原理 GC 原理 Channel 原理 Goroutine GMP 调度模型 Work-stealing 调度算法 Goroutine Lifecycle “Goroutine 是一个与其他 goroutines 并行运行在同一地址空间的 Go 函数或方法。一个运行的程序由一个或更多个 goroutine 组成。它与线程、协程、进程等不同。它是一个 goroutine” —— Rob Pike Goroutines 在同一个用户地址空间里并行独立执行 functions，c
go runtime 包
go|Python的个人博客
07-18 661
虽然Go编译器产生的是本地可执行代码，但是这些代码仍旧运行在Go的runtime（这部分的代码可以在runtime包中找到）当中。Go的运行时，可以通过runtime包中的函数，设置go运行时的环境，比如运行最大有多少逻辑处理器§，最多可以创建多少OS线程(M)等。...
golang runtime 简析
blog
03-06 3722
Go Runtime 的总览 golang 的 runtime 在 golang 中的地位类似于 Java 的虚拟机，不过 go runtime 不是虚拟机. golang 程序生成可执行文件在指定平台上即可运行，效率很高， 它和 c/c++ 一样编译出来的是二进制可执行文件. 我们知道运行 golang 的程序并不需要主机安装有类似 Java 虚拟机之类的东西，那是因为在编译时，golang 会...
Go 运行时（go runtime）的含义
wohu1104的专栏
02-08 1790
go 运行时，也称为 go runtime。其本身就是每个 go 程序的一部分，它会跟你的源码一起编译并连接到目标程序中。即便你只是写了一个 hello world 程序，这个程序中也包含了 runtime 的实现。 它在程序中具体负责什么？runtime 负责实现 Go 的垃圾收集、并发、内存堆栈管理以及 Go 语言的其他关键功能。 它大部分以标准库的形式存放在每个 Go 发布版的源码中。 ...
Go语言计时器深度解析：Timer与Ticker的使用与原理
"Go语言的计时器主要包括两个类型：Timer和Ticker，它们是基于Go运行时的runtime.timer实现的。本文将深入探讨这两种计时器的内部结构、使用方法及注意事项。\n\nTimer计时器在指定的duration时间后触发，向其内部的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值