CiteExportLink to record
Permanent link

Direct link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Compile-time Safety and Runtime Performance in Programming Frameworks for Distributed Systems
KTH, School of Electrical Engineering and Computer Science (EECS), Computer Science, Software and Computer systems, SCS.ORCID iD: 0000-0002-1200-0177
2020 (English)Doctoral thesis, monograph (Other academic)
Abstract [en]

Distributed Systems, that is systems that must tolerate partial failures while exploiting parallelism, are a fundamental part of the software landscape today. Yet, their development and design still pose many challenges to developers when it comes to reliability and performance, and these challenges often have a negative impact on developer productivity. Distributed programming frameworks and languages attempt to provide solutions to common challenges, so that application developers can focus on business logic. However, the choice of programming model as provided by a such a framework or language will have significant impact both on the runtime performance of applications, as well as their reliability.

In this thesis, we argue for programming models that are statically typed, both for reliability and performance reasons, and that provide powerful abstractions, giving developers the tools to implement fast algorithms without being constrained by the choice of the programming model. Furthermore, we show how the design of Domain Specific Languages (DSLs) for such distributed programming frameworks, as well as DSLs for testing these components written in them, can reduce the mental gap between theoretical algorithms and their implementation, in turn reducing the risk of introducing subtle bugs.

Concretely, we designed and implemented two different versions of the Kompics Component Model. The first is called Kompics Scala and focuses on pattern matching of events, as well as programming ergonomics and similarity to theoretical algorithms. The second version is called Kola and is a language with a compiler of its own, focusing on compile-time safety. Finally, we present a third framework, called Kompact, implementing a hybrid Actor–Component model which is designed around runtime-performance and static typing, and is implemented in the Rust language. In order to compare our solutions to the state-of-the-art, we present the first cross-language, distributed, message-passing benchmarking suite. We evaluated the impact of network abstractions in these models on performance, and show that our approach offers between 2× and 5× improvements on throughput for certain applications. We also evaluated the performance tradeoffs of different message-passing models and different implementations of the same model. We show that all our implementations are competitive, and our hybrid model, in particular, has significant benefits in a wide range of scenarios, leading to improvements of up to 27× compared to the state-of-the-art of message-passing systems. 

Abstract [sv]

Distribuerade system, det vill säga system som tolererar partiella fel medan paral- lelism utnyttjas, är en grundläggande del av landskapet för mjukvaruutveckling idag. Ändå utgör dessas utveckling och design fortfarande många utmaningar för utvecklare när det gäller tillförlitlighet och prestanda, och dessa utmaningar har ofta en negativ inverkan på utvecklarens produktivitet. Distribuerade programme- ringsramverk och -språk försöker att ge lösningar på vanliga utmaningar, så att applikationsutvecklare kan fokusera på applikationslogik. Sådant ramverk eller språk är baserad på en programmeringsmodell, vars val har en betydande inverkan både på applikationernas runtime-prestanda, liksom dessas tillförlitlighet.

I den här avhandlingen argumenterar vi för programmeringsmodeller som är statiskt typade, både av tillförlitlighets- och prestandaskäl, och som ger kraftfulla abstraktioner, vilket ger utvecklarna verktyg för att implementera snabba algo- ritmer utan att begränsas av valet av programmeringsmodell. Dessutom visar vi hur utformningen av domänspecifika språk (DSL) för sådana distribuerade programmeringsramverk, liksom DSL:er för att testa dessa komponenter skrivna i dem, kan minska den mentala klyftan mellan teoretiska algoritmer och dessas implementation, vilket i följd minskar risken för introduktion av subtila buggar. Specifikt, har vi utformat och implementerat två olika versioner av Kompics Compo- nent modellen. Den första heter Kompics Scala och fokuserar på mönstermatchning av event, samt programmeringsergonomi och likhet med teoretiska algoritmer. Den andra versionen heter Kola som är ett språk och sin egen kompilator med fokus på sä- kerhet i kompileringstid. Slutligen presenterar vi ett tredje ramverk, kallad Kompact, som implementerar en hybrid Actor-Component modell. Ramverket är utformad kring runtime-prestanda och statisk typning, och är implementerad i språket Rust. För att jämföra våra lösningar med andra state-of-the-art lösningar, presenterar vi den första flerspråkiga, distribuerade, message-passing benchmarking-sviten. Vi utvärderade effekterna av nätverksabstraktioner i dessa modeller på prestanda och visar att vår strategi erbjuder mellan 2× till 5× förbättringar av kapaciteten för vissa applikationer. Vi utvärderade också prestanda-tradeoffs för olika message-passing modeller och olika implementationer av samma modell. Vi visar att alla våra imple- mentationer är konkurrenskraftiga, och särskilt att vår hybridmodell har betydande fördelar i ett brett spektrum av scenarion, vilket leder till förbättringar på upp till 27× jämfört med den mest kända state-of-the-art message-passing system. 

Place, publisher, year, edition, pages
Stockholm: KTH Royal Institute of Technology, 2020. , p. 257
Series
TRITA-EECS-AVL ; 13
Keywords [en]
distributed systems, distributed computing, programming systems, programming languages, computer science, domain specific languages, message-passing, actor model, component model
National Category
Computer Systems
Research subject
Information and Communication Technology
Identifiers
URN: urn:nbn:se:kth:diva-267324ISBN: 978-91-7873-445-0 (print)OAI: oai:DiVA.org:kth-267324DiVA, id: diva2:1392215
Public defence
2020-03-06, Ka Sal-C, Electrum, Kungliga Tekniska Högskolan, Kistagången 16, Kista, 13:00 (English)
Opponent
Supervisors
Funder
Swedish Foundation for Strategic Research , BD15-0006
Note

QC 20200207

Available from: 2020-02-07 Created: 2020-02-06 Last updated: 2020-02-18Bibliographically approved

Open Access in DiVA

fulltext(6298 kB)4 downloads
File information
File name FULLTEXT02.pdfFile size 6298 kBChecksum SHA-512
1d8964bc89da106435fe21309d21797938c7ad3054f8826446900f270411a96df85fe7007c2b1454851012110391f264e02d7b17cf33aa5e7082660d58e03f11
Type fulltextMimetype application/pdf

Authority records BETA

Kroll, Lars

Search in DiVA

By author/editor
Kroll, Lars
By organisation
Software and Computer systems, SCS
Computer Systems

Search outside of DiVA

GoogleGoogle Scholar
Total: 16 downloads
The number of downloads is the sum of all downloads of full texts. It may include eg previous versions that are now no longer available

isbn
urn-nbn

Altmetric score

isbn
urn-nbn
Total: 139 hits
CiteExportLink to record
Permanent link

Direct link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf