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

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Concurrency Patterns

Semelhante a Concurrency Patterns (6)

Mais de ryanstout

Mais de ryanstout (8)

Último

Último (20)

Concurrency Patterns