Scala-Gopher: CSP-style programming techniques with idiomatic Scala.

CSCSP WITH IDIOMATIC SCALA
SCALA-GOPHER
https://github.com/rssh/scala-gopher
goo.gl/dbT3P7
Ruslan Shevchenko
VertaMedia

scala-gopher
❖ Akka extension + Macros on top of SIP22-async
❖ Integrate CSP Algebra and scala concurrency primitives
❖ Provides:
❖ asynchronous API inside general control-ﬂow
❖ pseudo-synchronous API inside go{ .. } or async{ ..}
blocks
❖ Techreport: goo.gl/dbT3P7

def nPrimes(n:Int):Future[List[Int]]= {
val in = makeChannel[Int]()
val out = makeChannel[Int]()
go {
for(i <- 1 to Int.MaxValue) in.write(i)
}
go {
select.fold(in){ (ch,s) =>
s match {
case p:ch.read => out.write(p)
ch.filter(_ % p != 0)
}
}
}
go {
for(i <- 1 to n) yield out.read
}
}

go {
for(i <- 1 to n*n) out.write(i)
}
go {
s match {
}
}
}
go {
}
}
go {
for(i <- 1 to Int.MaxValue)
in.write(i)
}

go {
}
go {
s match {
}
}
}
go {
}
}
go {
s match {
}
}
}

go {
}
go {
s match {
}
}
}
go {
}
}
go {
}

Goroutines
❖ go[X](body: X):Future[X]
❖ Wrapper around async +
❖ translation of high-order functions into async form
❖ handling of defer statement

Goroutines
❖ translation of hight-order functions into async form
❖ f(g): f: (A=>B)=>C in g: A=>B,
❖ g is invocation-only in f iff
❖ g called in f or in some h inside f : g invocation-only in h
❖ g is
❖ not stored in memory behind f
❖ not returned from f as return value
❖ Collection API high-order methods are invocation-only

Translation of invocation-only functions
❖ f: ((A=>B)=>C), g: (A=>B), g invocation-only in f
❖ f’: ((A=>Future[B])=>Future[C]) g’: (A=>Future[B])
❖ await(g’) == g => await(f’) == f
❖ f’ => await[translate(f)]
❖ g(x) => await(g’(x))
❖ h(g) => await(h’(g’)) iff g is invocation-only in h
❖ That’s all
❖ (implemented for speciﬁc shapes and parts of scala collection
API)

go {
for(i <- 1 to n*n) in.write(i)
}
go {
s match {
}
}
}
go {
}
}
go {
}

go {
(1 to n).map(i => out.read)
}
async{
await(t[(1 to n).map(i => out.read)])
}
async{
await((1 to n).mapAsync(t[i => async(out.read)]))
}
async{
await((1 to n).mapAsync(i => async(await(out.aread)))
}
mapAsync(i => out.aread)

Channels
❖ Channel[A] <: Input[A] + Output[A]
❖ Unbuffered
❖ Buffered
❖ Dynamically growing buffers [a-la actor mailbox]
❖ One-time channels [Underlaying promise/Future]
❖ Custom
CSP

Input[A] - internal API
trait Input[A]
{
type read = A
def cbread(f: ContRead[A,B]=>Option[
ContRead.In[A] => Future[Continuated[B]])
…..
}
case class ContRead[A,B](
function: F,
channel: Channel[A],
ﬂowTermination: FlowTermination[B]
)
// in ConRead companion object
sealed trait In[+A]
case class Value(a:A) extends In[A]
case class Failure(ex: Throwable] extends In[Nothing]
case object Skip extends In[Nothing]
case object ChannelClosed extends In[Nothing]
ContRead[A,B].F
Continuated[B]
• ContRead
• ContWrite
• Skip
• Done
• Never

Input[A] - external API
trait Input[A]
{
……
def aread: Future[A] = <implementation…>
def read: A = macro <implementation … >
….
def map[B](f: A=>B): Input[B] = ….
// or, zip, ﬁlter, … etc
await(aread)
+ usual operations on streams in functional language

Output[A] - API
trait Output[A]
{
type write = A
def cbwrite(f: ContWrite[A,B]=>Option[
(A,Future[Continuated[B]])],
ft: FlowTermination[B])
…..
def awrite(a:A): Future[A] = ….
def write(a:A): A = …. << await(awrite)
….
ContWrite[A,B].F
case class ContWrite[A,B](
function: F,
channel: Channel[A],
ﬂowTermination: FlowTermination[B]
)

Selector ss
go {
for{
select{
case c1 -> x : … // P
case c2 <- y : … // Q
}
}
Go language:
go {
select.forever {
case x : c1.read => … // P
case y : c2.write => … // Q
}
}
Scala:
Provide set of flow combinators:
forever, once, fold
select.aforever {
case x : c1.read => … // P
case y : c2.write => … // Q
}

select: fold API
def ﬁbonacci(c: Output[Long], quit: Input[Boolean]): Future[(Long,Long)] =
select.afold((0L,1L)) { case ((x,y),s) =>
s match {
case x: c.write => (y, x+y)
case q: quit.read =>
select.exit((x,y))
}
}
fold/afold:
• special syntax for tuple support
• ’s’: selector pseudoobject
• s match must be the first statement
• select.exit((..)) to return value from flow

Transputer
❖ Actor-like object with set of input/output ports, which
can be connected by channels
❖ Participate in actor systems supervisors hierarchy
❖ SelectStatement
❖ A+B (parallel execution, common restart)
❖ replicate

Transputer: select
class Zipper[T] extends SelectTransputer
{
val inX: InPort[T]
val inY: InPort[T]
val out: OutPort[(T,T)]
loop {
case x: inX.read => val y = inY.read
out write (x,y)
case y: inY.read => val x = inX.read
out.write((x,y))
}
}
inX
inY
out

Transputer: replicate
val r = gopherApi.replicate[SMTTransputer](10)
( r.dataInput.distribute( (_.hashCode % 10 ) ).
.controlInput.duplicate().
out.share()
)
dataInput
controlInput
share

Programming techniques
❖ Dynamic recursive dataﬂow schemas
❖ conﬁguration in state
❖ Channel-based two-wave generic API
❖ expect channels for reply

Dynamic recursive dataflow
select.fold(output){ (out, s) => s match {
case x:input.read => select.once {
case x:out.write =>
case select.timeout => control.distributeBandwidth match {
case Some(newOut) => newOut.write(x)
out | newOut
case None => control.report("Can't increase bandwidth")
out
}
}
case select.timeout => out match {
case OrOutput(frs,snd) => snd.close
frs
case _ => out
}
}
dynamically increase and decrease bandwidth in dependency from load

case x:out.write =>
out | newOut
out
}
}
frs
case _ => out
}
}
case select.timeout =>
control.distributeBandwidth match {
out | newOut
case None =>
control.report("Can't increase bandwidth")
out

case x:out.write =>
out | newOut
out
}
}
frs
case _ => out
}
}
frs
case _ => out
}

Channel-based generic API
❖ Endpoint instead function call
❖ f: A=>B
❖ endpoint: Channel[A,Channel[B]]
❖ Recursive
❖ case class M(A,Channel[M])
❖ f: (A,M) => M (dataﬂow conﬁgured by input)

trait Broadcast[T]
{
val listeners: Output[Channel[T]]
val messages: Output[T]
def send(v:T):Unit = { messages.write(v) }
….
• message will received by all listeners

class BroadcastImpl[T]
{
val listeners: Channel[Channel[T]]
val messages: Channel[T] = makeChannel[Channel[T]]
def send(v:T):Unit = { messages.write(v) }
….
}
// private part
case class Message(next:Channel[Message],value:T)
select.afold(makeChannel[Message]) { (bus, s) =>
s match {
case v: messages.read => val newBus = makeChannel[Message]
current.write(Message(newBus,v))
newBus
case ch: listeners.read => select.afold(bus) { (current,s) =>
s match {
case msg:current.read => ch.awrite(msg.value)
current.write(msg)
msg.next
}
}
current

val listeners: Channel[Channel[T]]
val messages: Channel[T] = makeChannel[]
// private part
s match {
case v: message.read => val newBus = makeChannel[Message]
newBus
case ch: listener.read => select.afold(bus) { (current,s) =>
s match {
current.write(msg)
msg.next
}
}
• state - channel [bus], for which all listeners are subscribed
• on new message - send one to bus with pointer to the next bus state
• listener on new message in bus - handle, change current and send again
• on new listener - propagate

val listener: Channel[Channel[T]]
val message: Channel[T] = makeChannel[]
// private part
s match {
newBus
s match {
msg.next
}
}
current
• on new listener - propagate
s match {
current.write(msg)
msg.next
}

val listener: Channel[Channel[T]]
val message: Channel[T] = makeChannel[]
// private part
s match {
newBus
s match {
current.write(msg)
msg.next
}
}
current
•
val newBus = makeChannel[Message]
newBus

Scala concurrency libraries
Flexibility
Scalability
Level
Actors
• Actors
• low level,
• great flexibility and scalability
• Akka-Streams
• low flexibility
• hight-level, scalable
• SCO
• low scalability
• hight-level, flexible
• Reactive Isolated
• hight-level, scalable,
• allows delegation
• Gopher
• can emulate each style
Streams
SCO
Subscript
Language

Gopher vs Reactive Isolates
• Isolate
• Events
• Channel
• Transputer/fold
• Input
• Output
Gopher Isolates
One writerMany writers
Channel must have owner
Local Distributed
Loosely coupled (growing buffer)CSP + growing buffer

Scala-gopher: early experience reports
❖ Not 1.0 yet
❖ Helper functionality in industrial software projects.
(utilities, small team)
❖ Generally: positive
❖ transformation of invocation-only hight-order methods
into async form
❖ recursive dynamic data ﬂows
❖ Error handling needs some boilerplate

Error handling: language level issue
val future = go {
………
throw some exception
}
go {
……….
}
Go {
…………
}
Core scala library:
Future.apply
(same issue)
Error is ignored
Developers miss-up Go/go

Errors in ignored value: possible language changes.
❖ Possible solutions:
❖ Optional implicit conversion for ignored value
❖ Special optional method name for calling with ignored value
❖ Special return type
trait Ignored[F]
object Future
{
implicit def toIgnored(f:Future):Ignored[Future] =
….
def go[X](f: X): Future[X]
def go_ignored[X](f:X): Unit
def go(f:X): Ignored[Future[X]] =

Scala-Gopher: Future directions
❖ More experience reports (try to use)
❖ Extended set of notiﬁcations
❖ channel.close, overﬂow
❖ Distributed case
❖ new channel types with explicit distributed semantics

Scala-Gopher: Conclusion
❖ Native integration of CSP into Scala is possible
❖ have a place in a Scala concurrency model zoo
❖ Bring well-established techniques to Scala world
❖ (recursive dataﬂow schemas; channel API)
❖ Translation of invocation-only high-order functions into
async form can be generally recommended.
❖ (with TASTY transformation inside libraries can be done
automatically)

Thanks for attention
❖ Questions ?
❖ https://github.com/rssh/scala-gopher
❖ ruslan shevchenko: ruslan@shevchenko.kiev.ua

Scala-Gopher: CSP-style programming techniques with idiomatic Scala.

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Scala-Gopher: CSP-style programming techniques with idiomatic Scala. (20)

More from Ruslan Shevchenko (20)

Recently uploaded (20)

Scala-Gopher: CSP-style programming techniques with idiomatic Scala.