1. GPars
'coz concurrency is Groovy
Václav Pech

2. Asynchronous calculations
Fork/Join
Parallel collections
Actors
Agents, Stm
Dataflow
CSP
Why this talk?

3. Structure
Parallelism
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

4. Structure
Parallelism
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

5. Parallelism
Task parallelism
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

6. Asynchronous invocation
Future f = threadPool.submit(calculation);
…
System.out.println(“Result: “ + f.get());

7. Async the Groovy way
task {
calculation.process()
}

8. Async the Groovy way
def group = new NonDaemonPGroup(10)
group.task {
calculation.process()
}

9. group.task {->…}
group.task new Runnable() {…}
group.task new Callable<V>() {...}
Async the Groovy way

10. Independent tasks
def group = new NonDaemonPGroup(10)
submissions.each {form →
group.task {
form.process()
}
}

11. Dependent tasks
Parallelism
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

12. State sharing
Parallelism
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

13. State sharing
List registrations = []
submissions.each {form →
group.task {
if (form.process().valid) {
registrations << form
}
}
}

14. State sharing
List registrations = []
submissions.each {form →
group.task {
if (form.process().valid) {
registrations << form
}
}
}
Needs protection

15. Agent
 Lock Shared Mutable State in a Safe
Alter
the
State
Alter
the
State

16. Agent inside
Double IncrementAdd 25
Message Queue
36 thread

17. Sharing through agents
Agent registrations = group.agent( [] )
submissions.each {form →
group.task {
if (form.process().valid) {
registrations.send {it << form}
}
}
}

18. Random task dependency
Parallelism
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

19. Dataflow Concurrency
No race-conditions
No live-locks
Deterministic deadlocks

20. Dataflow Variables / Promises
main task2 task3
x
yz
task1

21. Dataflow Variables / Promises
task2
x
task1

22. Dataflow Variables / Promises
main task2 task3
x
yz
task1

23. Chaining promises
def h1 = download('url') then {text → text.trim()} then hash

24. Error handling
url.then(download)
.then(calculateHash)
.then(formatResult)
.then(printResult, printError)
.then(sendNotificationEmail);

25. List registrations = []
List<Promise> forms=submissions.collect {form →
group.task {
if (form.process().valid) return form
}
}
forms.each{registrations << it.get()}
Pass results around

26. Dataflow Variables / Promises
task2
x
task1

27. Dataflow Channels
task2
x|y|z
task1

28. Synchronous Channels
task2
x|y|z
task1

29. Tasks with progress indication
List<Promise> forms=submissions.collect {form →
group.task {
def result = form.process()
progressQueue << 1
if (result.valid) {
return form
}
}
}

30. Channel Selection
Select alt = group.select(validForms, invalidForms)
SelectResult selectResult = alt.select() //alt.prioritySelect()
switch (selectResult.index) {
case 0: registrations << selectResult.value; break
case 1: ...
}

31. Parallelism
Data parallelism
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

32. Parallelism
Data parallelism
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

33. Geometric decomposition
images.eachParallel {it.process()}
documents.sumParallel()
candidates.maxParallel {it.salary}.marry()

34. Geometric decomposition
registrations = submissions
.collectParallel { form -> form.process()}
.findAllParallel { it.valid }
registrations = submissions.parallel
.map { form -> form.process()}
.filter { it.valid }.collection

35. Frequent confusion

36. Improper use 1
def accumulator = 0
myCollection.eachParallel {
accumulator += calculate(it)
}

37. Improper use 2
new File("/file.txt").withReader{reader ->
reader.eachParallel {
def r1 = step1(r)
def r2 = step2(r1)
def r3 = step3(r2)
}
}

38. Unroll iteration
def pipeline = data | step1 | step2 | step3
new File("/file.txt").withReader{reader ->
reader.each {
data << it
}
}

39. Unroll iteration

40. Parallelism
Streamed data
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

41. Pipeline DSL
def toProcess = new DataflowQueue()
def validated = new DataflowQueue()
toProcess | {form -> process(form)} |
{processedForm -> validate(processedForm)} | validated
submissions.each {toProcess << it}

42. Url resolverUrl resolverUrl resolverprocess
validate
inProcess
validated

43. Url resolverUrl resolver
Downloader
Groovy scanner Scala scanner
Url resolverUrl resolver
Reporter
Speculator
Evaluator
Splitter
Confirm
Cache
updates
Approvals

44. Dataflow Operators
operator(inputs: [headers, bodies, footers],
outputs: [articles, summaries])
{header, body, footer ->
def article = buildArticle(header, body, footer)
bindOutput(0, article)
bindOutput(1, buildSummary(article))
}

46. Conclusion
Parallelism
Task Data
Random
Independent Dependent
Hierarchical
Geometrical
Streamed
Event-driven
Functional
Hierarchical
Shared state

47. Summary
Parallelism is not hard, multi-threading is
Jon Kerridge, Napier University

48. Questions?
Find more at:
http://gpars.codehaus.org
http://www.jroller.com/vaclav
http://twitter.com/vaclav_pech