better changes to language

Author: ardan-bkennedy

topics/go/language/pointers/README.md

@@ -109,10 +109,10 @@ https://godoc.org/golang.org/x/tools/go/ssa
 
 ## Code Review
 
-[Pass by Value](example1/example1.go) ([Go Playground](https://play.golang.org/p/ufunQgPsYA))  
-[Sharing data I](example2/example2.go) ([Go Playground](https://play.golang.org/p/g0Cs0FVpyi))  
+[Pass by Value](example1/example1.go) ([Go Playground](https://play.golang.org/p/JJMHWiZ9h9))  
+[Sharing data I](example2/example2.go) ([Go Playground](https://play.golang.org/p/y_FHIdUbAw))  
 [Sharing data II](example3/example3.go) ([Go Playground](https://play.golang.org/p/KRKrUCcTYe))  
-[Stack vs Heap](example4/example4.go) ([Go Playground](https://play.golang.org/p/jYkpV-zQ_o))  
+[Escape Analysis](example4/example4.go) ([Go Playground](https://play.golang.org/p/ObEFYdDVB2))  
 [Stack grow](example5/example5.go) ([Go Playground](https://play.golang.org/p/tpDOwBCvqW))  
 
 ## Exercises

topics/go/language/pointers/example1/example1.go

@@ -12,7 +12,7 @@ func main() {
 	// Display the "value of" and "address of" count.
 	println("count:\tValue Of[", count, "]\tAddr Of[", &count, "]")
 
-	// Pass the "value of" the variable count.
+	// Pass the "value of" the count.
 	increment(count)
 
 	println("count:\tValue Of[", count, "]\tAddr Of[", &count, "]")
@@ -23,7 +23,7 @@ func main() {
 //go:noinline
 func increment(inc int) {
 
-	// Increment the value.
+	// Increment the "value of" inc.
 	inc++
 	println("inc:\tValue Of[", inc, "]\tAddr Of[", &inc, "]")
 }

topics/go/language/pointers/example2/example2.go

@@ -11,20 +11,20 @@ func main() {
 	count := 10
 
 	// Display the "value of" and "address of" count.
-	println("count:\tValue Of[",count, "]\t\tAddr Of[", &count, "]")
+	println("count:\tValue Of[", count, "]\t\tAddr Of[", &count, "]")
 
-	// Pass the "address of" the variable count.
+	// Pass the "address of" count.
 	increment(&count)
 
-	println("count:\tValue Of[",count, "]\t\tAddr Of[", &count, "]")
+	println("count:\tValue Of[", count, "]\t\tAddr Of[", &count, "]")
 }
 
 // increment declares count as a pointer variable whose value is
 // always an address and points to values of type int.
 //go:noinline
 func increment(inc *int) {
 
-	// Increment the value that the "pointer points to". (de-referencing)
+	// Increment the "value of" count that the "pointer points to".
 	*inc++
-	println("inc:\tValue Of[",inc, "]\tAddr Of[", &inc, "]\tValue Points To[", *inc, "]")
-}
+	println("inc:\tValue Of[", inc, "]\tAddr Of[", &inc, "]\tValue Points To[", *inc, "]")
+}

topics/go/language/pointers/example4/example4.go

@@ -4,7 +4,7 @@
 // Escape Analysis Flaws:
 // https://docs.google.com/document/d/1CxgUBPlx9iJzkz9JWkb6tIpTe5q32QDmz8l0BouG0Cw/view
 
-// Sample program to show variables stay on or escape from the stack.
+// Sample program to teach the mechanics of escape analysis.
 package main
 
 // user represents a user in the system.
@@ -15,12 +15,13 @@ type user struct {
 
 // main is the entry point for the application.
 func main() {
-	stayOnStack()
-	escapeToHeap()
+	createUserV1()
+	createUserV2()
 }
 
-// stayOnStack shows how the variable does not escape.
-func stayOnStack() user {
+// createUserV1 creates a user value and passed
+// a copy back to the caller.
+func createUserV1() user {
 	u := user{
 		name:  "Bill",
 		email: "[email protected]",
@@ -29,8 +30,9 @@ func stayOnStack() user {
 	return u
 }
 
-// escapeToHeap shows how the variable does escape.
-func escapeToHeap() *user {
+// createUserV2 creates a user value and shares
+// the value with the caller.
+func createUserV2() *user {
 	u := user{
 		name:  "Bill",
 		email: "[email protected]",
@@ -44,49 +46,62 @@ func escapeToHeap() *user {
 
 go build -gcflags "-m -m"
 
-./example4.go:23: can inline stayOnStack as: func() user { u := user literal; return u }
-./example4.go:33: can inline escapeToHeap as: func() *user { u := user literal; return &u }
-./example4.go:17: can inline main as: func() { stayOnStack(); escapeToHeap() }
-./example4.go:18: inlining call to stayOnStack func() user { u := user literal; return u }
-./example4.go:19: inlining call to escapeToHeap func() *user { u := user literal; return &u }
+./example4.go:24: can inline createUserV1 as: func() user { u := user literal; return u }
+./example4.go:35: can inline createUserV2 as: func() *user { u := user literal; return &u }
+./example4.go:17: can inline main as: func() { createUserV1(); createUserV2() }
+./example4.go:18: inlining call to createUserV1 func() user { u := user literal; return u }
+./example4.go:19: inlining call to createUserV2 func() *user { u := user literal; return &u }
 ./example4.go:19: main &u does not escape
-./example4.go:39: &u escapes to heap
-./example4.go:39: 	from ~r0 (return) at ./example4.go:39
-./example4.go:37: moved to heap: u
+./example4.go:41: &u escapes to heap
+./example4.go:41: 	from ~r0 (return) at ./example4.go:41
+./example4.go:39: moved to heap: u
 
 // See the intermediate assembly phase before
 // generating the actual arch-specific assembly.
 
 go build -gcflags -S
 
-0x000f 00015 (pointers/example4/example4.go:18)	MOVQ	$4, DX
-0x0016 00022 (pointers/example4/example4.go:18)	LEAQ	go.string."[email protected]"(SB), CX
-0x001d 00029 (pointers/example4/example4.go:18)	MOVQ	$18, AX
-0x0024 00036 (pointers/example4/example4.go:18)	NOP
-0x0024 00036 (pointers/example4/example4.go:19)	MOVQ	$0, AX
-
+"".createUserV1 t=1 size=43 args=0x20 locals=0x0
+	0x0000 00000 example4.go:24		TEXT	"".createUserV1(SB), $0-32
+	0x0000 00000 example4.go:24		FUNCDATA	$0, gclocals·ff19ed39bdde8a01a800918ac3ef0ec7(SB)
+	0x0000 00000 example4.go:24		FUNCDATA	$1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
+	0x0000 00000 example4.go:18		LEAQ	go.string."Bill"(SB), AX
+	0x0007 00007 example4.go:30		MOVQ	AX, "".~r0+8(FP)
+	0x000c 00012 example4.go:30		MOVQ	$4, "".~r0+16(FP)
+	0x0015 00021 example4.go:18		LEAQ	go.string."[email protected]"(SB), AX
+	0x001c 00028 example4.go:30		MOVQ	AX, "".~r0+24(FP)
+	0x0021 00033 example4.go:30		MOVQ	$18, "".~r0+32(FP)
+	0x002a 00042 example4.go:30		RET
 
 // See the actual machine representation by using
 // the disasembler.
 
 go tool objdump -s main.main example4
 
-example4.go:17	0x2040	4883ec28		SUBQ $0x28, SP
-example4.go:17	0x2044	48896c2420		MOVQ BP, 0x20(SP)
-example4.go:17	0x2049	488d6c2420		LEAQ 0x20(SP), BP
-example4.go:19	0x204e	48c7042400000000	MOVQ $0x0, 0(SP)
-example4.go:19	0x2056	48c744240800000000	MOVQ $0x0, 0x8(SP)
+TEXT main.main(SB) example4.go
+	example4.go:17	0x104bf10	4883ec28		SUBQ $0x28, SP
+	example4.go:17	0x104bf14	48896c2420		MOVQ BP, 0x20(SP)
+	example4.go:17	0x104bf19	488d6c2420		LEAQ 0x20(SP), BP
+	example4.go:19	0x104bf1e	48c7042400000000	MOVQ $0x0, 0(SP)
+	example4.go:19	0x104bf26	48c744240800000000	MOVQ $0x0, 0x8(SP)
+	example4.go:19	0x104bf2f	48c744241800000000	MOVQ $0x0, 0x18(SP)
+	example4.go:19	0x104bf38	488d05c9a30100		LEAQ 0x1a3c9(IP), AX
+	example4.go:19	0x104bf3f	48890424		MOVQ AX, 0(SP)
+	example4.go:19	0x104bf43	48c744240804000000	MOVQ $0x4, 0x8(SP)
+	example4.go:19	0x104bf4c	488d05acb30100		LEAQ 0x1b3ac(IP), AX
+	example4.go:19	0x104bf53	4889442410		MOVQ AX, 0x10(SP)
+	example4.go:19	0x104bf58	48c744241812000000	MOVQ $0x12, 0x18(SP)
+	example4.go:20	0x104bf61	488b6c2420		MOVQ 0x20(SP), BP
+	example4.go:20	0x104bf66	4883c428		ADDQ $0x28, SP
+	example4.go:20	0x104bf6a	c3			RET
 
 // See a list of the symbols in an artifact with
 // annotations and size.
 
 go tool nm example4
 
-6cea0 R $f64.bfe62e42fefa39ef
-96d20 B __cgo_init
-96d28 B __cgo_notify_runtime_init_done
-96d30 B __cgo_thread_start
-4c8a0 T __rt0_amd64_darwin
-4af50 T _gosave
-4c8c0 T _main
+104bf70 T main.init
+10b2940 B main.initdone.
+104bf10 T main.main
+10983d0 B os.executablePath
 */