CONCURRENCY MODELS: GO CONCURRENCY MODEL BY VASYL NAKVASIUK, 2014 - - PowerPoint PPT Presentation

▶
concurrency models go concurrency model
SMART_READER_LITE
LIVE PREVIEW

CONCURRENCY MODELS: GO CONCURRENCY MODEL BY VASYL NAKVASIUK, 2014 - - PowerPoint PPT Presentation

Nov 13, 2022 227 likes •734 views

CONCURRENCY MODELS: GO CONCURRENCY MODEL BY VASYL NAKVASIUK, 2014 KYIV GO MEETUP #1 CONCURRENCY AND PARALLELISM CONCURRENCY AND PARALLELISM THE WORLD IS OBJECT ORIENTED THE WORLD IS PARALLEL THE WORLD IS OBJECT ORIENTED AND PARALLEL

slide-1
SLIDE 1

CONCURRENCY MODELS: GO CONCURRENCY MODEL

BY VASYL NAKVASIUK, 2014

KYIV GO MEETUP #1

slide-2
SLIDE 2

CONCURRENCY AND PARALLELISM

slide-3
SLIDE 3

CONCURRENCY AND PARALLELISM

THE WORLD IS OBJECT ORIENTED THE WORLD IS PARALLEL THE WORLD IS OBJECT ORIENTED AND PARALLEL

slide-4
SLIDE 4

CONCURRENCY AND PARALLELISM

Concurrency is a composition of independently computing things. Parallelism is a simultaniuse execution of multiple things. Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once.

Rob Pike, "Concurrency Is Not Parallelism", 2012

slide-5
SLIDE 5

CONCURRENCY AND PARALLELISM

CONCURRENT CONCURRENT AND PARALLEL PARALLEL

slide-6
SLIDE 6

CONCURRENCY AND PARALLELISM

USERS SOFTWARE MULTICORE

slide-7
SLIDE 7

CONCURRENCY AND PARALLELISM

MOORE’S LAW CPU: WHY ARE STALLED?

slide-8
SLIDE 8

CONCURRENCY AND PARALLELISM

SHARED MEMORY

slide-9
SLIDE 9

CONCURRENCY AND PARALLELISM

DISTRIBUTED MEMORY

slide-10
SLIDE 10

CONCURRENCY AND PARALLELISM

CONCURRENT SOFTWARE FOR A CONCURRENT WORLD DISTRIBUTED SOFTWARE FOR A DISTRIBUTED WORLD FAULT-TOLERANT SOFTWARE FOR AN UNPREDICTABLE WORLD

slide-11
SLIDE 11

THREADS AND LOCKS

slide-12
SLIDE 12

THREADS AND LOCKS

PROCESS THREAD

slide-13
SLIDE 13

public class Counting { public static void main(String[] args) throws InterruptedException { class Counter { private int count = 0; public void increment() { ++count; } public int getCount() { return count; } } final Counter counter = new Counter(); class CountingThread extends Thread { public void run() { for(int x = 0; x < 10000; ++x) counter.increment(); } } CountingThread t1 = new CountingThread(); CountingThread t2 = new CountingThread(); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(counter.getCount()); } }

COUNT != 20000

slide-14
SLIDE 14

THREADS AND LOCKS: PROBLEMS

HEISENBUGS RACE CONDITIONS

slide-15
SLIDE 15

THREADS AND LOCKS: LOCKS

MUTUAL EXCLUSION (MUTEX) SEMAPHORE HIGH-LEVEL SYNCHRONIZATION

slide-16
SLIDE 16

THREADS AND LOCKS: LOCKS

class Counter { private int count = 0; public synchronized void increment() { ++count; } public int getCount() { return count; } }

COUNT == 20000

slide-17
SLIDE 17

THREADS AND LOCKS: MULTIPLE LOCKS

“DINING PHILOSOPHERS” PROBLEM DEADLOCK!

slide-18
SLIDE 18

THREADS AND LOCKS: MULTIPLE LOCKS

DEADLOCK SELF-DEADLOCK LIVELOCK

slide-19
SLIDE 19

THREADS AND LOCKS: MULTIPLE LOCKS

“DINING PHILOSOPHERS” SOLUTIONS

RESOURCE HIERARCHY SOLUTION ARBITRATOR SOLUTION TRY LOCK

slide-20
SLIDE 20

THREADS AND LOCKS: WIKIPEDIA PARSER

WHAT’S THE MOST COMMONLY USED WORD ON WIKIPEDIA?

“PRODUCER-CONSUMER” PATTERN

slide-21
SLIDE 21

THREADS AND LOCKS: WRAP-UP

STRENGTHS

“CLOSE TO THE METAL” EASY INTEGRATION

WEAKNESSES

ONLY SHARED-MEMORY ARCHITECTURES HARD TO MANAGE HARD TO TESTING

slide-22
SLIDE 22

FUNCTIONAL PROGRAMMING

slide-23
SLIDE 23

FUNCTIONAL PROGRAMMING

IMMUTABLE STATE EFFORTLESS PARALLELISM

slide-24
SLIDE 24

FUNCTIONAL PROGRAMMING: SUM

(defn reduce-sum [numbers] (reduce (fn [acc x] (+ acc x)) 0 numbers)) (defn sum [numbers] (reduce + numbers)) (ns sum.core (:require [clojure.core.reducers :as r])) (defn parallel-sum [numbers] (r/fold + numbers))

slide-25
SLIDE 25

FUNCTIONAL PROGRAMMING: WIKIPEDIA PARSER

(defn count-words-sequential [pages] (frequencies (mapcat get-words pages))) (pmap #(frequencies (get-words %)) pages) (defn count-words-parallel [pages] (reduce (partial merge-with +) (pmap #(frequencies (get-words %)) pages)))

slide-26
SLIDE 26

FUNCTIONAL PROGRAMMING: DIVIDE AND CONQUER

(ns sum.core (:require [clojure.core.reducers :as r])) (defn parallel-sum [numbers] (r/fold + numbers))

slide-27
SLIDE 27

FUNCTIONAL PROGRAMMING: REFERENTIAL TRANSPARENCY

(+ (+ 1 2) (+ 3 4)) → (+ (+ 1 2) 7) → (+ 3 7) → 10 (+ (+ 1 2) (+ 3 4)) → (+ 3 (+ 3 4)) → (+ 3 7) → 10

slide-28
SLIDE 28

FUNCTIONAL PROGRAMMING: WRAP-UP

STRENGTHS

REFERENTIAL TRANSPARENCY NO MUTABLE STATE

WEAKNESSES

LESS EFFICIENT THAN ITS IMPERATIVE EQUIVALENT

slide-29
SLIDE 29

SOFTWARE TRANSACTIONAL MEMORY (STM)

slide-30
SLIDE 30

STM

MUTABLE STATE CAS (COMPARE-AND-SWAP) TRANSACTIONS ARE ATOMIC, CONSISTENT, AND ISOLATED

slide-31
SLIDE 31

STM

(defn transfer [from to amount] (dosync (alter from - amount) (alter to + amount))) => (def user1 (ref 1000)) => (def user2 (ref 2000)) => (transfer user2 user1 100) 1100 => @checking 1100 => @savings 1900

slide-32
SLIDE 32

STM: WRAP-UP

STRENGTHS

EASY TO USE

WEAKNESSES

RETRYING TRANSACTIONS SPEED

slide-33
SLIDE 33

ACTOR MODEL

slide-34
SLIDE 34

ACTOR MODEL

CARL HEWITT (1973) ACTOR – LIGHTWEIGHT PROCESS MESSAGES AND MAILBOXES

slide-35
SLIDE 35

ACTOR MODEL

defmodule Talker do def loop do receive do {:greet, name} -> IO.puts("Hello, #{name}") {:bye, status, name} -> IO.puts("Bye, #{status} #{name}") end loop end end pid = spawn(&Talker.loop/0) send(pid, {:greet, "Gopher"}) send(pid, {:bye, "Mrs", "Pike"}) sleep(1000) Hello, Gopher Bye, Mrs Pike

slide-36
SLIDE 36

ACTOR MODEL

PATTERN MATCHING BIDIRECTIONAL COMMUNICATION NAMING PROCESSES SUPERVISING A PROCESS

slide-37
SLIDE 37

ACTOR MODEL

DISTRIBUTION CLUSTER REMOTE MESSAGING

slide-38
SLIDE 38

ACTOR MODEL: WRAP-UP

STRENGTHS

MESSAGING AND ENCAPSULATION FAULT TOLERANCE DISTRIBUTED PROGRAMMING

WEAKNESSES

WE STILL HAVE DEADLOCKS OVERFLOWING AN ACTOR’S MAILBOX

slide-39
SLIDE 39

COMMUNICATING SEQUENTIAL PROCESSES (CSP)

slide-40
SLIDE 40

COMMUNICATING SEQUENTIAL PROCESSES (CSP)

SIR CHARLES ANTONY RICHARD HOARE (1978) SIMILAR TO THE ACTOR MODEL FOCUS ON THE CHANNELS

Rob Pike

Do not communicate by sharing memory, instead share memory by communicating

slide-41
SLIDE 41

CSP

GOROUTINES

IT'S VERY CHEAP IT'S NOT A THREAD COOPERATIVE SCHEDULER VS PREEMPTIVE SCHEDULER MULTITHREADING, MULTICORE

go func() @rob_pike

Just looked at a Google-internal Go server with 139K goroutines serving over 68K active network connections. Concurrency wins.

slide-42
SLIDE 42

CSP: CHANNELS

CHANNELS – THREAD-SAFE QUEUE CHANNELS – FIRST CLASS OBJECT

// Declaring and initializing var ch chan int ch = make(chan int) // or ch := make(chan int) // Buffering ch := make(chan int, 100) // Sending on a channel ch <- 1 // Receiving from a channel value = <- ch

slide-43
SLIDE 43

CSP

EXAMPLE

func main() { jobs := make(chan Job) done := make(chan bool, len(jobList)) go func() { for _, job := range jobList { jobs <- job // Blocks waiting for a receive } close(jobs) }() go func() { for job := range jobs { // Blocks waiting for a send fmt.Println(job) // Do one job done <- true } }() for i := 0; i < len(jobList); i++ { <-done // Blocks waiting for a receive } }

slide-44
SLIDE 44

CSP: WRAP-UP

STRENGTHS

FLEXIBILITY NO CHANNEL OVERFLOWING

WEAKNESSES

WE CAN HAVE DEADLOCKS

slide-45
SLIDE 45

GO CONCURRENCY: WRAP-UP

STRENGTHS

MESSAGE PASSING (CSP) STILL HAVE LOW-LEVEL SYNCHRONIZATION DON'T WORRY ABOUT THREADS, PROCESSES

WEAKNESSES

NIL

slide-46
SLIDE 46

WRAPPING UP

THE FUTURE IS IMMUTABLE THE FUTURE IS DISTRIBUTED THE FUTURE WITH BIG DATA USE RIGHT TOOLS DON'T WRITE DJANGO/ROR BY GO/CLOJURE/ERLANG

slide-47
SLIDE 47

LINKS

BOOKS: “Seven Concurrency Models in Seven Weeks”, 2014, by Paul Butcher “Communicating Sequential Processes”, 1978, C. A. R. Hoare OTHER: “Concurrency Is Not Parallelism” by Rob Pike ( ) “Modern Concurrency” by Alexey Kachayev ( ) A Tour of Go ( ) http://goo.gl/hyFmcZ http://goo.gl/Tr5USn http://tour.golang.org/

slide-48
SLIDE 48

THE END

THANK YOU FOR ATTENTION!

Vasyl Nakvasiuk Email: vaxxxa@gmail.com Twitter: @vaxXxa Github: vaxXxa

THIS PRESENTATION:

Source: https://github.com/vaxXxa/talks Live: http://vaxXxa.github.io/talks