TU Darmstadt / ULB / TUbiblio

Concurrency and Distribution in Reactive Programming

Drechsler, Joscha (2019)
Concurrency and Distribution in Reactive Programming.
Technische Universität Darmstadt
Dissertation, Erstveröffentlichung

Kurzbeschreibung (Abstract)

Distributed Reactive Programming is a paradigm for implementing distributed interactive applications modularly and declaratively. Applications are defined as dynamic distributed dataflow graphs of reactive computations that depend upon each other, similar to formulae in spreadsheets. A runtime library propagates input changes through the dataflow graph, recomputing the results of affected dependent computations while adapting the dataflow graph topology to changing dependency relations on the fly. Reactive Programming has been shown to improve code quality, program comprehension and maintainability over modular interactive application designs based on callbacks. Part of what makes Reactive Programming easy to use is its synchronous change propagation semantics: Changes are propagated such that no computation can ever observe an only partially updated state of the dataflow graph, i.e., each input change together with all dependent recomputations appears to be instantaneous.

Traditionally, in local single-threaded applications, synchronous semantics are achieved through glitch freedom consistency: a recomputation may be executed only after all its dependencies have been recomputed. In distributed applications though, this established approach breaks in two ways. First, glitch freedom implies synchronous semantics only if change propagations execute in isolation. Distributed applications are inherently exposed to concurrency in that multiple threads may propagate different changes concurrently. Ensuring isolation between concurrent change propagations requires the integration of additional algorithms for concurrency control. Second, applications’ dataflow graphs are spread across multiple hosts. Therefore, distributed reactive programming requires algorithms for both glitch freedom and concurrency control that are decentralized, i.e., function without access to shared memory. A comprehensive survey of related prior works shows, that none have managed to solve this issue so far.

This dissertation introduces FrameSweep, the first algorithm to provide synchronous propagation semantics for concurrent change propagation over dynamic distributed dataflow graphs. FrameSweep provides isolation and glitch freedom through a combination of fine-grained concurrency control algorithms for linearizability and serializability from databases with several aspects of change propagation algorithms from Reactive Programming and Automatic Incrementalization. The correctness of FrameSweep is formally proven through the application of multiversion concurrency control theory. FrameSweep decentralizes all its algorithmic components, and can therefore be integrated into any reactive programming library in a syntactically transparent manner: Applications can continue to use the same syntax for Reactive Programming as before, without requiring any adaptations of their code. FrameSweep therefore provides the exact same semantics as traditional local single-threaded Reactive Programming through the exact same syntax. As a result, FrameSweep proves by example that interactive applications can reap all benefits of Reactive Programming even if they are concurrent or distributed.

A comprehensive empirical evaluation measures through benchmarks, how FrameSweep’s performance and scalability are affected by a multitude of factors, e.g., thread contention, dataflow topology, dataflow topology changes, or distribution topology. It shows that FrameSweep’s performance compares favorably to alternative scheduling approaches with weaker guarantees in local applications. An existing Reactive Programming application is migrated to FrameSweep to empirically verify the claims of semantic and syntactic transparency.

Typ des Eintrags: Dissertation
Erschienen: 2019
Autor(en): Drechsler, Joscha
Art des Eintrags: Erstveröffentlichung
Titel: Concurrency and Distribution in Reactive Programming
Sprache: Englisch
Referenten: Mezini, Prof. Dr. Mira ; De Meuter, Prof. Dr. Wolfgang
Publikationsjahr: 2019
Ort: Darmstadt
Datum der mündlichen Prüfung: 11 Februar 2019
URL / URN: https://tuprints.ulb.tu-darmstadt.de/5228
Kurzbeschreibung (Abstract):

Distributed Reactive Programming is a paradigm for implementing distributed interactive applications modularly and declaratively. Applications are defined as dynamic distributed dataflow graphs of reactive computations that depend upon each other, similar to formulae in spreadsheets. A runtime library propagates input changes through the dataflow graph, recomputing the results of affected dependent computations while adapting the dataflow graph topology to changing dependency relations on the fly. Reactive Programming has been shown to improve code quality, program comprehension and maintainability over modular interactive application designs based on callbacks. Part of what makes Reactive Programming easy to use is its synchronous change propagation semantics: Changes are propagated such that no computation can ever observe an only partially updated state of the dataflow graph, i.e., each input change together with all dependent recomputations appears to be instantaneous.

Traditionally, in local single-threaded applications, synchronous semantics are achieved through glitch freedom consistency: a recomputation may be executed only after all its dependencies have been recomputed. In distributed applications though, this established approach breaks in two ways. First, glitch freedom implies synchronous semantics only if change propagations execute in isolation. Distributed applications are inherently exposed to concurrency in that multiple threads may propagate different changes concurrently. Ensuring isolation between concurrent change propagations requires the integration of additional algorithms for concurrency control. Second, applications’ dataflow graphs are spread across multiple hosts. Therefore, distributed reactive programming requires algorithms for both glitch freedom and concurrency control that are decentralized, i.e., function without access to shared memory. A comprehensive survey of related prior works shows, that none have managed to solve this issue so far.

This dissertation introduces FrameSweep, the first algorithm to provide synchronous propagation semantics for concurrent change propagation over dynamic distributed dataflow graphs. FrameSweep provides isolation and glitch freedom through a combination of fine-grained concurrency control algorithms for linearizability and serializability from databases with several aspects of change propagation algorithms from Reactive Programming and Automatic Incrementalization. The correctness of FrameSweep is formally proven through the application of multiversion concurrency control theory. FrameSweep decentralizes all its algorithmic components, and can therefore be integrated into any reactive programming library in a syntactically transparent manner: Applications can continue to use the same syntax for Reactive Programming as before, without requiring any adaptations of their code. FrameSweep therefore provides the exact same semantics as traditional local single-threaded Reactive Programming through the exact same syntax. As a result, FrameSweep proves by example that interactive applications can reap all benefits of Reactive Programming even if they are concurrent or distributed.

A comprehensive empirical evaluation measures through benchmarks, how FrameSweep’s performance and scalability are affected by a multitude of factors, e.g., thread contention, dataflow topology, dataflow topology changes, or distribution topology. It shows that FrameSweep’s performance compares favorably to alternative scheduling approaches with weaker guarantees in local applications. An existing Reactive Programming application is migrated to FrameSweep to empirically verify the claims of semantic and syntactic transparency.

Alternatives oder übersetztes Abstract:
Alternatives AbstractSprache

Verteilte Reaktive Programmierung ist eine Programmiertechnik zur modularen und zeitgleich deklarativen Implementierung verteilter interaktiver Anwendungen. Diese werden als ein über mehrere Rechner verteilter dynamischer Datenfluss-Graph aus voneinander abhängenden Berechnungen definiert, ähnlich zu Formeln in Tabellenkalkulation. Eine Laufzeitbibliothek propagiert eingehende Änderungen durch diesen Datenfluss-Graphen, indem sie die Ergebnisse betroffener Berechnungen neu berechnet und zugleich die Topologie des Datenfluss-Graphen an möglicherweise geänderte Abhängigkeitsbeziehungen anpasst. Nutzerstudien haben ergeben, dass Reaktive Programmierung Code-Qualität sowie Verständlichkeit und Wartbarkeit von Programmen verbessert im Vergleich zu modularen Designs interaktiver Anwendungen basierend auf dem Beobachter-Entwurfsmuster. Ein Teil dieser Verbesserungen basiert auf synchroner Semantik für die Propagation von Änderungen: keine Neuberechnung können einen nur teilweise aktualisierten Zustand des Datenfluss-Graphen beobachten. Dies führt dazu, dass sämtliche Neuberechnungen infolge einer eingehenden Änderung augenscheinlich instantan stattfinden.

Klassischerweise wurde synchrone Semantik in lokalen und nicht nebenläufigen Anwendungen durch das Sicherstellen der Konsistenzeigenschaft “Glitch-Freiheit” erreicht: jede Neuberechnung darf nur ausgeführt werden, nachdem alle nötigen Neuberechnungen ihrer Abhängigkeiten zuvor abgeschlossen wurden. In verteilten Anwendungen sind existierende Ansätze aufgrund zweierlei Gründe jedoch nicht mehr anwendbar. Zum einen impliziert Glitch-Freiheit synchrone Semantik nur solange Propagationen von Änderungen isoliert voneinander ausgeführt werden. Verteilte Anwendungen sind unweigerlich nebenläufig, was bedeutet, dass mehrere Änderungen zeitgleich durch denselben Datenfluss-Graphen propagiert werden. Um mehrere nebenläufig Änderungspropagationen voneinander zu isolieren, müssen daher Algorithmen zur Einschränkung der Nebenläufigkeit in die Laufzeitbibliothek integriert werden. Zum anderen ist der Datenfluss-Graph in verteilten Anwendungen über mehrere Rechner verteilt, welche nur über Netzwerkverbindungen miteinander kommunizieren können. Es können daher, sowohl zum Einhalten von Glitch-Freiheit als auch zur Einschränken von Nebenläufigkeit, ausschließlich Algorithmen eingesetzt werden, die dezentralisiert sind, was bedeutet dass sie ohne Zugriff auf gemeinsamen Arbeitsspeicher funktionieren müssen. Eine umfangreiche Studie themenverwandter früherer Arbeiten zeigt, dass bisher keine Lösung für diese Problemstellung existiert.

Die vorliegende Dissertation präsentiert FrameSweep, den ersten Algorithmus der synchrone Semantik für nebenläufige Propagation von Änderungen auf dynamischen und verteilten Datenfluss-Graphen sicherstellt. FrameSweep isoliert nebenläufige Propagationen und stellt ihre Glitch-Freiheit sicher, indem es mehrere Algorithmen aus dem Feld der Datenbanken für atomar erscheinende Transaktionen mit Aspekten von Algorithmen zur Änderungspropagation aus den Gebieten der Reaktiven Programmierung und der Automatischen Inkrementalisierung kombiniert. Die Korrektheit von FrameSweep wird durch Anwendung von establierter Theorie zur Nebenläufigkeitskontrolle durch Multiversionen formal bewiesen. FrameSweep dezentralisiert all seine algorithmischen Bestandteile und kann dadurch syntaktisch transparent in jegliche Laufzeitbibliotheken für Reaktive Programmierung integriert werden, was bedeutet, dass existierende Programme FrameSweep ohne Anpassungen ihres Quelltexts verwenden können. FrameSweep implementiert somit auf Basis identischer Syntax identische Semantik wie klassische, lokale, nicht-nebenläufige Reaktive Programmierung. Dadurch ist FrameSweep ein beispielhafter Beweis, dass interaktive Anwendungen alle Vorteile Reaktiver Programmierung genießen können, selbst wenn sie nebenläufige oder verteilte Systeme sind.

Eine umfangreiche empirische Evaluation misst durch Benchmarks, wie sich die Performanz und Skalierbarkeit von FrameSweep verhalten unter diversen Faktoren wie mehr oder weniger häufige Zugriffskonflikte zwischen nebenläufigen Prozessen, Topologie des Datenfluss-Graphen, Änderungen dieser Topologie, oder Topologie der Verteilung des Datenfluss-Graphen über verschiedene nur durch Netzwerk verbundene Rechner. Die Evaluation zeigt, dass Vergleiche der Performanz lokaler Anwendungen gegen globalen wechselseitigen Ausschluss und transaktionalen Speicher vorteilhaft zugunsten von FrameSweep ausfallen. Durch Migration einer bestehenden, mittels Reaktiver Programmierung implementierten Anwendung zu FrameSweep werden darüber hinaus die Behauptungen zu unveränderter Syntax und Semantik empirisch verifiziert.

Deutsch
URN: urn:nbn:de:tuda-tuprints-52284
Sachgruppe der Dewey Dezimalklassifikatin (DDC): 000 Allgemeines, Informatik, Informationswissenschaft > 004 Informatik
Fachbereich(e)/-gebiet(e): 20 Fachbereich Informatik
20 Fachbereich Informatik > Softwaretechnik
Hinterlegungsdatum: 11 Aug 2019 19:55
Letzte Änderung: 11 Aug 2019 19:55
PPN:
Referenten: Mezini, Prof. Dr. Mira ; De Meuter, Prof. Dr. Wolfgang
Datum der mündlichen Prüfung / Verteidigung / mdl. Prüfung: 11 Februar 2019
Export:
Suche nach Titel in: TUfind oder in Google
Frage zum Eintrag Frage zum Eintrag

Optionen (nur für Redakteure)
Redaktionelle Details anzeigen Redaktionelle Details anzeigen