How not to Go wrong with concurrency – Artemiy Ryabinkov

Transcript

1. How not to Go wrong with concurrency Artemiy Ryabinkov
3. Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines. golang.org/doc/
4. Two Models of Communication Shared Memory Message Passing (CSP and Actor Model) Locks Mutexes Implicit communication Messages Channels Explicit communication
5. Do not communicate by sharing memory; instead, share memory by communicating.
6. Communicating Sequential Processes
7. Application Shared Memory Message Passing Mutex RWMutex Wait Chan Chan + other ops Lib Docker 9 0 3 5 2 2 Kubernetes 6 2 0 3 6 0 etcd 5 0 0 10 5 1 CockroachDB 4 3 0 5 0 0 gRPC 2 0 0 6 2 1 BoltDB 2 0 0 0 1 0 Total 28 5 3 29 16 4 Blocking Bug Causes https://songlh.github.io/paper/go-study.pdf
8. https://songlh.github.io/paper/go-study.pdf Our study found that message passing does not necessarily make multithreaded programs less error-prone than shared memory. In fact, message passing is the main cause of blocking bugs.
9. Concurrency Parallelism
11. Amdahl’s law
12. Speedup( P processors ) = Time( 1 processor ) Time( P processors ) F = inherently sequential fraction of the computation 1+(P-1)F S MAX = P
13. F = 1% F = 5% F = 10% Max Speedup Processors 40 32 24 16 8 8 16 24 32 40 48 56 64
14. Some programs are nicer even if not parallel at all
15. Synchronization Context Switch Network Request Memory Allocation Disk Read/Write Garbage Collection
16. CPU Bound IO Bound Progress is limited by CPU speed Progress is limited by I/O subsystem speed
17. Core Cache Line Memory
18. False Cache-Line Sharing
19. Core 0 Cache Line Core 1 Cache Line Memory
21. Scheduler
22. UserSpace Scheduler OS Scheduler CPU
23. Cooperative multitasking Preemptive multitasking Process makes switch decision Process can monopolize processor Effective context switch Scheduler makes switch decision Prevents monopolizing Overheads involved with interrupts Fair timeslice
24. UserSpace Scheduler OS Scheduler CPU Preemptive Preemptive
25. UserSpace Scheduler OS Scheduler CPU Preemptive Cooperative Gooperative
26. runtime.GOMAXPROCS(1) x := 0 go func() { for { x++ } }() time.Sleep(500 * time.Millisecond) fmt.Println(x)
27. runtime.GOMAXPROCS(1) x := 0 go func() { for { runtime.Gosched() x++ } }() time.Sleep(500 * time.Millisecond) fmt.Println(x)
28. runtime.morestack() -> runtime.newstack() runtime.Gosched() locks network I/O syscalls Goroutine preemption points Cyrill Lashkevich - Go Scheduler
29. Race Conditions
30. a += 1
31. a += 1 tmp = a + 1 a = tmp ⇔
32. a += 1 if a == 1 { criticalSection() } a += 1 if a == 1 { criticalSection() }
33. tmp = a+1 a = tmp if a == 1 { criticalSection() } tmp = a+1 a = tmp if a == 1 { criticalSection() }
34. var mx sync.Mutex // .. mx.Lock() tmp = a + 1 a = tmp if a == 1 { criticalSection() } mx.Unlock()
35. mx.Lock() tmp = a + 1 a = tmp mx.Unlock() atomic.AddInt64(&a, 1) ⇔
36. atomic.AddInt64(&a, 1) val = atomic.LoadInt64(&a)
37. func setup() { a = "hello, world" done = true } var once sync.Once func doprint() { if !done { once.Do(setup) } print(a) }
38. func setup() { done = true a = "hello, world" } var once sync.Once func doprint() { if !done { once.Do(setup) } print(a) }
39. The Go Memory Model https://golang.org/ref/mem Benign Data Races: What Could Possibly Go Wrong? https://intel.ly/1MaL4rD
40. Deadlock
41. mx1.Lock() mx2.Lock() mx2.Lock() mx1.Lock()
42. mx1.Lock() mx2.Lock() mx1.Lock() mx2.Lock()
43. m.Lock() m.Unlock() request <- ch m.Lock() ch <- request m.Unlock()
44. The Deadlock Empire https://deadlockempire.github.io/
45. Race Conditions Deadlock/Livelock Starvation False Sharing/Lock Contention Sort of Problems
46. Race Detector go test -race
47. Requires test coverage Stores history of N memory access Reports no false positives. May miss data races Limits of Race Detector
48. ThreadSanitizerAlgorithm https://bit.ly/2WctkVx Data Race Detector: official docs https://bit.ly/2TXlTEe
49. Block profile go test -run=XXX -bench=. --blockprofile=block.out go tool pprof http://.../debug/pprof/block
50. Let's Code On
51. func call(ctx context.Context, requests []T) error { for _, req := range requests { err := send(ctx, req) if err != nil { return err } } return nil }
52. func call(ctx context.Context, requests []T) error { errCh := make(chan error, 1) var wg sync.WaitGroup for _, req := range requests { go func() { wg.Add(1) if err = send(ctx, req); err != nil { errCh <- err } wg.Done() }() } wg.Wait() close(errCh) return <-errCh }
53. for _, req := range requests { go func() { wg.Add(1) if err = send(ctx, req); err != nil { errCh <- err } wg.Done() }() } wg.Wait() close(errCh) return <-errCh
54. for _, req := range requests { go func() { wg.Add(1) if err = send(ctx, req); err != nil { errCh <- err } wg.Done() }() } wg.Wait() close(errCh) return <-errCh
55. wg.Add(len(requests)) for _, req := range requests { go func() { if err = send(ctx, req); err != nil { errCh <- err } wg.Done() }() } wg.Wait() close(errCh) return <-errCh
56. wg.Add(len(requests)) for _, req := range requests { go func() { if err = send(ctx, req); err != nil { errCh <- err } wg.Done() }() } wg.Wait() close(errCh) return <-errCh
57. wg.Add(len(requests)) for _, req := range requests { go func(req T) { if err = send(ctx, req); err != nil { errCh <- err } wg.Done() }(req) } wg.Wait() close(errCh) return <-errCh
58. errCh := make(chan error, 1) for _, req := range requests { go func() { if err = send(ctx, req); err != nil { errCh <- err } }() } ... return <-errCh
59. errCh := make(chan error, 1) for _, req := range requests { go func() { if err = send(ctx, req); err != nil { errCh <- err } }() } return <-errCh
60. errCh := make(chan error, len(requests)) for _, req := range requests { go func() { if err = send(ctx, req); err != nil { errCh <- err } }() } return <-errCh
61. func call(ctx context.Context, requests []T) error { errCh := make(chan error, len(requests)) var wg sync.WaitGroup wg.Add(len(requests)) for _, req := range requests { go func(req string) { if err = send(ctx, req); err != nil { errCh <- err } wg.Done() }(req) } wg.Wait() close(errCh) return <-errCh } Dave Cheney: Concurrency made easy
62. golang.org/x/sync/errgroup
63. func call(ctx context.Context, requests []T) error { g, ctx := errgroup.WithContext(ctx) for _, req := range requests { req := req g.Go(func() error { return send(ctx, req) }) } return g.Wait() }
64. func call(ctx context.Context, requests []T) error { for _, req := range requests { err := send(ctx, req) if err != nil { return err } } return nil }
65. ctx := context.Background() g, ctx := errgroup.WithContext(ctx) g.Go(func() error { return DoA(ctx) }) g.Go(func() error { return DoB(ctx) }) err := g.Wait()
66. As Simple as Possible, but not Simpler Get to know your abstractions Explicit over implicit syncronization
67. Go ❤ Concurrency
68. Artemiy Ryabinkov github.com/furdarius getlag@ya.ru facebook.com/furdarius