A Multi-Paradigm Concurrent Programming Model

  • Janwillem Swalens ((PhD) Student)

Scriptie/masterproef: Doctoral Thesis

Uittreksel

Sinds de opkomst van multicore processors rond het jaar 2005 moeten programmeurs expliciet concurrency en parallellisme gebruiken om hun programma's sneller te maken. Programmeren met concurrency is echter erg moeilijk. Programmeurs gebruiken hiervoor "concurrencymodellen": technieken die parallellisme toevoegen aan een programma, maar op een gecontroleerde manier, zodat ze garanties bieden die vaak gemaakte fouten voorkomen (zoals race conditions of deadlocks). Dit proefschrift start van drie concurrencymodellen uit drie categorieën: futures (die determinisme garanderen), transacties (die isolatie en progress garanderen), en actors (die het isolated turn-principe en de afwezigheid van deadlocks garanderen).

Een empirische studie toonde aan dat bestaande programma's en programmeertalen vaak verschillende concurrencymodellen combineren. Wij tonen aan dat het combineren van modellen hun garanties kan teniet doen. Dit breekt de veronderstellingen van programmeurs, waardoor opnieuw de fouten opduiken die door de aparte concurrencymodellen werden voorkomen. Voor elke combinatie bestuderen we welke garanties gebroken worden in een naïeve, ad-hoc combinatie. Vervolgens onderzoeken we hoe de garanties van beide modellen toch kunnen behouden worden, zonder de performantie te beperken. We focussen op twee interessante gevallen.

Ten eerste leidt de combinatie van transacties en futures tot transactional futures. Dit zijn futures die aangemaakt worden in een transactie én toegang hebben tot die transactie. Met transactional futures kan het parallellisme binnenin transacties benut worden, met de garantie op determinisme binnen de transactie en isolatie tussen de transacties.

Ten tweede combineren we transacties en actors in transactional actors. Hiermee kunnen zowel transacties in actors gemaakt worden als, vice versa, berichten gestuurd worden naar actors in transacties. Onze semantiek behoudt de garanties op isolatie en progress van transacties en garandeert de afwezigheid van low-level races en deadlocks van actors.

Ten slotte voegen we de drie modellen samen in één framework: Chocola (voor COmposable COncurrency LAnguage). We implementeerden Chocola als een uitbreiding van Clojure. We definiëren de operationele semantiek van Chocola en tonen aan welke garanties het biedt. Als evaluatie breiden we drie programma's uit de vaak gebruikte STAMP benchmark suite uit, door verschillende concurrencymodellen te combineren. Hiermee demonstreren we dat met Chocola parallellisme kan toegevoegd worden aan deze programma's, wat de performantie verhoogt, en dat dit slechts weinig moeite vereist van de programmeur.

Voor zover wij weten is dit proefschrift het eerste dat systematisch de combinaties van drie radicaal verschillende concurrencymodellen bestudeert – futures, transacties en actors – en een semantiek definieert voor hun combinaties die parallellisme toevoegt terwijl hun garanties waar mogelijk behouden blijven. Zo kunnen programmeurs met Chocola een rijk palet aan concurrencymodellen gebruiken en mengen in hun programma's.
Datum Prijs27 sep 2018
TaalEnglish
Toekennende instantie
  • Vrije Universiteit Brussel
BegeleiderWolfgang De Meuter (Promotor), Joeri De Koster (Promotor), Viviane Jonckers (Jury), Beat Signer (Jury), Jan Lemeire (Jury), Mira Mezini (Jury) & Hridesh Rajan (Jury)

Citeer dit

'