Pistache: A π-Calculus Internal Domain Specific Language for Scala
-
Upload
pmatiello -
Category
Technology
-
view
350 -
download
0
description
Transcript of Pistache: A π-Calculus Internal Domain Specific Language for Scala
PISTACHEA π-Calculus Internal Domain Specific Language for Scala
• Pistache is an implementation of the π-Calculus as a domain specific language hosted in Scala
INTRODUCTION
• It provides π-Calculus’ abstractions for concurrent computation within the Scala programming language
INTRODUCTION
π-CALCULUS
•π-Calculus is a formal language for describing concurrent computation with dynamic reconfiguration
•Agents communicate by exchanging names through channels (which are also names)
•Connections between agents may change in the course of the computation
AGENTS
0 Nil
α.P Prefix
P + Q Sum
P|Q Parallel
(νx)P Restriction
[x=y].P Match
[x≠y].P Mismatch
PREFIXES
yx Output
y(x) Input
τ Silent
_
• The Agents:C = (νz) y(p).pzS = yx.SP = x(w).α.P
• The composition:C | S | P
&
6
3
\ [
__
EXAMPLE
Example adapted from: An Introduction to the pi-Calculus, by Joachim Parrow
SCALA
•Scala is a general-purpose programming language providing features both of object-oriented and functional programming
•Flexible syntax
•Statically-typed
•Runs on the Java Virtual Machine
•Actively-developed
•Growing community
PISTACHE
•Pistache is an implementation of π-Calculus as an internal Domain Specific Language for Scala
val P = Agent(...)
lazy val recP:Agent = Agent(...)
val restrP = Agent { val restrictedName = Name(...) ...}
AGENT DEFINITION
val name = Name(some_object)
val name = Name[Type]
name := other_object
value = name.value
NAMES
val y = Link[Type]
y~x yx
y(x) y(x)
CHANNELS
_
val silent = Action{ doSomething() } τ
SILENT TRANSITIONS
val P = Agent { p1 * p2 * Q } P = α.β.Q
CONCATENATION
val P = Agent { Q | R | S } P = Q | R | S
COMPOSITION
val P = Agent { (p1 :: Q) + (p2 :: R) + (p3 :: S) P = αQ + βR + γS
}
SUMMATION
val P = Agent(If (x==y) {Q}) P = [x=y] Q
MATCHING
• The Agents:C = (νz) y(p).pzS = yx.SP = x(w).α.P
• The composition:C | S | P
&
6
3
\ [
__
EXAMPLE
val y = Link[Link[String]]val x = Link[String]
EXAMPLE
val y = Link[Link[String]]val x = Link[String]
val C = Agent { val p = Name[Link[String]] val z = "message" y(p) * p~z}
EXAMPLE
C = (νz) y(p).pz_
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 }
EXAMPLE
S = yx.S_
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] val act = Action { println(msg.value) } x(w) * act * P}
EXAMPLE
P = x(w).α.P
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] val act = Action { println(msg.value) } x(msg) * act * P}
new ThreadedRunner(C | S | P) start
EXAMPLE
C | S | P
MESSAGE PASSING
• Channels are implemented as shared buffers
• Communication between agents is synchronous
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
_
val P = Agent ( p1 * p2 * p3 * Q )
DATA STRUCTURE
val P = Agent ( p1 * p2 * p3 * Q )
DATA STRUCTURE
3
S�
&RQFDWHQDWLRQ$JHQW
&RQFDWHQDWLRQ3UHIL[
&RQFDWHQDWLRQ3UHIL[
4
S�S�
def execute(agent:PiObject) { agent match { case ConcatenationAgent(left, right) => ... case CompositionAgent(left, right) => ... ... }}
EXECUTION
case ConcatenationAgent(left, right) => execute(left apply) execute(right apply)
EXECUTION
case CompositionAgent(left, right) => executeInNewThread(left apply) executeInNewThread(right apply)
EXECUTION
def executeInNewThread(agent:PiObject) {
val runnable = new Runnable() { override def run() { execute(agent) } }
executor.execute(runnable)}
THREAD SPAWNING
THREAD SPAWNING
• CachedThreadPool
• Caches finished threads
• Reuses cached threads
• Creates new threads if none are available
•Deletes from the pool threads that have not been used reused for 60 seconds
THREAD SPAWNING
Strategy Time consumed for 100k agents
new Thread 23 743 ms
CachedThreadPool 2 089 ms
•We knew that:
• Concurrent programming is hard
CONCLUSION
•We learned that:
• Proper abstractions can improve our understanding of concurrency and concurrent programs
CONCLUSION
•We also learned that:
• The abstractions present in π-Calculus provide a feasible model for concurrency in actual software programming
CONCLUSION
PISTACHEPedro Matiello
Ana Cristina de Melo