Go is a simple language with familiar syntax, but still, there are features, which implementation differs from most part of other programming languages. For example, the idea of CSP implemented as concurrency paradigm is used for parallelism in Go. It looks like a simple API, but under the hood, it is very complicated, but interesting mechanism. We will discuss, how it really works. (Slides from the speech on Kharkiv Go meetup 14 Sep 2019)

1. Concurrency under the hood
by Denys Goldiner

2. Concurrency under the hood
by Denys Goldiner

3. Practical concurrency
by Denys Goldiner

4. Practical concurrency
and some theory behind it
by Denys Goldiner

5. What is concurrency?
- asynchrony
- goroutines
- synchronization
- shared memory
- message communication
- execution planning
- scheduler

6. Questions I had in practice
- is sync.Mutex absolutely safe?
- how much does shared memory cost?
- what is the secret of a nil channel?
- is channel absolutely safe?
- how to plan execution?
- how to rule the concurrency?
- how many goroutines do you need?

7. Is sync.Mutex absolutely safe?

8. Data race with mutex
func main() {
var wg sync.WaitGroup
ctx, cancel := context.WithCancel(context.Background())
wg.Add(2)
go checkCtxErr(&wg, ctx)
go checkCtxVal(&wg, ctx)
time.Sleep(1 * time.Second)
cancel()
wg.Wait()
}

9. Data race with mutex
func checkCtxErr(wg *sync.WaitGroup, ctx context.Context) {
defer wg.Done()
for {
select {
case <-ctx.Done():
return
default:
if err := ctx.Err(); err != nil {
return
}
}
}
}

10. Data race with mutex
func checkCtxVal(wg *sync.WaitGroup, ctx context.Context) {
defer wg.Done()
expectedCtx, _ := context.WithCancel(context.Background())
for {
select {
case <-ctx.Done():
return
default:
if reflect.DeepEqual(expectedCtx, ctx) {
return
}
}
}
}

11. Data race with mutex
WARNING: DATA RACE
- Read by goroutine 7:
- reflect.deepValueEqual()
- reflect.DeepEqual()
- main.checkCtxVal()
- Previous write by goroutine 6:
- sync/atomic.CompareAndSwapInt32()
- sync.(*Mutex).Lock()
- context.(*cancelCtx).Done()
- main.checkCtxErr()

12. Data race with mutex
type cancelCtx struct {
Context
mu sync.Mutex
done chan struct{}
children map[canceler]struct{}
err error
}
func (c *cancelCtx) Err() error {
c.mu.Lock()
err := c.err
c.mu.Unlock()
return err
}

13. Be careful with reflect!

14. How much does shared memory cost?

15. False sharing, cache invalidation (core i7-9xxx)
L3 cache
L2 cache
L2 cache Main
Memory
core1core2core3core4
L1 I-cache
L1 D-cache
T0
T1
L1 I-cache
L1 D-cache
T0
T1
L2 cache
L1 I-cache
L1 D-cache
T0
T1
L2 cache
L1 I-cache
L1 D-cache
T0
T1

16. False sharing, cache invalidation
func main() {
arr := make([]int, 1000)
wg := sync.WaitGroup{}
wg.Add(len(arr))
for i := 0; i < len(arr); i++ {
go func(wg *sync.WaitGroup, i int) {
arr[i] = i * i
wg.Done()
}(&wg, i)
}
wg.Wait()
}

17. Map + sync.RWMutex
type safeMap struct {
data map[int]struct{}
sync.RWMutex
}
func (sm *safeMap) check(v int) bool {
sm.RLock()
_, ok := sm.data[v]
sm.RUnlock()
return ok
}

18. Map + sync.RWMutex
func mapUse(n int) {
var sm = &safeMap{data: map[int]struct{}{0: {}, 1: {}, 2: {}}}
var wg sync.WaitGroup
wg.Add(n)
for i := 0; i < n; i++ {
go func(wg *sync.WaitGroup) {
_ = sm.check(i % 3)
wg.Done()
}(&wg)
}
wg.Wait()
}

19. Map + mutex vs sync.Map
cores
iterations
map + sync.RWMutex
sync.Map

20. Sync.Map use cases
- stable keys
- once written, many times read
- many threads

21. How to avoid false sharing?

22. Use message communication

23. Using message communication
func communication(arr []int) {
ch := make(chan update)
for i := 0; i < len(arr); i++ {
go func(ch chan update, i int) {
ch <- update{id: i, val: i * i}
}(ch, i)
}
for j := 0; j < len(arr); j++ {
iu := <-ch
arr[iu.id] = iu.val
}
}

24. What is the secret of a nil channel?

25. Nil channel
func main() {
ch1 := make(chan struct{})
ch2 := make(chan struct{})
var wg sync.WaitGroup
wg.Add(1)
go fanIn(&wg, ch1, ch2)
close(ch1)
time.Sleep(1 * time.Second)
close(ch2)
wg.Wait()
}

26. Nil channel
func fanIn(wg *sync.WaitGroup, ch1, ch2 <-chan struct{}) {
defer wg.Done()
var b1, b2 bool
for !b1 || !b2 {
select {
case _, ok := <-ch1:
if !ok { b1 = true }
fmt.Println("case 1")
case _, ok := <-ch2:
if !ok { b2 = true }
fmt.Println("case 2")
}
}
}

27. Nil channel
- case 1
- case 1
- case 1
- case 1
- ...
- case 1
- case 1
- case 1
- case 1
- case 2
- Process finished with exit code 0

28. Nil channel
func fanInUpgrade(wg *sync.WaitGroup, ch1, ch2 <-chan struct{}) {
defer wg.Done()
for ch1 != nil || ch2 != nil {
select {
case _, ok := <-ch1:
if !ok { ch1 = nil }
fmt.Println("case 1")
case _, ok := <-ch2:
if !ok { ch2 = nil }
fmt.Println("case 2")
}
}
}

29. Nil channel
- case 1
- case 2
- Process finished with exit code 0

30. Is channel absolutely safe?

31. Data race with channel
func main() {
ch := make(chan struct{})
go func() {
<-ch
}()
ch = nil
}
// data race

32. Data race with channel
func main() {
ch := make(chan struct{})
go func(ch chan struct{}) {
<-ch
}(ch)
ch = nil
}
// no data race

33. Data race with channel
func main() {
ch := make(chan struct{})
go func(ch *chan struct{}) {
<-*ch
}(&ch)
ch = nil
}
// data race

34. Channels
type hchan struct {
qcount uint // total data in the queue
dataqsiz uint // size of the circular queue
buf unsafe.Pointer // points to an array of dataqsiz elements
elemsize uint16
closed uint32
elemtype *_type // element type
sendx uint // send index
recvx uint // receive index
recvq waitq // list of recv waiters
sendq waitq // list of send waiters
lock mutex
}

35. Data race with channel
func makechan(t *chantype, size int) *hchan {
…
}
func makemap(t *maptype, hint int, h *hmap) *hmap {
…
}
func makeslice(et *_type, len, cap int) unsafe.Pointer {
…
}

36. Data race with channel
func main() {
ch := make(chan struct{})
go func(ch chan struct{}) {
ch = nil
}(ch)
log.Println(ch == nil) // false
}
func main() {
ch := make(chan struct{})
go func(ch chan struct{}) {
log.Println(ch == nil) // false
}(ch)
ch = nil
}

37. Take it in mind using nil in select

38. Data race with data from channel
func dataRace() {
ch := make(chan *int)
go func() {
b := <-ch
*b++
}()
var a = 5
ch <- &a
a++
}

39. Pay attention to pointers

40. How to plan execution?

41. Scheduler (execution planning)
- processor threads
- OS threads
- scheduler
- context switch
- software threads

42. What is an execution context?
It’s a number of registers needed to restore the thread
execution:
- Program Counter (PC)
- Stack Pointer (SP)
- …

43. What is an execution context?
- context switch is not for free!
- we need a predictable execution context switch

44. Statement of a problem
- CPU-bound (working) - MAXIMIZE
- workload for all available threads - MAXIMIZE
- IO-bound (waiting) - MINIMIZE
- execution context switching - MINIMIZE

45. We need our own scheduler

46. Goroutine execution
M1
G1
P1
G2 G3 G4
Core
LRQ

47. System calls planning
M2
G2
P1
G3 G4
Core
LRQ
M1
G1

48. System calls planning
M2
G2
P1
G3 G4
Core
LRQ
M1
G1

49. Parallelism
M2
G4
P2
G5 G6
LRQ
M1
G1
P1
G2 G3
LRQ
GRQ
G7

50. Work steal
M2
G4
P2
G5 G6
LRQ
M1
P1
LRQ
GRQ
G7

51. - 1/61 off the time, check global queue
- check local queue
- try to steal half of work from other P
- check the global queue
- poll network
Work steal & GRQ

52. Work steal
M2
G4
P2
G5 G6
LRQ
M1
P1
LRQ
GRQ
G7

53. Work steal
M1
G6
P1
LRQ
GRQ
G7
M2
G4
P2
G5
LRQ

54. Work steal
M2
G5
P2
LRQ
M1
P1
LRQ
GRQ
G7

55. Work steal
M2
G5
P2
LRQ
M1
G7
P1
LRQ
GRQ

56. How to rule the concurrency?

57. Channels and FIFO
- FIFO read goroutine queue
- FIFO write goroutine queue
- FIFO buffer

58. Channels and FIFO
- FIFO read goroutine queue
- FIFO write goroutine queue
- FIFO buffer

59. Context switch conditions
- GC
- system calls (blocking / non-blocking / Cgo)
- function calls
- goroutine creation
- synchronization operations
- special function runtime.Gosched()
It means other goroutines might start execution

60. GOMAXPROCS
- sets P number
- for go run
- for tests (go test -cpu <number>)

61. How many goroutines do you need?

62. How many goroutines do you need?
- small amount of goroutines is bad
- huge amount of goroutines is bad

63. How many goroutines do you need?
- type of work (IO / CPU bound)
- how many blocking operations do you have
- how many threads do you have
- how much garbage does your program produce

64. The amount of goroutines is an empirical
value

65. Bonus: 7 steps to effective concurrency
- finish synchronous version of the program
- write benchmarks to measure results
- optimize synchronous implementation
- check if your solution fits for concurrency
- make your code concurrent
- measure results
- optimize concurrent implementation

66. Links
- https://habr.com/ru/post/338718/
- https://www.ardanlabs.com/blog/2018/08/scheduling-in-go-part1.html
- https://medium.com/@riteeksrivastava/a-complete-journey-with-goroutines-8472630c7f5c
- https://www.youtube.com/watch?v=t9bEg2A4jsw