GPars Groovy Parallel Systems Václav Pech

About Passionate programmer Open source software author Concurrency enthusiast Technology evangelist @ JetBrains JetBrains Academy member http://www.jroller.com/vaclav http://twitter.com/vaclav_pech

Passionate programmer

Open source software author

Concurrency enthusiast

Technology evangelist @ JetBrains

JetBrains Academy member

http://www.jroller.com/vaclav

http://twitter.com/vaclav_pech

GPars Nov 2008 – Sep 2009 as GParallelizer Since Sep 2009 GPars @Codehaus 5 commiters Tight relation with the Groovy team

Nov 2008 – Sep 2009 as GParallelizer

Since Sep 2009

GPars

@Codehaus

5 commiters

Tight relation with the Groovy team

Agenda Why? What? How?

Why?

What?

How?

Pantha rei Entering a new era!

Entering a new era!

We’re quad core already Beware: More cores to come shortly!

SW is being late to the game Dead-locks Live-locks Missed writes Race conditions The Root Cause Shared Mutable State

Dead-locks

Live-locks

Missed writes

Race conditions

The Root Cause

Shared Mutable State

Lock and synchronize Multithreaded programs today work mostly by accident!

Multithreaded programs today work mostly

by accident!

Can we do better? STM Dataflow CSP Actors (message passing) Agents Fork/Join Parallel Arrays …

STM

Dataflow

CSP

Actors (message passing)

Agents

Fork/Join

Parallel Arrays

…

GPars Aims Easy concurrency through Promising concurrency concepts Natural and elegant DSLs Flexible Groovy meta-programming

Easy concurrency through

Promising concurrency concepts

Natural and elegant DSLs

Flexible Groovy meta-programming

Toolset Fork/Join Actors Collections Dataflow Safe

Parallelizer doParallel { forkJoinPool -> images. findAllParallel {it.contains me} . collectParallel {convert it} . groupByParallel {it.size()} } Important: Side-effect-free functions only!

doParallel { forkJoinPool ->

images. findAllParallel {it.contains me}

. collectParallel {convert it}

. groupByParallel {it.size()}

}

Important:

Side-effect-free functions only!

Transparently parallel doParallel { images. makeTransparent() . findAll {it.contains me} . collect {convert it} . groupBy {it.size()} }

doParallel {

images. makeTransparent()

. findAll {it.contains me}

. collect {convert it}

. groupBy {it.size()}

}

Parallelize existing code buyBargain stocks. makeTransparent() def buyBargain(stocks) { buy stocks. findAll { it.download().price < 50 } } Use with CAUTION!

buyBargain stocks. makeTransparent()

def buyBargain(stocks) {

buy stocks. findAll {

it.download().price < 50

}

}

Use with CAUTION!

Functional flavor Map / Reduce map, reduce, filter, min, max, sum, … (1..n).parallel.filter{it%2==0} .map{it ** 2} .reduce{a, b -> a + b}

Map / Reduce

map, reduce, filter, min, max, sum, …

(1..n).parallel.filter{it%2==0}

.map{it ** 2}

.reduce{a, b -> a + b}

Call closures asynchronously def isSelfPortrait = {image -> image.contains me} def flag = isSelfPortrait. call (img1) def future = isSelfPortrait. callAsync (img1) … def flag = future.get()

def isSelfPortrait = {image -> image.contains me}

def flag = isSelfPortrait. call (img1)

def future = isSelfPortrait. callAsync (img1)

…

def flag = future.get()

Asynchronous closures def resize = {img -> img.resize(64, 64)} def fastResize = resize. async() def resized = images.collect fastResize … createAlbum resized*.get()

def resize = {img -> img.resize(64, 64)}

def fastResize = resize. async()

def resized = images.collect fastResize

…

createAlbum resized*.get()

Fork/Join Orchestration protected void compute() { long count = 0; file.eachFile { if (it.isDirectory()) { println &quot;Forking a thread for $it&quot; forkOffChild (new FileCounter(it)) } else { count++ } } setResult (count + ( childrenResults ?.sum() ?: 0)) } Waits for children without blocking the thread!

protected void compute() {

long count = 0;

file.eachFile {

if (it.isDirectory()) {

println &quot;Forking a thread for $it&quot;

forkOffChild (new FileCounter(it))

} else {

count++

}

}

setResult (count + ( childrenResults ?.sum() ?: 0))

}

GroovyDSL – IntelliJ IDEA CE

Dataflow Concurrency No race-conditions No live-locks Deterministic deadlocks Completely deterministic programs BEAUTIFUL code (Jonas Bonér)

No race-conditions

No live-locks

Deterministic deadlocks

Completely deterministic programs

BEAUTIFUL code

(Jonas Bonér)

Dataflow Variables start { z << x.val + y.val } start { x << 40 } start { y << 2 } assert 42 == z.val Single-assignment variables with blocking read

start { z << x.val + y.val }

start { x << 40 }

start { y << 2 }

assert 42 == z.val

Single-assignment variables

with blocking read

DataFlows def df = new DataFlows () start { df .z = df .x + df .y } start { df .x = 10 } start { df .y = 5 } assert 15 == df .z

def df = new DataFlows ()

start { df .z = df .x + df .y }

start { df .x = 10 }

start { df .y = 5 }

assert 15 == df .z

DataFlows Making Money def stocks = ['AAPL', 'GOOG', 'IBM', 'JAVA'] def price = new DataFlows() stocks.each( {stock -> price [stock] = getClosing(stock, 2008) }.async()) def topStock = stocks.max { price [it] }

def stocks = ['AAPL', 'GOOG', 'IBM', 'JAVA']

def price = new DataFlows()

stocks.each( {stock ->

price [stock] = getClosing(stock, 2008)

}.async())

def topStock = stocks.max { price [it] }

Dataflow Streams def words = ['Groovy', 'fantastic', ‘parallel’, ‘enjoyable’, …] final def buffer = new DataFlowStream() start { //producer for (word in words) { buffer << word.toUpperCase() } } start { //consumer while (true) println buffer .val }

def words = ['Groovy', 'fantastic', ‘parallel’, ‘enjoyable’, …]

final def buffer = new DataFlowStream()

start { //producer

for (word in words) {

buffer << word.toUpperCase()

}

}

start { //consumer

while (true) println buffer .val

}

Dataflow Operators operator(inputs: [stocksStream], outputs: [pricedStocks], group) { stock -> def price = getClosing( stock , 2008) bindOutput(0, [stock: stock , price: price ]) } * + <>

operator(inputs: [stocksStream],

outputs: [pricedStocks], group)

{ stock ->

def price = getClosing( stock , 2008)

bindOutput(0, [stock: stock , price: price ])

}

Actors Isolated Communicating Immutable messages Active Pooled shared threads Activities Create a new actor Send a message Receive a message Actor Actor Actor Actor Actor Actor Actor T T T Thread pool

Isolated

Communicating

Immutable messages

Active

Pooled shared threads

Activities

Create a new actor

Send a message

Receive a message

Actors use Gate Keeper Form HTTP Finger Prints Address Check Email Check Process Fraud Detect Response SOAP SMTP

Actors patterns Enricher Router Translator Endpoint Splitter Agregator Filter Resequencer Checker

Creating Actors class MyActor extends AbstractPooledActor { void act() { def buddy = new YourActor() buddy << ‘Hi man, how’re things?’ def response = receive () } }

class MyActor extends AbstractPooledActor {

void act() {

def buddy = new YourActor()

buddy << ‘Hi man, how’re things?’

def response = receive ()

}

}

Creating Actors def decryptor = actor { loop { react {msg -> reply msg.reverse() } } } decryptor << ‘noitcA nI yvoorG’

def decryptor = actor {

loop {

react {msg ->

reply msg.reverse()

}

}

}

decryptor << ‘noitcA nI yvoorG’

Sending messages buddy. send 10.eur buddy << new Book(title: ’Groovy Recipes’ , author: ’Scott Davis’ ) def canChat = buddy. sendAndWait ‘Got time?’ buddy. sendAndContinue ‘Need money!’ , {cash-> pocket.add cash }

buddy. send 10.eur

buddy << new Book(title: ’Groovy Recipes’ ,

author: ’Scott Davis’ )

def canChat = buddy. sendAndWait ‘Got time?’

buddy. sendAndContinue ‘Need money!’ , {cash->

pocket.add cash

}

Reacting to messages react {gift1 -> reply ”Thank you for $gift1” react {gift2 -> reply ”Wow, one more $gift2” [gift1, gift2].max{it.price}. reply ‘ Will you marry me?’ } //Never reached }

react {gift1 ->

reply ”Thank you for $gift1”

react {gift2 ->

reply ”Wow, one more $gift2”

[gift1, gift2].max{it.price}. reply

‘ Will you marry me?’

}

//Never reached

}

Choosing the Reaction react / receive {gift -> switch (gift) { case Money: reply ‘Thanks’ ;pocket gift; break case [iPhone, iPod]:child << gift; break case (BigFlat..SmallHouse):moveIn(gift); break case Clothes: putOn(gift) fits(gift)?reply ‘Thanks’ : reply gift break case EXIT: stop() } }

react / receive {gift ->

switch (gift) {

case Money: reply ‘Thanks’ ;pocket gift; break

case [iPhone, iPod]:child << gift; break

case (BigFlat..SmallHouse):moveIn(gift); break

case Clothes:

putOn(gift)

fits(gift)?reply ‘Thanks’ : reply gift

break

case EXIT: stop()

}

}

Continuation Style loop { … react { … react { /*schedule the block; throw CONTINUE*/ … } //Never reached } //Never reached } //Never reached

loop {

…

react {

…

react { /*schedule the block; throw CONTINUE*/

…

}

//Never reached

}

//Never reached

}

//Never reached

Receiving messages def gift = receive () reply ”Thank you for $gift” gift = receive () reply ”Wow, one more $gift” Blocks the calling thread

def gift = receive ()

reply ”Thank you for $gift”

gift = receive ()

reply ”Wow, one more $gift”

Blocks the calling thread

Dynamic Dispatch Actor def actor = new DynamicDispatchActor ({ when {BigDecimal num -> println 'Received BigDecimal' } when {String code -> compileAndRun code } when {Book book -> read book } })

def actor = new DynamicDispatchActor ({

when {BigDecimal num ->

println 'Received BigDecimal' }

when {String code ->

compileAndRun code }

when {Book book ->

read book }

})

Reactor def decryptor = reactor { msg.reverse() } decryptor << ‘rotca na si rotcaeR’

def decryptor = reactor {

msg.reverse()

}

decryptor << ‘rotca na si rotcaeR’

Safe (Agent) Lock Shared Mutable State in a Safe Alter the State Alter the State

Lock Shared Mutable State in a Safe

Safe inside Double Increment Add 25 Message Queue 36 thread

Agent principles Builds on actors Accepts functions / commands Runs the functions against the state Output becomes the new state Functions don’t care about other functions No locking or sync code in them

Builds on actors

Accepts functions / commands

Runs the functions against the state

Output becomes the new state

Functions don’t care about other functions

No locking or sync code in them

Safe List def jugMembers = new Safe<List>( ['Me'] ) //add Me final Thread t1 = Thread.start { jugMembers.send {it.add 'Joe'} //add Joe } final Thread t2 = Thread.start { jugMembers << {it.add 'Dave'} //add Dave jugMembers << {it.add 'Alice'} //add Alice } [t1, t2]*.join() println jugMembers. val

def jugMembers = new Safe<List>( ['Me'] ) //add Me

final Thread t1 = Thread.start {

jugMembers.send {it.add 'Joe'} //add Joe

}

final Thread t2 = Thread.start {

jugMembers << {it.add 'Dave'} //add Dave

jugMembers << {it.add 'Alice'} //add Alice

}

[t1, t2]*.join()

println jugMembers. val

Safe-based Shopping Cart Cart cart = new Cart() cart.addItem 'Pilsner', 10 cart.addItem 'Budweisser', 5 cart.removeItem 'Budweisser‘ cart.increaseQuantity 'Budweisser', 3

Cart cart = new Cart()

cart.addItem 'Pilsner', 10

cart.addItem 'Budweisser', 5

cart.removeItem 'Budweisser‘

cart.increaseQuantity 'Budweisser', 3

Cart implementation class ShoppingCart { private def cartState = new Safe( [:] ) public void addItem(String product, int quantity) { cartState << {it[product] = quantity} } public void removeItem(String product) { cartState << {it.remove(product)} } public Object listContent() { return cartState. val }

class ShoppingCart {

private def cartState = new Safe( [:] )

public void addItem(String product, int quantity) {

cartState << {it[product] = quantity}

}

public void removeItem(String product) {

cartState << {it.remove(product)}

}

public Object listContent() {

return cartState. val

}

Integration Maven Gradle Grape (@Grab) Griffon plugin Grails plugin

Maven

Gradle

Grape (@Grab)

Griffon plugin

Grails plugin

Roadmap Map/Reduce, Fork/Join Dataflow enhancements API evolution Actor and DataFlow remoting CSP?, STM?

Map/Reduce, Fork/Join

Dataflow enhancements

API evolution

Actor and DataFlow remoting

CSP?, STM?

Summary Tasty concurrency menu Actors, Collections, Dataflow, Safe, … Enjoyable parallelism http://gpars.codehaus.org

Tasty concurrency menu

Actors, Collections, Dataflow, Safe, …

Enjoyable parallelism

http://gpars.codehaus.org

Questions?

Questions?