Verteilte Algorithmen TI5005

Transkript

1 Verteilte Algorithmen TI5005 Th. Letschert TH Mittelhessen Gießen University of Applied Sciences Prozess-Netze mit Aktoren Produzent / Konsument / Pipeline Client-Server Abstraktion der Partner

2 Produzent / Konsument Schreiber / Produzent Leser / Konsument Schreiber Aktiv Leser Schreiber Aktiv Aktiv Klassisch : aktiver Produzent, aktiver Konsument Schreiber Rektiv Leser Reaktiv Pull: reaktiver Produzent, aktiver Konsument Reaktiv Push: aktiver Produzent, reaktiver Konsument Schreiber Aktiv Leser Leser Reaktiv Unsinn: reaktiver Produzent, reaktiver Konsument Seite 2

3 Produzent / Konsument Push: Aktiver Schreiber / Produzent Reaktiver Leser / Konsument ohne Flusskontrolle Schreiber sendet Daten ohne Rücksicht auf Leser Leser arbeitet seine Mailbox ab, diese wird eventuell von Nachrichten überflutet Leser Schreiber mit Flusskontrolle Schreiber und Leser beachten Protokoll z.b.: Stop-and-Wait-Protokoll: Leser bestätigt jede Nachricht Schreiber wartet nach jeder Nachricht eine Bestätigung ab. Reaktiv Aktiv aktiver Produzent, reaktiver Konsument Interaktion ohne Flusskontrolle Schreiber Aktiv Leser Reaktiv aktiver Produzent, reaktiver Konsument Interaktion mit Flusskontrolle Seite 3

4 Produzent / Konsument Push: Aktiver Schreiber / Produzent Reaktiver Leser / Konsument ohne Flusskontrolle akka.actor.actorref akka.actor.actor akka.actor.actorsystem akka.actor.props Schreiber class Reader extends Actor { def receive = { case x: Int => { consume(x) def consume(v: Int) { println(s"reader consumes $v") Aktiv class Writer(start: Int, reader : ActorRef) extends Runnable { override def run { var i = start while (true) { reader! i i = i+1 object A_Producer_R_Consumer_App_NoFlowControl extends App { val system = ActorSystem("RWSystem") val reader = system.actorof(props[reader], name = "reader") val writer = new Writer(50, reader) new Thread(writer). start Seite 4 Leser Reaktiv

5 Produzent / Konsument Push: Aktiver Schreiber / Produzent Reaktiver Leser / Konsument mit Flusskontrolle akka.actor.{actorref, Actor, ActorSystem, Props scala.concurrent.{executioncontext, Future, Await akka.pattern.ask akka.util.timeout scala.concurrent.duration._ Schreiber case object Ack class Reader extends Actor { def receive = { case x: Int => { consume(x) sender! Ack def consume(v: Int) { println(s"reader consumes $v") class Writer(start: Int, reader : ActorRef, implicit val execcontext: ExecutionContext) implicit val timeout = Timeout(3 seconds) override def run { var i = start while (true) { val f: Future[_] = (reader? i) Await.result(f, 1.seconds) i = i+1 Aktiv Leser Reaktiv extends Runnable { object A_Producer_R_Consumer_App_FlowControl extends App { val system = ActorSystem("RWSystem") val execcontext = system.dispatcher val reader = system.actorof(props[reader], name = "reader") val writer = new Writer(50, reader, execcontext) new Thread(writer). start Seite 5

6 Produzent / Konsument Pull: Reaktiver Schreiber / Produzent Aktiver Leser / Konsument ohne Flusskontrolle akka.actor.{actorref, Actor, ActorSystem, Props scala.concurrent.{executioncontext, Future, Await scala.concurrent.duration._ scala.util.{success, Failure akka.pattern.ask akka.util.timeout case object Ask class Reader(writer : ActorRef, implicit val execcontext: ExecutionContext) extends Runnable { implicit val timeout = Timeout(3 seconds)? Schreiber Reaktiv Leser Aktiv reaktiver Produzent, aktiver Konsument override def run() { while (true) { val f: Future[_] = (writer? Ask) consume(f.asinstanceof[future[int]]) Asynchrone Verarbeitung der Antwort def consume(f: Future[Int]) { des Schreibers: Keine Flusskontrolle! f andthen { case Success(v) => println(s"reader received $v") case Failure(e) => println(s"reader failed with $e") object R_Producer_A_Consumer_App_NoFlowControl extends App { val system = ActorSystem("RWSystem") val execcontext = system.dispatcher class Writer(start: Int) extends Actor { var i = start val writer = system.actorof(props(classof[writer],50), name = "writer") def receive = { val reader = new Reader(writer, execcontext) case Ask => { sender! i new Thread(reader). start i = i+1 Seite 6

7 Produzent / Konsument Pull: Reaktiver Schreiber / Produzent Aktiver Leser / Konsument mit Flusskontrolle akka.actor.{actorref, Actor, ActorSystem, Props scala.concurrent.{executioncontext, Future, Await scala.concurrent.duration._ akka.pattern.ask akka.util.timeout? case object Ask Schreiber class Reader(writer : ActorRef, implicit val execcontext: ExecutionContext) extends Runnable { Reaktiv implicit val timeout = Timeout(3 seconds) override def run() { while (true) { val f: Future[_] = (writer? Ask) consume(await.result(f.asinstanceof[future[int]], 1.seconds)) def consume(v: Int) { println(s"reader consumes $v") Leser Aktiv reaktiver Produzent, aktiver Konsument Synchrone Verarbeitung der Antwort des Schreibers: Flusskontrolle! class Writer(start: Int) var i = start def receive = { case Ask => { sender! i i = i+1 extends Actor { object R_Producer_A_Consumer_App_FlowControl extends App { val system = ActorSystem("RWSystem") val execcontext = system.dispatcher val writer = system.actorof(props(classof[writer],50), name = "writer") val reader = new Reader(writer, execcontext) new Thread(reader). start Seite 7

8 Pipeline Pipeline (1) Der Partner wird als Parameter direkt bei der der Konstruktion übergeben. object SimpleActorNet_App extends App { val val val val system = consumer filter = producer ActorSystem("ProducerConsumer") = system.actorof(props[consumer], name = "Consumer") system.actorof(props(classof[filter], consumer), name = "Filter") = new Thread(new Producer(filter)) producer.start() producer.join() val filter_stopped: Future[Boolean] = gracefulstop(filter, 5 seconds) val consumer_stopped: Future[Boolean] = gracefulstop(consumer, 5 seconds) Await.result(filter_stopped, 5 seconds) Await.result(consumer_stopped, 5 seconds) Filter-Pipeline mit freundlichem Herunterfahren system.shutdown() producer filter consumer Seite 8

9 Pipeline Pipeline (2) akka.actor.{actor, ActorSystem, ActorRef, Props scala.util.random scala.concurrent.{await, Future akka.util.timeout scala.concurrent.duration._ akka.pattern.gracefulstop class Consumer extends Actor { def receive = { case x: Int => println("consumer received " + x) case _ => println("consumer received unkown msg ") class Filter(dest: ActorRef) extends Actor { def receive = { case -1 => { case x: Int => { if (x%2 == 0) dest! x case _ => println("filter received unkown msg ") class Producer(dest: ActorRef) extends Runnable { override def run() { for (i <- List(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)) { Thread.sleep(Random.nextInt(100)) dest! i Seite 9

10 Client Server Aktor-Netze mit Monitoren Passive Monitore mit synchronisierten blockierenden Methoden in Kombination mit reaktiven Komponenten sind verboten. Kein Passiver Puffer (synchronisierender Kanal): der Schreiber darf kein blockierendes Put ausführen Reaktiv der Leser kann kein wartendes Get ausführen put Ein aktiver oder reaktiver Monitor, z.b. ein Puffer, kann zwei aktive Partner koppeln Seite 10 OK! Reaktiv get Puffer (Monitor / Server) aktiv oder reaktiv put uns inn OK ig! producer reaktiv Passiv mit Synchronisation value OK producer Reaktive Clients eines aktiven Monitors (Server) sind unsinnig! Ein (re)aktiver Server benötigt aktive Partner! Ver b put otenget! get value Puffer (Monitor / Server) aktiv oder reaktiv consumer uns i nni g! consumer reaktiv

11 Client Server Aktor-Netze mit Monitoren Beispiel reaktiver Puffer (1) case case case case akka.actor.{actor, ActorSystem, ActorRef, Props scala.util.random scala.concurrent.{await, Future akka.util.timeout scala.concurrent.duration._ akka.pattern.{ask, gracefulstop, AskTimeoutException class PutMsg(x: Int) class DataMsg(x: Int) object GetMsg object OKMsg producer aktiv put get OK value Puffer (Monitor / Server) reaktiv object ReactiveBuffer_App extends App { val system = ActorSystem("ProducerConsumer") val buffer = system.actorof(props[reactivebuffer], name = "Buffer") object producer1 extends ActiveProducer(buffer) { val data = List(1,3,5,7,9,11,13,15,17,19,21) object producer2 extends ActiveProducer(buffer) { val data = List(2,4,6,8,10,12,14,16,18,20,22) val p1: Thread = new Thread(producer1) val p2: Thread = new Thread(producer2) val consumer: Thread = new Thread(new ActiveConsumer(buffer)); consumer.start() p1.start(); p2.start() p1.join(); p2.join() consumer.interrupt() val buffer_stopped: Future[Boolean] = gracefulstop(buffer, 5 seconds) Await.result(buffer_stopped, 5 seconds) system.shutdown() Seite 11 consumer aktiv

12 Client Server Aktor-Netze mit Monitoren Beispiel reaktiver Puffer (2) abstract class ActiveProducer(buffer: ActorRef) extends Runnable { val data : List[Int] implicit val timeout = Timeout(5 seconds) override def run() { for (i <- data) { Thread.sleep(Random.nextInt(100)) val futureok = buffer? PutMsg(i) Await.result(futureOK, timeout.duration) Seite 12 producer aktiv

13 Client Server Aktor-Netze mit Monitoren Beispiel reaktiver Puffer (3) class ActiveConsumer(buffer: ActorRef) extends Runnable { implicit val timeout = Timeout(5 seconds) override def run() { while(! Thread.currentThread().isInterrupted()) { val futuredatamsg = buffer? GetMsg try { val v = Await.result(futureDataMsg, timeout.duration) println("consumer received " + v) catch { case e: InterruptedException => println("consumer interrupted") case e: AskTimeoutException => println("consumer timeout") Seite 13 consumer aktiv

14 Client Server Aktor-Netze mit Monitoren Beispiel reaktiver Puffer (4) class ReactiveBuffer extends Actor { implicit val execcontext = context.dispatcher object BufferMonitor { var item : Int = -999 var empty : Boolean = true def put(x: Int) = synchronized { while (!empty) { try { wait catch { case e: InterruptedException => empty = false item = x notifyall() def get() : Int = synchronized { while (empty) { try { wait catch { case e: InterruptedException => empty=true notifyall() item Puffer (Monitor / Server) reaktiv def receive = { case PutMsg(x) => val lsender = sender Future { BufferMonitor.put(x) lsender! OKMsg case GetMsg => val lsender = sender Future { lsender! DataMsg(BufferMonitor.get()) case x => println("buffer received unkown msg " + x) Seite 14

15 Client Server Aktor-Netze mit Monitoren Client Zusammenfassung Client / Server Kombinationen OK Ein Monitor synchronisiert die Kontrollflüsse aktiver Komponenten die in einer dritten Komponente zusammenstoßen In einer passiven Komponente durch Synchronisation (Anhalten / reaktivieren des Kontrollflusses) Verboten In einer reaktiven Komponente durch Verwaltung der eintreffenden Nachrichten und Senden eigener Nachrichten. OK In einer aktiven Komponente durch Verwaltung der eintreffenden Nachrichten und Senden eigener Nachrichten. Ein eigener Kontrollfluss prinzipiell unnötig wenn auch gelegentlich vorteilhaft. OK Unsinnig Seite 15 Server Client

16 Abstraktion der Partner Aktor-Netze und Ports DataSink DataSource Channel Aktive Komponenten haben explizite Empfangsoperation können über Kanäle kommunizieren Senden und Empfang via Ports ist sinnvoll Empfänger Sender InPort OutPort Kanäle / Ports / aktive Komponenten: eine perfekte Kombination Reaktive Komponenten Reaktive Komponenten dürfen keine blockierenden Operationen ausführen Direkte Interaktion schreibend oder lesend mit einem passiven blockierenden Puffer ist verboten Reaktive Komponenten können nur von einem aktiven Kanalende mit Nachrichten versorgt werden DataSink DataSource Channel Sender InPort OutPort DataSink Das Mischen aktiver und reaktiver Komponenten ist problematisch. Aktive Komponenten sollten auf ein Minimum beschränkt werden. Explizite Kanäle in Kombination mit reaktiven Komponenten sind wenig sinnvoll. reaktiver Empfänger DataSource Channel Sender OutPort reaktiver Empfänger InPort Reaktive Komponente an einem Kanalende: aktives Kanalende erforderlich Seite 16

17 Abstraktion der Partner Aktor-Netze und Ports Explizite Kanäle als synchronisierende Komponenten sind in Aktor-Netzen kaum sinnvoll, da das zugrunde liegende System die entsprechende Funktionalität bietet und reaktive Komponenten keine synchronisierenden Puffer zwischen sich benötigen. Die Kombination Port / Kanal zur Trennung der Bekanntschaft-Relation vom statischen Code der Prozesse / Aktoren ist jedoch hilfreich. Eine reaktive Komponente benötigt Informationen über die möglichen Empfänger ihrer Nachrichten um eigene Nachrichten an den Richtigen versenden zu können. Das Konzept Senden an einen OutPort ist darum sinnvoll. Eine reaktive Komponente kann nicht an einem bestimmten Port / Kanal auf Nachrichten warten. Das Konzept Empfangen an einem bestimmten InPort ist unnötig. Eine Komponente muss allerdings feststellen können, von wem eine Nachricht kam. Das Konzept Nachricht kam über einen bestimmten InPort ist also zu realisieren. Seite 17

18 Abstraktion der Partner Aktor-Netze und (abstrakte) Nachbarschaften Das Port-Konzept als Trennung der Netztopologie vom Code der Komponenten kann auf unterschiedliche Art auch in Aktor-Netzen realisiert werden. Eine Möglichkeit besteht darin, die Komponenten (Knoten) im Kontext einer Nachbarschaft agieren zu lassen. Die Nachbarschaft besteht aus Knoten zu denen Nachrichten gesendet werden können und die als Absender einer Nachricht in Frage kommen. Die Nachbarschaft eines Knotens wird abstrakt definiert und bei der Bestimmung der Netztopologie konkretisiert. Seite 18

19 Abstraktion der Partner Aktor-Netze und (abstrakte) Nachbarschaften A Beispiel Prozesse und Aktoren mit abstrakten Partnern (1) class Consumer extends Actor { def receive = { case value => println("consumer received " + value + " from " + sender ) Sender einer Nachricht kann stets festgestellt werden mit der Methode sender. abstract class Filter extends Actor { val out: ActorRef def receive = { case x: Int => { if (x%2 == 0) out! x case _ => println("filter received unkown msg ") abstract class Producer extends Runnable { val out: ActorRef val data: List[Int] override def run() { for (i <- data) { Thread.sleep(Random.nextInt(100)) out! i Seite 19

20 Abstraktion der Partner Aktor-Netze und (abstrakte) Nachbarschaften A Beispiel Prozesse und Aktoren mit abstrakten Partnern (2) object SimpleNetNeighbor_App extends App { val system = ActorSystem("ProducerConsumer") val consumer = system.actorof(props[consumer], name = "Consumer") class FilterC extends Filter { val out: ActorRef = consumer val filter = system.actorof(props[filterc], name = "Filter") object Producer_1 extends Producer { val data = List(1,2,3,4,5,6,7,8,9,0) val out = filter object Producer_2 extends Producer { val data = List(11,12,13,14,15,16,17,18,19,10) val out = filter val producer1 = new Thread(Producer_1) val producer2 = new Thread(Producer_2) producer1.start(); producer2.start() producer1.join(); producer2.join() val filter_stopped: Future[Boolean] = gracefulstop(filter, 5 seconds) val consumer_stopped: Future[Boolean] = gracefulstop(consumer, 5 seconds) Await.result(filter_stopped, 5 seconds) Await.result(consumer_stopped, 5 seconds) system.shutdown() Seite 20

21 Abstraktion der Partner Aktor-Netze und (abstrakte) Nachbarschaften B Beispiel Prozesse und Aktoren mit abstrakter Nachbarschaft (1) akka.actor.{actor, ActorSystem, ActorRef, Props scala.util.random scala.concurrent.{await, Future akka.util.timeout scala.concurrent.duration._ akka.pattern.gracefulstop class Consumer extends Actor { var neighbors : Set[ActorRef] = Set() def receive = { case value => { println("consumer received a " + value + " from " + sender ) if (neighbors.contains(sender)) { println(" (I know this sender)") else { println(" (This sender is new to me)") neighbors += sender abstract class Producer extends Runnable { val neighbors: List[ActorRef] val data: List[Int] override def run() { for (i <- data) { Thread.sleep(Random.nextInt(100)) for (out <- neighbors) out! i Seite 21

22 Abstraktion der Partner Aktor-Netze und (abstrakte) Nachbarschaften B Beispiel Prozesse und Aktoren mit abstrakter Nachbarschaft (2) object SeveralNeighbor_App extends App { val system = ActorSystem("ProducerConsumer") val consumer_1 = system.actorof(props[consumer], name = "Consumer_1") val consumer_2 = system.actorof(props[consumer], name = "Consumer_2") object ProducerC extends Producer { val data = List(1,2,3,4,5,6,7,8,9,0) val neighbors = List(consumer_1, consumer_2) val producer = new Thread(ProducerC) producer.start(); producer.join() val consumer_1_stopped: Future[Boolean] = gracefulstop(consumer_1, 5 seconds) val consumer_2_stopped: Future[Boolean] = gracefulstop(consumer_2, 5 seconds) Await.result(consumer_1_stopped, 5 seconds) Await.result(consumer_2_stopped, 5 seconds) system.shutdown() Seite 22