This document discusses moving from C to Go and compares various aspects of memory allocation between the two languages. It covers how arrays are values in Go rather than pointers, stack allocation versus heap allocation, and Go's garbage collector. It also provides an overview of the Go toolchain including supported architectures and compares performance of GCCGO versus the standard Go compiler. Finally, it explains Go's M:N user-space scheduler model and how goroutines are scheduled across logical processors.

1. Move From C to Go
Cherie Hsieh
1

2. Move From C to Go
Golang Taiwan, Gopher Taipei
2
7056 members

3. Move From C to Go
Go Turns 10
3
10 years of Go!!

4. Move From C to Go
Go Turns 10
4
Special stickers for
gophers in Taiwan

5. Move From C to Go
Beginning
5
Robert Griesemer Rob Pike Ken Thompson
The designers of Go language.

6. Move From C to Go
Beginning
6

7. Move From C to Go
The Goals of Go
7
Go was designed by and for people who write—and read and debug and
maintain—large software systems.
ELIMINATE
SLOWNESS
ELIMINATE
CLUMSINESS
IMPROVE
EFFECTIVENESS
IMPROVE
SCALE

8. Move From C to Go
The Future of Go
8
Image is from GMOM- Go Slide Template - 10th Birthday

9. Memory Allocation
9
Move From C to Go

10. Move From C to Go
Memory Allocation
10
void numbers()
{
int numbers[50];
}
void numbers()
{
int *numbers = malloc(sizeof(int) * 50);
}
Memory allocation in C.
Stack
Heap

11. Move From C to Go
Memory Allocation
11
func Numbers() {
var numbers [50]int
}
Memory allocation in Go.
Stack
func GetNumbers() [50]int {
var numbers [50]int
return numbers
}
func main() {
n := GetNumbers()
}
Stack
Stack
GetNumbers stack frame
Main stack frame

12. Move From C to Go
Memory Allocation
12
Go's arrays are values.
An array variable denotes the entire array.
It is not a pointer to the first array element like C.
Read More: Go Slices: usage and internals

13. Move From C to Go
Memory Allocation
13
func GetNumbers() {
numbers := new([50]int)
}
Memory allocation in Go.
Stack
new(T) allocates zeroed storage for a new item of type T and returns its address, a value
of type *T.
The variable may not be allocated in heap like C/C++.
Read More: Effective Go - Allocation with New

14. Move From C to Go
Memory Allocation
14
func GetNumbers() *[50]int {
numbers := new([50]int)
return numbers
}
func main() {
n := GetNumbers()
n[0] = 1
}
Memory allocation in Go.
Heap

15. Move From C to Go
Memory Allocation
15
How do I know whether a variable is allocated on the heap or the stack?
In the current compilers, if a variable has its address taken, that variable is a candidate
for allocation on the heap. However, a basic escape analysis recognizes some cases
when such variables will not live past the return from the function and can reside on the
stack.
From Frequently Asked Questions (FAQ)
Read More: Escape-Analysis Flaws

16. Move From C to Go
Memory Allocation
16
1. Do we need to change the underlying value?
2. Should the value be nil?
The basic rules of passing by pointers or values
Read More: Allocation efficiency in high-performance Go services

17. Move From C to Go
Memory Allocation
17
func GetNumbers() [50]int {
var numbers [50]int
return numbers
}
func main() {
n := GetNumbers()
}
Stack
Stack
The address is not in the system stack

18. Move From C to Go
Memory Allocation
18
Memory allocator in Go (A branch of TCMalloc).

19. Move From C to Go
Memory Allocation
19
Memory allocator in Go.
User space thread

20. Move From C to Go
Memory Allocation
20
Memory allocator in Go.
User space thread

21. Move From C to Go
Memory Allocation
21
To prevent the fragmentation problem on 32-bit platform, Go will make a large initial
reservation of virtual memory (~258MB).
Note
Read More:
1. A visual guide to Go Memory Allocator from scratch
2. Go’s Memory Allocator - Overview

22. Move From C to Go
Memory Allocation
22
1. Use local variables (copy by value)
2. For large cache libraries, they use mmap (or some tricky ways) to avoid the GC
scan. (e.g. bigCache library).
The practices to reduce the stress of Garbage Collection
Read More: Writing a very fast cache service with millions of entries in Go

23. Move From C to Go
Memory Allocation
23
More about the goroutine stack
resizeable goroutine stack (continuous stack)
Read More: Contiguous stacks in Go
Question: How can we copy the stack to a new one without losing pointers?

24. Go Toolchain
24
Move From C to Go

25. Move From C to Go
Go Toolchain
25
Support five major architectures
1. x86
2. ARM
3. PowerPC
4. MIPS
5. IBM
6. WebAssembly
- GC (Go compiler. Generate an object file for the Go linker)
- Go Linker

26. Move From C to Go
Go Toolchain
26
gccgo: the front-end of gcc compiler
- support most of gcc compiler options.
An alternative compiler
Front-end
GCCGO
Mid-end
GCC
Back-end
GCC
Analyzing the source code to
build an internal representation
of the program.
performs optimizations on the
intermediate representation.
Responsible for the CPU
a r c h i t e c t u r e s p e c i fi c
optimizations and for code
generation.

27. Move From C to Go
Go Toolchain
27
Performance Comparison
GCCGO still yielding (much) slower code than the standard compiler.
(GCCGO in 2019 https://meltware.com/2019/01/16/gccgo-benchmarks-2019.html)
Why use GCCGO?
Brief overview of gccgo, "the other" Go compiler

28. Move From C to Go
Go Toolchain
28
More about Go linker
This approach is different from the less conventional gc compiler, which does
significant code generation work at link time.
The Go runtime needs to know where all the pointers are in the data and bss
segments, and a standard linker won't put that information together for you. The
Go linker does that. The Go linker also writes out runtime information for
unwinding stacks during GC and translating program counters to file:line for use
in stack dumps. Again, this is all much easier to do with a toolchain that we control
entirely than having to build into existing ones.
Building a better Go linker (2019/09)
(https://docs.google.com/document/d/1D13QhciikbdLtaI67U6Ble5d_1nsI4befEd6_k1z91U/mobilebasic)

29. User-Space Scheduler in Go
29
Move From C to Go

30. Move From C to Go
User-Space Scheduler in Go
30
Thread Models
- NPTL C Library
1:1 (kernel-level threading)
- Go
M:N scheduling
M
P
(processor)
G2
G3
G4
Local Runnable
Queue
Kernel Thread
G1
Execute

31. Move From C to Go
User-Space Scheduler in Go
31
M
P
(processor)
G2
G3
G4
Local Runnable
Queue
Execute
31
Context Switch
semtable
G1
Sleep
Wake up
- Generally, there is no system call
being invoked during rescheduling
- Data Locality for Processor

32. Move From C to Go
User-Space Scheduler in Go
32
M
P1
(processor)
G1
Execute
32
Create a New Goroutine
G2
Local Runnable
Queue
(1) Add a new goroutine to LRQ
Global Queue
(2) Move half of tasks from a local queue to the global
runnable queue if the local queue full.
M
P2
(processor)
Steal
Grab

33. Move From C to Go
User-Space Scheduler in Go
Note
- The current implementation of the Go scheduler is not a preemptive scheduler
but a cooperating scheduler.
(go 1.14 may release non-cooperative goroutine preemption)
- The scheduler needs well-defined user space events that happen at safe points
in the code to make scheduling decisions.

34. Enjoy your developer life with Go
34