pointers/

README

Pointers

Pointers provide a way to share data across function boundaries. Having the ability to share and reference data with a pointer provides flexbility. It also helps our programs minimize the amount of memory they need and can add some extra performance.

Notes

• Use pointers to share data.
• Values in Go are always pass by value.
• "Value of", what's in the box. "Address of" ( & ), where is the box.
• The (*) operator declares a pointer variable and the "Value that the pointer points to".

Garbage Collection

The design of the Go GC has changed over the years:

• Go 1.0, Stop the world mark sweep collector based heavily on tcmalloc.
• Go 1.2, Precise collector, wouldn't mistake big numbers (or big strings of text) for pointers.
• Go 1.3, Fully precise tracking of all stack values.
• Go 1.4, Mark and sweep now parallel, but still stop the world.
• Go 1.5, New GC design, focusing on latency over throughput.
• Go 1.6, GC improvements, handling larger heaps with lower latency.

Mark / Sweep

• All objects on the heap are turned WHITE and the write barrier is turned on.
• Scan Stack phase is about finding all the root objects and placing them in the queue.
  • All these root objects are turned GREY.
• Mark phase I is about popping a GREY object from the queue and scanning it.
  • If this GREY object points to a WHITE object, the WHITE object is added to the queue and marked GREY.
  • The popped GREY object is then turned BLACK to show it has been scanned.
  • The GC and the application are running concurrently.
• Mark phase II is about finding objects that were missed due to updates.
  • Rescan all the root objects again.
  • This scan should be quick but required for consistency.
• Sweep phase reclaims memory.
  • Left with either WHITE or BLACK objects. No more GREY objects.
  • WHITE objects are reclaimed while BLACK objects stay.

Write Barrier

The write barrier is in place to prevent a situation where a BLACK object (one that is processed) suddenly finds itself pointing to a WHITE object. This could happen if a goroutine changes (writes) a pointer inside a BLACK object to point to a WHITE object while both the program and the GC is running.

The write barrier is a little function that inspects the write of pointers when the GC is running. If it identifies such a write, the WHITE object is turned GREY and added to the queue.

Pacing

The GC starts a scan based on a feedback loop of information about the running program and the stress on the heap. It is the pacers job to make this decision. Once the decision is made to run, the amount of time the GC has to finish the scan is pre-determined. This time is based on the current size of the heap, the current live heap, and timing calculations about future heap usage while the GC is running.

The GC has a set of goroutines to perform the task of Mark and Sweep. The scheduler will provide these goroutines 25% of the available logical processor time. If your program is using 4 logical processors, that 1 entire logical processor will be given to the GC goroutines for exclusive use.

If the GC begins to believe that it can’t finish the collection within the decided amount of time, it will begin to recruit program goroutines to help. Those goroutines that are causing the slow down will be recruited to help.

Links

Pointer Mechanics

https://golang.org/doc/effective_go.html#pointers_vs_values
http://www.goinggo.net/2013/07/understanding-pointers-and-memory.html
http://www.goinggo.net/2014/12/using-pointers-in-go.html

Stacks

Contiguous Stack Proposal

Escape Analysis and Inlining

Go Escape Analysis Flaws
Compiler Optimizations

Garbage Collection

Tracing Garbage Collection
Go Blog - 1.5 GC
Go GC: Solving the Latency Problem
Concurrent garbage collection

Single Static Assignment Optimizations

GopherCon 2015: Ben Johnson - Static Code Analysis Using SSA
https://godoc.org/golang.org/x/tools/go/ssa
Understanding Compiler Optimization

Code Review

Pass by Value (Go Playground)
Sharing data I (Go Playground)
Sharing data II (Go Playground)
Stack vs Heap (Go Playground)
Stack grow (Go Playground)

Exercises

Exercise 1

Part A Declare and initialize a variable of type int with the value of 20. Display the address of and value of the variable.

Part B Declare and initialize a pointer variable of type int that points to the last variable you just created. Display the address of , value of and the value that the pointer points to.

Template (Go Playground) | Answer (Go Playground)

Exercise 2

Declare a struct type and create a value of this type. Declare a function that can change the value of some field in this struct type. Display the value before and after the call to your function.

Template (Go Playground) | Answer (Go Playground)

---

All material is licensed under the Apache License Version 2.0, January 2004.