Grokking Techtalk #38: Escape Analysis in Go compiler

10/15/2020 Escape analysis in the Go compiler
https://talks.cuonglm.xyz/escape-analysis-in-go-compiler.slide#1 1/57
Escape analysis in the Go compilerEscape analysis in the Go compiler
Cuong Manh LeCuong Manh Le
2020-09-262020-09-26
Software EngineerSoftware Engineer

AgendaAgenda
Go overviewGo overview
Go compiler overviewGo compiler overview
Escape Analysis overviewEscape Analysis overview
How Go compiler implements escape analysisHow Go compiler implements escape analysis 22

Warm upWarm up
This talk assumes you did know fundamental concepts of a compiler.This talk assumes you did know fundamental concepts of a compiler.
The termThe term gcgc in this talk stands forin this talk stands for go compilergo compiler, not, not garbage collectorgarbage collector..
There are some compilers for Go: gc, gccgo,There are some compilers for Go: gc, gccgo, tinygotinygo(https://github.com/tinygo-org/tinygo)(https://github.com/tinygo-org/tinygo)... This talk is about... This talk is about
gcgc, the official Go compiler., the official Go compiler.
This talk use go version 1.15This talk use go version 1.15
I recommendI recommend this coursethis course(https://online.stanford.edu/courses/soe-ycscs1-compilers)(https://online.stanford.edu/courses/soe-ycscs1-compilers)for anyone interested in learning aboutfor anyone interested in learning about
compilers.compilers. 33

Let's goLet's go
44

Go overviewGo overview
55

GoGo
Go is an open source programming language that makes it easy to build simple, reliable, andGo is an open source programming language that makes it easy to build simple, reliable, and
efficient software.efficient software.
package mainpackage main
import "fmt"import "fmt"
func main() {func main() {
fmt.Println("Hello, 世界")fmt.Println("Hello, 世界")
}} Run
66

Why is Go great for modern distributed computing?Why is Go great for modern distributed computing?
First class concurrency primitivesFirst class concurrency primitives
All inclusive networking librariesAll inclusive networking libraries
Statically Typed languageStatically Typed language
Simple language to learnSimple language to learn
Statically linked binariesStatically linked binaries
Fast build timesFast build times
Many more…Many more… 77

Go was built to solve problems at Google:Go was built to solve problems at Google:
Multicore processorsMulticore processors
Networked systemsNetworked systems
Massive computation clustersMassive computation clusters
......
See more detailsSee more details herehere(https://talks.golang.org/2013/distsys.slide#1)(https://talks.golang.org/2013/distsys.slide#1) 88

Go Compiler OverviewGo Compiler Overview
99

What's compilerWhat's compiler
A compiler is a computer program that translates high level human written computer codeA compiler is a computer program that translates high level human written computer code
into machine executable code.into machine executable code.
$ file main.go$ file main.go
main.go: C source, UTF-8 Unicode textmain.go: C source, UTF-8 Unicode text
$ go tool compile main.go$ go tool compile main.go
$ ls$ ls
main.go main.omain.go main.o
$ file main.o$ file main.o
main.o: current ar archivemain.o: current ar archive
$ ar x main.o$ ar x main.o
$ ls$ ls
_go_.o main.go main.o __.PKGDEF_go_.o main.go main.o __.PKGDEF
$ file _go_.o$ file _go_.o
_go_.o: data_go_.o: data
1010

Go compiler (gc)Go compiler (gc)
Translate go source code to machine code.Translate go source code to machine code.
$ go tool compile main.go$ go tool compile main.go
Actually, "gc" is a separate executable, invoked by the "go" command:Actually, "gc" is a separate executable, invoked by the "go" command:
$ go tool -n compile$ go tool -n compile
/home/cuonglm/sources/go/pkg/tool/linux_amd64/compile/home/cuonglm/sources/go/pkg/tool/linux_amd64/compile
1111

How does gc do itHow does gc do it
Through many steps or phases, logically, there'reThrough many steps or phases, logically, there're fourfour phases:phases:
ParsingParsing
Type-checking and AST transformationsType-checking and AST transformations
SSASSA
Generate machine codeGenerate machine code 1212

How does gc do itHow does gc do it
SourceSource(https://www.slideshare.net/moriyoshi/hacking-go-compiler-internals-gocon-2014-autumn)(https://www.slideshare.net/moriyoshi/hacking-go-compiler-internals-gocon-2014-autumn) 1313

1 - Parsing1 - Parsing
Includes bothIncludes both lexinglexing(https://en.wikipedia.org/wiki/Lexical_analysis)(https://en.wikipedia.org/wiki/Lexical_analysis)andand parsingparsing(https://en.wikipedia.org/wiki/Parsing)(https://en.wikipedia.org/wiki/Parsing) 1414

Lexer comes from lexical analysis which means converting a sequence ofLexer comes from lexical analysis which means converting a sequence of
characters into a sequence of tokens/stringscharacters into a sequence of tokens/strings

ExampleExample
a := 1a := 1
will be parsed/lexed and produce:will be parsed/lexed and produce:
[]ast.Stmt {[]ast.Stmt {
&ast.AssignStmt {&ast.AssignStmt {
Lhs: []ast.Expr {Lhs: []ast.Expr {
&ast.Ident {Name: "a"},&ast.Ident {Name: "a"},
},},
Tok: :=,Tok: :=,
Rhs: []ast.Expr {Rhs: []ast.Expr {
&ast.BasicLit {&ast.BasicLit {
ValuePos: 32,ValuePos: 32,
Kind: INT,Kind: INT,
Value: "1",Value: "1",
},},
},},
},},
}}
This uses "go/ast", compiler uses another parser in "cmd/compile/internal/syntax", but it'sThis uses "go/ast", compiler uses another parser in "cmd/compile/internal/syntax", but it's
similar.similar. 1717

2 - Type-checking and AST transformations2 - Type-checking and AST transformations
Type checking means to confirm that declared variables correctly store data with theType checking means to confirm that declared variables correctly store data with the
types they are declared with.types they are declared with.
To perform type checking, this pass is presented with what's called anTo perform type checking, this pass is presented with what's called an Abstract syntaxAbstract syntax
treetree(https://en.wikipedia.org/wiki/Abstract_syntax_tree)(https://en.wikipedia.org/wiki/Abstract_syntax_tree)
The intermediate representation (The intermediate representation (IRIR(https://en.wikipedia.org/wiki/Intermediate_representation)(https://en.wikipedia.org/wiki/Intermediate_representation)) of source code in another) of source code in another
form, specifically, it's aform, specifically, it's a treetree..
func main() {func main() {
var x stringvar x string
x = 1x = 1
println(x)println(x)
}} Run
1818

3 - SSA3 - SSA
Static single assignment formStatic single assignment form(https://en.wikipedia.org/wiki/Static_single_assignment_form)(https://en.wikipedia.org/wiki/Static_single_assignment_form)is another IR of the source codeis another IR of the source code
(not a(not a treetree):):
variable is assignedvariable is assigned exactly onceexactly once
variable isvariable is defineddefined before it is usedbefore it is used
b1:b1:
v1 = InitMem <mem>v1 = InitMem <mem>
v2 = SP <uintptr>v2 = SP <uintptr>
v3 = SB <uintptr>v3 = SB <uintptr>
v4 = Addr <*uint8> {type.string} v3v4 = Addr <*uint8> {type.string} v3
v5 = Addr <*string> {""..stmp_0} v3v5 = Addr <*string> {""..stmp_0} v3
v6 = IMake <interface {}> v4 v5 (~arg0[interface {}])v6 = IMake <interface {}> v4 v5 (~arg0[interface {}])
v7 = ConstInterface <interface {}>v7 = ConstInterface <interface {}>
v8 = ArrayMake1 <[1]interface {}> v7v8 = ArrayMake1 <[1]interface {}> v7
v9 = VarDef <mem> {.autotmp_11} v1v9 = VarDef <mem> {.autotmp_11} v1
......
v25 = ConstInterface <error> (fmt..autotmp_4[error], fmt.err[error]) DEADv25 = ConstInterface <error> (fmt..autotmp_4[error], fmt.err[error]) DEAD
v28 = OffPtr <*io.Writer> [0] v2v28 = OffPtr <*io.Writer> [0] v2
v29 = Addr <*uint8> {go.itab.*os.File,io.Writer} v3v29 = Addr <*uint8> {go.itab.*os.File,io.Writer} v3
v30 = Addr <**os.File> {os.Stdout} v3v30 = Addr <**os.File> {os.Stdout} v3
......
1919

SSA helps avoiding unnecessary operations that don't affect the final form of a variable's use:SSA helps avoiding unnecessary operations that don't affect the final form of a variable's use:
nil-check, bound check ...nil-check, bound check ... 2020

4 - Generate machine code4 - Generate machine code
00000 (5) TEXT "".main(SB), ABIInternal00000 (5) TEXT "".main(SB), ABIInternal
00001 (5) FUNCDATA $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)00001 (5) FUNCDATA $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
00002 (5) FUNCDATA $1, gclocals·f207267fbf96a0178e8758c6e3e0ce28(SB)00002 (5) FUNCDATA $1, gclocals·f207267fbf96a0178e8758c6e3e0ce28(SB)
00003 (5) FUNCDATA $3, "".main.stkobj(SB)00003 (5) FUNCDATA $3, "".main.stkobj(SB)
v26 00004 (6) XORPS X0, X0v26 00004 (6) XORPS X0, X0
v11 00005 (6) MOVUPS X0, ""..autotmp_11-16(SP)v11 00005 (6) MOVUPS X0, ""..autotmp_11-16(SP)
v20 00006 (6) LEAQ type.string(SB), AXv20 00006 (6) LEAQ type.string(SB), AX
v14 00007 (6) MOVQ AX, ""..autotmp_11-16(SP)v14 00007 (6) MOVQ AX, ""..autotmp_11-16(SP)
v38 00008 (6) LEAQ ""..stmp_0(SB), AXv38 00008 (6) LEAQ ""..stmp_0(SB), AX
v17 00009 (6) MOVQ AX, ""..autotmp_11-8(SP)v17 00009 (6) MOVQ AX, ""..autotmp_11-8(SP)
v27 00010 (?) NOPv27 00010 (?) NOP
# $GOROOT/src/fmt/print.go# $GOROOT/src/fmt/print.go
......
v36 00019 (274) PCDATA $1, $0v36 00019 (274) PCDATA $1, $0
v36 00020 (274) CALL fmt.Fprintln(SB)v36 00020 (274) CALL fmt.Fprintln(SB)
# main.go# main.go
b4 00021 (6) RETb4 00021 (6) RET
00022 (?) END00022 (?) END
2121

That's 4 logical phases of go compilerThat's 4 logical phases of go compiler
2222

But ...But ...
The second phase contains moreThe second phase contains more sub-phasessub-phases
Type Check const, type, and names and types of funcsType Check const, type, and names and types of funcs
Type Check variable assignmentsType Check variable assignments
Type check function bodiesType check function bodies
Capture closure variablesCapture closure variables
InliningInlining
Escape analysisEscape analysis
Transform closure bodiesTransform closure bodies 2323

But ...But ...
The second phase contains moreThe second phase contains more sub-phasessub-phases
Type Check const, type, and names and types of funcsType Check const, type, and names and types of funcs
Type Check variable assignmentsType Check variable assignments
Type check function bodiesType check function bodies
Capture closure variablesCapture closure variables
InliningInlining
Escape analysisEscape analysis
Transform closure bodiesTransform closure bodies
Escape Analysis is important to help the compiler decide if it should allocate variables on theEscape Analysis is important to help the compiler decide if it should allocate variables on the
heap or on the stack or how to store the associated data.heap or on the stack or how to store the associated data. 2424

What is Escape AnalysisWhat is Escape Analysis
Escape Analysis is a method for determining the dynamic scope of pointers – where in theEscape Analysis is a method for determining the dynamic scope of pointers – where in the
program a pointer can be accessed. It is related to pointer analysis and shape analysis.program a pointer can be accessed. It is related to pointer analysis and shape analysis.
From https://en.wikipedia.org/wiki/Escape_analysisFrom https://en.wikipedia.org/wiki/Escape_analysis 2525

What is Escape AnalysisWhat is Escape Analysis
Escape Analysis is a method for determining the dynamic scope of pointers –Escape Analysis is a method for determining the dynamic scope of pointers – wherewhere in thein the
program a pointer can be accessed. It is related to pointer analysis and shape analysis.program a pointer can be accessed. It is related to pointer analysis and shape analysis.
"where" means"where" means stackstack oror heapheap 2626

Stack vs HeapStack vs Heap
This is traditional way heap/stack work.This is traditional way heap/stack work.
Within Go runtime:Within Go runtime:
Stacks are allocated within heap memoryStacks are allocated within heap memory
There can be more than one stack, and stacks might grow/shrink/move over time.There can be more than one stack, and stacks might grow/shrink/move over time. 2727

Why is Escape Analysis necessaryWhy is Escape Analysis necessary
The most benefit is helping convert heap allocation → stack allocationThe most benefit is helping convert heap allocation → stack allocation 2828

Why is Escape Analysis necessaryWhy is Escape Analysis necessary
That means:That means:
Faster execution time: stack allocation is much faster than heap allocationFaster execution time: stack allocation is much faster than heap allocation
Reduce garbage collector pressureReduce garbage collector pressure 2929

ExampleExample
StackStack
import "testing"import "testing"
type s struct {type s struct {
f *intf *int
}}
func stack() {func stack() {
x := s{}x := s{}
x.f = new(int)x.f = new(int)
}}
func BenchmarkAlloc(b *testing.B) {func BenchmarkAlloc(b *testing.B) {
b.ReportAllocs()b.ReportAllocs()
for i := 0; i <= b.N; i++ {for i := 0; i <= b.N; i++ {
stack()stack()
}}
}}
3030

$ go test -bench=. benchstat_stack_test.go$ go test -bench=. benchstat_stack_test.go
goos: linuxgoos: linux
goarch: amd64goarch: amd64
BenchmarkAlloc-8 1000000000 0.241 ns/op 0 B/op 0 allocs/opBenchmarkAlloc-8 1000000000 0.241 ns/op 0 B/op 0 allocs/op
PASSPASS
ok command-line-arguments 2.661sok command-line-arguments 2.661s
3131

ExampleExample
HeapHeap
import "testing"import "testing"
type s struct {type s struct {
f *intf *int
}}
func heap() {func heap() {
x := &s{}x := &s{}
}}
func BenchmarkAlloc(b *testing.B) {func BenchmarkAlloc(b *testing.B) {
b.ReportAllocs()b.ReportAllocs()
for i := 0; i <= b.N; i++ {for i := 0; i <= b.N; i++ {
heap()heap()
}}
}}
3232

$ go test -bench=. benchstat_heap_test.go$ go test -bench=. benchstat_heap_test.go
goos: linuxgoos: linux
goarch: amd64goarch: amd64
PASSPASS
ok command-line-arguments 12.126sok command-line-arguments 12.126s
3333

ExampleExample
$ benchstat stack.txt heap.txt$ benchstat stack.txt heap.txt
name old time/op new time/op deltaname old time/op new time/op delta
Alloc-8 0.24ns ± 1% 11.25ns ± 7% +4591.41% (p=0.000 n=10+10)Alloc-8 0.24ns ± 1% 11.25ns ± 7% +4591.41% (p=0.000 n=10+10)
name old alloc/op new alloc/op deltaname old alloc/op new alloc/op delta
Alloc-8 0.00B 8.00B ± 0% +Inf% (p=0.000 n=10+10)Alloc-8 0.00B 8.00B ± 0% +Inf% (p=0.000 n=10+10)
name old allocs/op new allocs/op deltaname old allocs/op new allocs/op delta
Alloc-8 0.00 1.00 ± 0% +Inf% (p=0.000 n=10+10)Alloc-8 0.00 1.00 ± 0% +Inf% (p=0.000 n=10+10)
3434

How is escape analysis implemented in the GoHow is escape analysis implemented in the Go
compiler?compiler?
3535

Building a directed weighted graphBuilding a directed weighted graph
With some rules:With some rules:
Vertices (termed "location") represent variables.Vertices (termed "location") represent variables.
Edges represent assignments between variables.Edges represent assignments between variables.
Compound variables (struct, slice, array, map ...) is lowered to simplest representation.Compound variables (struct, slice, array, map ...) is lowered to simplest representation. 3636

That meansThat means
var x struct { f, g *int }var x struct { f, g *int }
var u []*intvar u []*int
x.f = u[0]x.f = u[0]
is modeled simply as:is modeled simply as:
x = *ux = *u
3737

Building a directed weighted graphBuilding a directed weighted graph
With some rules:With some rules:
Vertices (termed "location") represents variables.Vertices (termed "location") represents variables.
Edges represents assignments between variables.Edges represents assignments between variables.
Compound variables is lowered to simplest representation.Compound variables is lowered to simplest representation.
Number of dereference operations minus the number of addressing operations is theNumber of dereference operations minus the number of addressing operations is the
edge's weightedge's weight
p = &q // -1p = &q // -1
p = q // 0p = q // 0
p = *q // 1p = *q // 1
p = **q // 2p = **q // 2
p = **&**&q // 2p = **&**&q // 2
3838

Run Bellman-Ford shortest path algorithmRun Bellman-Ford shortest path algorithm
To calculate the minimal number of dereferences from a "location" to others.To calculate the minimal number of dereferences from a "location" to others.
Bellman-FordBellman-Ford(https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm)(https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm)is slower thanis slower than DijkstraDijkstra(https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)(https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm),,
but it can handle negative weight (from addressing operations).but it can handle negative weight (from addressing operations).
Also do not have to worry about negative cycles, because the compiler does not allowAlso do not have to worry about negative cycles, because the compiler does not allow
"distances" to go below 0."distances" to go below 0.
var x intvar x int
_ = &(&x) // invalid_ = &(&x) // invalid
3939

ExampleExample
With following code:With following code:
package ppackage p
var px *intvar px *int
func foo() {func foo() {
var i intvar i int
p := &ip := &i
q := pq := p
px = qpx = q
}}
ii has no edgeshas no edges
pp has edge to i ( weight -1 )has edge to i ( weight -1 )
qq has edge to p ( weight 0 )has edge to p ( weight 0 )
heap has edge to q ( weight 0 )heap has edge to q ( weight 0 ) 4040

ExampleExample
if __name__ == '__main__':if __name__ == '__main__':
graph = {graph = {
'i': {},'i': {},
'p': {'i': -1},'p': {'i': -1},
'q': {'p': 0},'q': {'p': 0},
'heap': {'q': 0}'heap': {'q': 0}
}}
distance, _ = bellman_ford(graph, source='heap')distance, _ = bellman_ford(graph, source='heap')
print distanceprint distance
$ python main.py$ python main.py
{'i': -1, 'p': 0, 'q': 0, 'heap': 0}{'i': -1, 'p': 0, 'q': 0, 'heap': 0}
sourcesource(https://gist.github.com/ngenator/6178728)(https://gist.github.com/ngenator/6178728) 4141

Static data-flow analysisStatic data-flow analysis
To determine whether a locationTo determine whether a location outlivesoutlives others, that means it may survive beyond other'sothers, that means it may survive beyond other's
lifetime if stack allocated.lifetime if stack allocated.
A location outlives other if ...A location outlives other if ... 4242

Returned valuesReturned values
We don't know what the caller will do with the returned values.We don't know what the caller will do with the returned values.
Except for directly called closures:Except for directly called closures:
var u intvar u int
p := func() *int { return &u }()p := func() *int { return &u }()
*p = 42*p = 42
4343

Higher loop scopeHigher loop scope
in the same function:in the same function:
var l *intvar l *int
for {for {
l = new(int)l = new(int)
}}
4444

Other is declared within a child closureOther is declared within a child closure
var l *intvar l *int
func() {func() {
l = new(int)l = new(int)
}}
4545

Escape analysis also records information about whether a function's parameters will escape.Escape analysis also records information about whether a function's parameters will escape.
var global *intvar global *int
func f(p *int) { *p = 42 }func f(p *int) { *p = 42 }
func g(p *int) { global = p }func g(p *int) { global = p }
func h() {func h() {
f(new(int)) // does not escapef(new(int)) // does not escape
g(new(int)) // does escapeg(new(int)) // does escape
}}
That is because escape analysis firstly analyzes justThat is because escape analysis firstly analyzes just ff, then analyzes just *, then analyzes just *gg, then just, then just hh, but it, but it
uses the results of previously analyzinguses the results of previously analyzing ff andand gg.. 4646

That's the theoryThat's the theory
4747

In practiceIn practice
Go compiler provides tools for us to diagnose all of those things.Go compiler provides tools for us to diagnose all of those things.
usage: compile [options] file.go...usage: compile [options] file.go...
......
version,destination for JSON compiler/optimizer loggingversion,destination for JSON compiler/optimizer logging
-l disable inlining-l disable inlining
-lang string-lang string
release to compile forrelease to compile for
-linkobj file-linkobj file
write linker-specific object to filewrite linker-specific object to file
-linkshared-linkshared
generate code that will be linked against Go shared librariesgenerate code that will be linked against Go shared libraries
-live-live
debug liveness analysisdebug liveness analysis
-m print optimization decisions-m print optimization decisions
-memprofile file-memprofile file
write memory profile to filewrite memory profile to file
-memprofilerate rate-memprofilerate rate
set runtime.MemProfileRate to rateset runtime.MemProfileRate to rate
......
4848

ExampleExample
10 func stack() {10 func stack() {
11 x := s{}11 x := s{}
12 x.f = new(int)12 x.f = new(int)
13 }13 }
1414
15 func heap() {15 func heap() {
16 x := &s{}16 x := &s{}
17 x.f = new(int)17 x.f = new(int)
18 }18 }
$ go tool compile -l -m stack_vs_heap_test.go$ go tool compile -l -m stack_vs_heap_test.go
stack_vs_heap_test.go:12:11: new(int) does not escapestack_vs_heap_test.go:12:11: new(int) does not escape
stack_vs_heap_test.go:16:7: &s{} does not escapestack_vs_heap_test.go:16:7: &s{} does not escape
stack_vs_heap_test.go:17:11: new(int) escapes to heapstack_vs_heap_test.go:17:11: new(int) escapes to heap
4949

ExampleExample
$ go tool compile -l -m=2 stack_vs_heap_test.go$ go tool compile -l -m=2 stack_vs_heap_test.go
stack_vs_heap_test.go:17:11: new(int) escapes to heap:stack_vs_heap_test.go:17:11: new(int) escapes to heap:
stack_vs_heap_test.go:17:11: flow: {heap} = &{storage for new(int)}:stack_vs_heap_test.go:17:11: flow: {heap} = &{storage for new(int)}:
stack_vs_heap_test.go:17:11: from new(int) (spill) at stack_vs_heap_test.go:17:11stack_vs_heap_test.go:17:11: from new(int) (spill) at stack_vs_heap_test.go:17:11
stack_vs_heap_test.go:17:11: from x.f = new(int) (assign) at stack_vs_heap_test.go:17:6stack_vs_heap_test.go:17:11: from x.f = new(int) (assign) at stack_vs_heap_test.go:17:6
5050

ExampleExample
$ go tool compile -l -m=3 stack_vs_heap_test.go$ go tool compile -l -m=3 stack_vs_heap_test.go
stack_vs_heap_test.go:11:4:[1] stack stmt: x := s{}stack_vs_heap_test.go:11:4:[1] stack stmt: x := s{}
stack_vs_heap_test.go:11:2:[1] stack stmt: var x sstack_vs_heap_test.go:11:2:[1] stack stmt: var x s
stack_vs_heap_test.go:12:6:[1] stack stmt: x.f = new(int)stack_vs_heap_test.go:12:6:[1] stack stmt: x.f = new(int)
stack_vs_heap_test.go:16:4:[1] heap stmt: x := &s{}stack_vs_heap_test.go:16:4:[1] heap stmt: x := &s{}
stack_vs_heap_test.go:16:2:[1] heap stmt: var x *sstack_vs_heap_test.go:16:2:[1] heap stmt: var x *s
stack_vs_heap_test.go:17:6:[1] heap stmt: x.f = new(int)stack_vs_heap_test.go:17:6:[1] heap stmt: x.f = new(int)
stack_vs_heap_test.go:17:11: new(int) escapes to heap:stack_vs_heap_test.go:17:11: new(int) escapes to heap:
stack_vs_heap_test.go:17:11: flow: {heap} = &{storage for new(int)}:stack_vs_heap_test.go:17:11: flow: {heap} = &{storage for new(int)}:
stack_vs_heap_test.go:17:11: from new(int) (spill) at stack_vs_heap_test.go:17:11stack_vs_heap_test.go:17:11: from new(int) (spill) at stack_vs_heap_test.go:17:11
stack_vs_heap_test.go:17:11: from x.f = new(int) (assign) at stack_vs_heap_test.go:17:6stack_vs_heap_test.go:17:11: from x.f = new(int) (assign) at stack_vs_heap_test.go:17:6
5151

There's plenty of short-comingsThere's plenty of short-comings
var global *intvar global *int
func f(x bool, p *int) { if x { global = p } }func f(x bool, p *int) { if x { global = p } }
func g() {func g() {
f(false, new(int)) // BAD: new(int) is heap allocated, but would be safe to stack allocate heref(false, new(int)) // BAD: new(int) is heap allocated, but would be safe to stack allocate here
}}
Or assigment through a pointer is conservatively treated as a store to the heap.Or assigment through a pointer is conservatively treated as a store to the heap.
func heap() {func heap() {
x := &s{}x := &s{}
}}
5252

Further readingFurther reading
https://github.com/golang/go/blob/release-https://github.com/golang/go/blob/release-
branch.go1.15/src/cmd/compile/internal/gc/escape.gobranch.go1.15/src/cmd/compile/internal/gc/escape.go
https://www.cc.gatech.edu/~harrold/6340/cs6340_fall2009/Readings/choi99escape.pdfhttps://www.cc.gatech.edu/~harrold/6340/cs6340_fall2009/Readings/choi99escape.pdf5353

Q&AQ&A
5454

Special thanks (listing order by reviewing date)Special thanks (listing order by reviewing date)
@huydx@huydx(https://github.com/huydx)(https://github.com/huydx)
@favadi@favadi(https://github.com/favadi)(https://github.com/favadi)
@mdempsky@mdempsky(https://github.com/mdempsky)(https://github.com/mdempsky)
@odeke-em@odeke-em(https://github.com/odeke-em)(https://github.com/odeke-em)
These folks have helped me review many things like parts of this talk and code.These folks have helped me review many things like parts of this talk and code. 5555

Thank youThank you
Cuong Manh LeCuong Manh Le
2020-09-262020-09-26
Software EngineerSoftware Engineer
cuong.manhle.vn@gmail.comcuong.manhle.vn@gmail.com(mailto:cuong.manhle.vn@gmail.com)(mailto:cuong.manhle.vn@gmail.com)
https://cuonglm.xyzhttps://cuonglm.xyz(https://cuonglm.xyz)(https://cuonglm.xyz)
@cuonglm_@cuonglm_(http://twitter.com/cuonglm_)(http://twitter.com/cuonglm_)

Grokking Techtalk #38: Escape Analysis in Go compiler

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Grokking Techtalk #38: Escape Analysis in Go compiler

Ähnlich wie Grokking Techtalk #38: Escape Analysis in Go compiler (20)

Mehr von Grokking VN

Mehr von Grokking VN (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Grokking Techtalk #38: Escape Analysis in Go compiler