Concurrency Patterns

Author:RyanStout
ConcurrencyAnoverviewofconcurrentprocessingmodels
Date:June22nd,2013
Wednesday, July 10, 13

singlecoreperformanceisn’tincreasinganymore
ConcurrencyModels
NoMoreFreeLunch

ConcurrencyModels
Question:Howdowetake
advantageoftheextracores?

ConcurrencyModels

ConcurrencyModels
Answer:Concurrency&Parallelism
A
Concurrent Parallel
B
Sequential
A
A
B
B
A B

•Onlydifficultwhensharingstate
•Hardtoreasonabout
•Raceconditions
•Deadlock
ConcurrencyModels
Problem:Parallelcanbedifficult

1.Processes
2.ThreadsandLocks
3.Evented-io
4.Vectorization/SIMD
5.ActorModel-Erlang,Celluloid,Akka
6.CSP-GoogleGo
7.SoftwareTransactionalMemory
Differentwaytodothingsatthesametime
ConcurrencyModels
Solution(sortof):
BetterConcurrencyModels

separatememorymodel
ConcurrencyModels
1.Processes

•Pros:
•Easy
•OShandleseverything
•Goodforstatelessoperations(Respondingtowebrequests)
•NoMemoryLeaks
• Cons:
•Communicationbetweenprocessesisdifficult
•Ramgetsusedforeachprocess
Thewayunixintended
ConcurrencyModels
1.Processes Process A
Thread
A
Process B
Thread
B

ConcurrencyModels
2.Threads

ConcurrencyModels
2.Threads
Process
Thread
A
Thread
B

require 'thread'
class ThreadExample
def initialize
@count = 0
@count_mutex = Mutex.new
# Start a few readers
threads = []
3.times do
threads << Thread.new do
read_values
end
end
threads.each(&:join)
end
...
ConcurrencyModels
2.Threaded/MutexExample
...
def read_values
loop do
@count_mutex.synchronize do
local_count = @count
# Get the "value"
local_count += rand(10)
@count = local_count
puts "Value: #{local_count}"
end
end
end
end
ThreadExample.new

SharedMemoryModel
•Pros:
•Lessramthanprocesses
• Cons:
•Manuallyhandlinglocks
•Deadlocks
•Non-determanistic
•HardtoDebug
thewayJavaintended
ConcurrencyModels
2.Threads

ConcurrencyModels
3.Evented-io
Process
Reactor
A
B
A

require 'socket'
server = TCPServer.open(host, port)
while client = server.accept
Thread.new do
line = client.gets
client.puts(line)
client.close
end
end
ConcurrencyModels
ThreadedEchoServer

require 'eventmachine'
class Echo < EventMachine::Connection
def receive_data(data)
send_data(data)
end
end
EventMachine.run {
EventMachine.connect '127.0.0.1', 8081, Echo
}
ConcurrencyModels
Evented-io-EchoServer

module ProxyConnection
def initialize(local_connection)
@local_connection = local_connection
end
@local_connection.send_data(data)
end
end
module ProxyServer
def post_init
# Make a connection to the remote server
@connection = EventMachine.connect 'www.zeebly.com', 80, ProxyConnection, self
end
@connection.send_data(data)
end
end
EventMachine::run do
EventMachine::start_server "127.0.0.1", 8080, ProxyServer
end
ConcurrencyModels
Evented-io-ProxyServer

Aformofcooperativemultitasking
•Pros:
•GreatforheavyIOwork
•Savesthreadswitchingcost
•GoodOSlevelsupport(epoll,kqueue)
• Cons:
•Longrunningoperationsblockallotheroperations
•Doesnotusemultiplecores
•Somewhatdifficulttoreasonabout
Libraries:EventMachine(ruby),Tornado(python),nodejs,libev(C)
thewaynginxintended-concurrent,notparallel
ConcurrencyModels
3.Evented-io Process
Reactor
A
B
A

ConcurrencyModels
Process
Data A
Data B
0.51 0.98 1.5 0.29 0.75 0.11
0.39 0.19 1.22 1.6 0.84 0.90
Instruction:
Multiply(A,B)

void MatrixMulOnHost(float* M, float* N, float* P, int Width) {
for (int i = 0; i < Width; ++i) {
for (int j = 0; j < Width; ++j) {
float sum = 0;
for (int k = 0; k < Width; ++k) {
float a = M[i * Width + k];
float b = N[k * Width + j];
sum += a * b;
}
P[i * Width + j] = sum;
}
}
}
ConcurrencyModels
ExampleMatrixMultiplication-C

__global__ void MatrixMulKernel(float* d_M, float* d_N, float* d_P, int Width) {
int row = threadIdx.y;
int col = threadIdx.x;
float P_val = 0;
for (int k = 0; k < Width; ++k) {
float M_elem = d_M[row * Width + k];
float N_elem = d_N[k * Width + col];
P_val += M_elem * N_elem;
}
d_p[row*Widthh+col] = P_val;
}
ConcurrencyModels
ExampleMatrixMultiplication-
CUDA

SIMD=SingleInstructionMultipleData
•Pros:
•Veryfastforsomeoperations(~50xspeedimporvementinsome
cases)
• Cons:
•Onlyworkswhenworkingwithvectordata
•Nostandardwaytoprogram(CUDA,OpenCL,SSE,BLAS)
•TimetocopydatabetweenCPUandGPUaddsup
thewayNvidiaintended
ConcurrencyModels

“Don’tcommunicatebysharingstate;share
statebycommunicating”
http://www.igvita.com/2010/12/02/concurrency-with-actors-goroutines-ruby/
ConcurrencyModels
5.&6.ActorModel&CSP

•Stateisencapsulatedin“Actors”
•Actorssendmessagestocommunicate
•Messagesareasynchronous
•Messagesbufferina“mailbox”
Libraries:Akka(scala),Celluloid(ruby),Erlang(builtin)
thewayErlangintended
ConcurrencyModels
5.ActorModel

ConcurrencyModels
5.ActorModel
Process
Actor A Actor B
Actor C

require 'actor'
ping = nil
ping = Actor.spawn do
loop do
msg = Actor.receive
puts "Ping #{msg}"
pong << (msg + 1)
end
end
...
ConcurrencyModels
ActorExample
...
pong = Actor.spawn do
loop do
msg = Actor.receive
puts "Ping #{msg}"
break if msg > 10000
ping << (msg + 1)
end
end
ping << 0

•Pros:
•Nodeadlocks(ifyoufollowtherules)
•Fairlyeasytoreasonabout
• Cons:
•Connectingactorsisdifficult
•Errorhandlingistricky
ConcurrencyModels
5.ActorModel

ConcurrencyModels
Process
A
C
6.CommunicatingSequentialProcesses
B
Channel A

•GoogleGo’sModel
•Variablesarealwaysthreadlocal
•Stateissharedbysizedchannels
•Functionscanberunasa“goroutine”
•Anonymousthreadofexecution
•Cannotbereferencedorjoined
•Communicationtakesplaceoverchannels
•Channelsaresizedsynchronizedbuffers,whichcanbe“closed”
thewaygoogleintended
ConcurrencyModels

•Pros:
•Easytoreasonabout
•Simplemodelfordistributingdataprocessingwork
•Simpletoimplementbyhand(sizedqueue’s)
•Cons:
•Canbeextracodeforsimplesynchrnoization
Libraries:GoogleGo(language),Agent(ruby)
thewaygoogleintended
ConcurrencyModels

•InActorwenametheActors
•InCSPwenamethecommunicationchannels
•Bothallowustokeepoutnon-determinism(ifwefollow
therules)
ConcurrencyModels
DifferencebetweenCSPandActor?

ConcurrencyModels

ConcurrencyModels
Process
Memory
Variable A
Block B
read
process
transactional write
Block A
read
process
transactional write

ConcurrencyModels
Process
Memory
Variable A
Block B
read
process
transactional write
Block A
read
process
transactional write
SUCCESS

ConcurrencyModels
Process
Memory
Variable A
Block B
read
process
transactional write
Block A
read
process
transactional write
SUCCESS FAIL

ConcurrencyModels
Process
Memory
Variable A
Block B
read
process
transactional write

ConcurrencyModels
Process
Memory
Variable A
Block B
read
process
transactional write
SUCCESS

•Pros:
•Easytoreasonabout
• Cons:
•Moreresourcecontention=worseperformance
•Inordertopreventcontention,wemustuseimmutabledata
structures--whichmakesitmoredifficulttoreasonaboutagain
thewayClojureintended
ConcurrencyModels

•FunctionalReactiveProgramming
ConcurrencyModels
8.BonusModel

ConcurrencyModels
WhichModelisBest?

•Dependsontheproblem
ConcurrencyModels
WhichModelisBest?

•Dependsontheproblem
•Dependsonthelanguage
ConcurrencyModels
WhichModelisBest?

•http://www.igvita.com/2010/12/02/concurrency-with-actors-goroutines-ruby/
•http://en.wikipedia.org/wiki/Dining_philosophers_problem
•DiningPhilosophersProblem-http://rosettacode.org/wiki/Dining_philosophers
ConcurrencyModels
MoreInfo

Author:RyanStout
Thanks!anyquestions?
Date:June22nd,2013

Concurrency Patterns

Recommended

Recommended

More Related Content

Similar to Concurrency Patterns

Similar to Concurrency Patterns (6)

More from ryanstout

More from ryanstout (8)

Recently uploaded

Recently uploaded (20)

Concurrency Patterns