Memory allocation principle
Go uses escape analysis to determine where the variable is stored, and usually tries to store all Go values in function stack frames, which is called stack allocation. The compiler can determine which memory needs to be released based on the code situation and issue machine instructions to clean up without the intervention of the Go garbage collector.
However, when the compiler cannot determine the life cycle or size of a variable, it escapes the variable into the heap. For example, variables are too large to be put into the stack, or the compiler cannot determine whether the variable is used after the function is finished, which can cause the variable to escape into the heap.
Nevertheless, we are not completely sure whether a value is stored in the heap or the stack, because only the compiler can really understand where the variable is stored. In most cases, Go developers don't need to care about where the values are stored, but understanding this helps with performance optimization.
The role of escape analysis
Escape analysis is a process used by the compiler to determine whether a variable escapes into the heap. Any value that cannot be stored in the function stack frame will escape to the heap. We can usego build -gcflags="-m"Commands to check the memory allocation of the code to better understand the escape behavior of variables.
The following are some examples to illustrate the process of escape analysis:
When one function simply calls another, variables are usually left on the stack.
package main
func main() {
x := 2
square(x)
}
func square(x int) int {
return x * x
}In this case, all variables are kept on the stack.
# /timliudream/go-test/EscapeDemo
./:8:6: can inline square
./:3:6: can inline main
./:5:8: inlining call to square
When a function returns a pointer, the variable may escape into the heap.
package main
func main() {
x := 2
square(x)
}
func square(x int) *int {
y := x * x
return &y
}Here, variablesyEscape to the heap because its life cycle needs to be extended until the function returns.
# /timliudream/go-test/EscapeDemo
./:21:6: can inline square
./:16:6: can inline main
./:18:8: inlining call to square
./:22:2: moved to heap: y
When a function accepts a pointer and returns a pointer, variables may be shared between the stack and the heap.
func main() {
x := 4
square(&x)
}
func square(x *int) *int {
y := *x * *x
return &y
}In this case, the variablexStay on the stack, but the value it points to may escape into the heap.
# /timliudream/go-test/EscapeDemo
./:50:6: can inline square
./:45:6: can inline main
./:47:8: inlining call to square
./:50:13: x does not escape
./:51:2: moved to heap: y
Escape analysis provides us with tools to understand the memory allocation of code, and although we don't need to care about this in most cases, it can be helpful to understand these principles when optimizing performance.
in conclusion
Memory allocation and escape analysis in Go language are important means for compilers to optimize performance. Understanding these principles helps us write more efficient code. passgo build -gcflags="-m"The command can view the memory allocation of the code, thereby better optimizing the code.
This is the end of this article about a brief analysis of escape analysis in Go. For more relevant Go escape analysis content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!