[Torstani@sparkb5-i ~/akka_example/pi]$ cat src/Pi.scala

 package akka.tutorial.first.scala

 import akka.actor._

 import akka.routing.RoundRobinRouter

 import scala.concurrent.duration._

 object Pi extends App{

         calculate(nrOfWorkers=4, nrOfElements=1000, nrOfMessages=10000)

         sealed trait PiMessage

         case object Calculate extends PiMessage

         case class Work(stat:Int, nrOfElements: Int) extends PiMessage

         case class Result(value: Double) extends PiMessage

         case class PiApproximation(pi: Double, duration: Duration)

         class Worker extends Actor{

                 def calculatePiFor(start: Int, nrOfElements: Int):Double = {

                         var acc = 0.0

                         for(i<- start until (start + nrOfElements))

                                 acc += 4.0 * (1 - (i%2) * 2) / (2 * i + 1)

                         acc

                 }

                 def receive = {

                         case Work(start, nrOfElements) =>

                                 //println("worker received "+start + ":"+nrOfElements)

                                 val res = calculatePiFor(start, nrOfElements)

                                 sender ! Result(res)

                                 //println("worker send result: "+res)

                 }

         }

         class Master(nrOfWorkers:Int, nrOfMessages:Int, nrOfElements: Int, listener: ActorRef) extends Actor {

                 var pi:Double = _

                 var nrOfResults:Int= _

                 val start:Long = System.currentTimeMillis

                 val workerRouter = context.actorOf(

                         Props[Worker].withRouter(RoundRobinRouter(nrOfWorkers)), name="workerRouter")

                 def receive = {

                         case Calculate =>

                                 //println("master receive Calculate")

                                 for(i <- 0 until nrOfMessages)

                                         workerRouter ! Work(i*nrOfElements, nrOfElements)

                         case Result(value) =>

                                 //println("master recieve result: "+value)

                                 pi += value

                                 nrOfResults += 1

                                 if(nrOfResults == nrOfMessages){

                                         listener ! PiApproximation(pi, duration=(System.currentTimeMillis - start).millis)

                                         context.stop(self)

                                 }

                 }

         }

         class Listener extends Actor{

                 def receive = {

                         case PiApproximation(pi, duration) =>

                                 println("\tpi approximation: \t\t%s\n\tCalculation time: \t%s".format(pi, duration))

                         context.system.shutdown()

                 }

         }

         def calculate(nrOfWorkers:Int, nrOfElements:Int, nrOfMessages:Int) = {

                 val system = ActorSystem("PiSystem")

                 val listener = system.actorOf(Props[Listener], name="listener")

                 val master = system.actorOf(Props(new Master(nrOfWorkers, nrOfMessages, nrOfElements, listener)), name="master")

                 master ! Calculate

         }

 }

 [Torstan@sparkb5-i ~/akka_example/pi]$ cat Makefile

 SRC_DIR := src

 SRC := $(shell find ${SRC_DIR} -name "*.scala")

 DIR=remote

 TARGET := HelloRemote.jar

 SCALAC := scalac

 SCFLAGS := /usr/local/scala-2.10.4/lib/akka-actors.jar  

 .PHONY: all clean

 all: ${TARGET}

 ${TARGET}: ${SRC}

         ${SCALAC} -cp ${SCFLAGS} $^

 clean:

         ${RM} -r ${TARGET} ${DIR}

 [Torstan@sparkb5-i ~/akka_example/pi]$ cat run.sh

 #!/bin/bash

 AKKA_LIB_PATH="/usr/local/akka-2.1.4/lib/akka/"

 java -cp \

  .:/usr/local/scala-2.10.4/lib/scala-library.jar:/usr/local/scala-2.10.4/lib/akka-actors.jar:/usr/local/scala-2.10.4/lib/typesafe-config.jar:${AKKA_LIB_PATH}/akka-remote_2.10-2.1.4.jar:${AKKA_LIB_PATH}/protobuf-java-2.4.1.jar:${AKKA_LIB_PATH}/netty-3.5.8.Final.jar \

 akka.tutorial.first.scala.Pi