Presented at: XIV Simpósio Brasileiro de Métodos Formais (SBMF 2011), September/2011.

1. PISTACHE
A π-Calculus Internal Domain Specific Language for Scala

2. • PedroMatiello
pmatiello@gmail.com
• AnaCristina de Melo
acvm@ime.usp.br
• http://code.google.com/p/pistache/

3. INTRODUCTION
• Pistacheis an implementation of the π-Calculus as a domain
specific language hosted in Scala

4. INTRODUCTION
• Itprovides π-Calculus’ abstractions for concurrent
computation within the Scala programming language

5. π-CALCULUS

6. • π-Calculus
is a formal language for describing
concurrent computation with dynamic
reconfiguration

7. • Agentscommunicate by exchanging names through
channels (which are also names)
• Connections between agents may change in the
course of the computation

8. AGENTS
0 Nil
α.P Prefix
P+Q Sum
P｜Q Parallel
(νx)P Restriction
[x=y].P Match
[x≠y].P Mismatch

9. PREFIXES
_
yx Output
y(x) Input
τ Silent

10. EXAMPLE
• The Agents:
_
C = (νz) y(p).pz
_
S = yx.S
P = x(w).α.P
• The
composition:
C|S|P
Example adapted from: An Introduction to the pi-Calculus, by Joachim Parrow

11. SCALA

12. • Scalais a general-purpose programming language
providing features both of object-oriented and
functional programming

13. • Flexible syntax
• Statically-typed
• Runs on the Java Virtual Machine

14. • Actively-developed
• Growing community

15. PISTACHE

16. • Pistacheis an implementation of π-Calculus as an
internal Domain Specific Language for Scala

17. AGENT DEFINITION
val P = Agent(...)
lazy val recP:Agent = Agent(...)
val restrP = Agent {
val restrictedName = Name(...)
...
}

18. NAMES
val name = Name(some_object)
val name = Name[Type]
name := other_object
value = name.value

19. CHANNELS
val y = Link[Type]
_
y~x yx
y(x) y(x)

20. SILENT TRANSITIONS
val silent = Action{ doSomething() } τ

21. CONCATENATION
val P = Agent { p1 * p2 * Q } P = α.β.Q

22. COMPOSITION
val P = Agent { Q | R | S } P=Q|R|S

23. SUMMATION
val P = Agent {
(p1 :: Q) + (p2 :: R) + (p3 :: S) P = αQ + βR + γS
}

24. MATCHING
val P = Agent(If (x==y) {Q}) P = [x=y] Q

25. EXAMPLE
• The Agents:
_
C = (νz) y(p).pz
_
S = yx.S
P = x(w).α.P
• The
composition:
C|S|P

26. EXAMPLE
val y = Link[Link[String]]
val x = Link[String]

27. EXAMPLE
val y = Link[Link[String]]
val x = Link[String]
val C = Agent {
val p = Name[Link[String]]
_
C = (νz) y(p).pz
val z = "message"
y(p) * p~z
}

28. EXAMPLE
val y = Link[Link[String]]
val x = Link[String]
val C = Agent {
val p = Name[Link[String]]
_
S = yx.S
y(p) * p~"message"
}
lazy val S:Agent = Agent { y~x*S }

29. EXAMPLE
val y = Link[Link[String]]
val x = Link[String]
val C = Agent {
val p = Name[Link[String]]
y(p) * p~"message"
}
lazy val S:Agent = Agent { y~x*S }
lazy val P:Agent = Agent {
val w = Name[String]
P = x(w).α.P
val act = Action { println(msg.value) }
x(w) * act * P
}

30. EXAMPLE
val y = Link[Link[String]]
val x = Link[String]
val C = Agent {
val p = Name[Link[String]]
y(p) * p~"message"
}
lazy val S:Agent = Agent { y~x*S }
lazy val P:Agent = Agent {
val msg = Name[String] C|S|P
val act = Action { println(msg.value) }
x(msg) * act * P
}
new ThreadedRunner(C | S | P) start

31. MESSAGE PASSING
• Channels are implemented as shared buffers
• Communication between agents is synchronous

32. MESSAGE PASSING
_
Output yx Input y(x)
Wait until y is empty Wait until y is not empty
Put x on y Put the contents of y in x
Signal y not empty Signal y empty
Wait until y is empty

33. DATA STRUCTURE
val P = Agent ( p1 * p2 * p3 * Q )

34. DATA STRUCTURE
val P = Agent ( p1 * p2 * p3 * Q )

35. EXECUTION
def execute(agent:PiObject) {
agent match {
case ConcatenationAgent(left, right) => ...
case CompositionAgent(left, right) => ...
...
}
}

36. EXECUTION
case ConcatenationAgent(left, right) =>
execute(left apply)
execute(right apply)

37. EXECUTION
case CompositionAgent(left, right) =>
executeInNewThread(left apply)
executeInNewThread(right apply)

38. THREAD SPAWNING
def executeInNewThread(agent:PiObject) {
val runnable = new Runnable() {
override def run() { execute(agent) }
}
executor.execute(runnable)
}

39. THREAD SPAWNING
• CachedThreadPool
• Caches finished threads
• Reuses cached threads
• Creates new threads if none are available
• Deletesfrom the pool threads that have not been used
reused for 60 seconds

40. THREAD SPAWNING
Strategy Time consumed for 100k agents
new Thread 23 743 ms
CachedThreadPool 2 089 ms

41. CONCLUSION
• We knew that:
• Concurrent programming is hard

42. CONCLUSION
• We learned that:
• Properabstractions can improve our understanding of
concurrency and concurrent programs

43. CONCLUSION
• We also learned that:
• The
abstractions present in π-Calculus provide a feasible
model for concurrency in actual software programming

44. PISTACHE
Pedro Matiello
Ana Cristina de Melo