Centralized coordination vs. partially-distributed coordination with Reo and constraint automata

Research output: Contribution to journalArticleAcademicpeer-review

Abstract

High-level concurrency notations and abstractions have several well-known software engineering advantages when it comes to programming concurrency protocols among threads. To also explore their complementary performance advantages, in ongoing work, we are developing compilation technology for a high-level coordination language, Reo, based on this language's formal automaton semantics. By now, as shown in our previous work, our tools are capable of generating code that can compete with carefully handcrafted code, at least for some protocols. An important prerequisite to further advance this promising technology, now, is to gain a better understanding of how the significantly different compilation approaches that we developed so far, which vary in the amount of parallelism in their generated code, compare against each other. For instance, to better and more reliably tune our compilers, we must learn under which circumstances parallel protocol code, with high throughput but also high latency, outperforms sequential protocol code, with low latency but also low throughput.

In this paper, we report on an extensive performance comparison between these approaches for a substantial number of protocols, expressed in Reo. Because we have always formulated our compilation technology in terms of a general kind of communicating automaton (i.e., constraint automata), our findings apply not only to Reo but, in principle, to any language whose semantics can be defined in terms of such automata. (C) 2017 Elsevier B.V. All rights reserved.

Original languageEnglish
Pages (from-to)48-77
Number of pages30
Journal Science of Computer Programming
Volume160
DOIs
Publication statusPublished - 1 Aug 2018

Fingerprint

Network protocols
Semantics
Throughput
Formal languages
Computer programming
Software engineering

Keywords

  • Benchmarks
  • CHANNEL-BASED COORDINATION
  • COMPONENT CONNECTORS
  • Compilation
  • Concurrency
  • Coordination protocols
  • IMPLEMENTATION
  • LTL MODEL-CHECKING
  • NETS
  • REACTIVE SYSTEMS
  • SOFTWARE TRANSACTIONAL MEMORY
  • SPECIFICATIONS
  • SYNCHRONIZATION
  • VERIFICATION

Cite this

@article{d7f1f16a0e4c477bbac30688667ea310,
title = "Centralized coordination vs. partially-distributed coordination with Reo and constraint automata",
abstract = "High-level concurrency notations and abstractions have several well-known software engineering advantages when it comes to programming concurrency protocols among threads. To also explore their complementary performance advantages, in ongoing work, we are developing compilation technology for a high-level coordination language, Reo, based on this language's formal automaton semantics. By now, as shown in our previous work, our tools are capable of generating code that can compete with carefully handcrafted code, at least for some protocols. An important prerequisite to further advance this promising technology, now, is to gain a better understanding of how the significantly different compilation approaches that we developed so far, which vary in the amount of parallelism in their generated code, compare against each other. For instance, to better and more reliably tune our compilers, we must learn under which circumstances parallel protocol code, with high throughput but also high latency, outperforms sequential protocol code, with low latency but also low throughput.In this paper, we report on an extensive performance comparison between these approaches for a substantial number of protocols, expressed in Reo. Because we have always formulated our compilation technology in terms of a general kind of communicating automaton (i.e., constraint automata), our findings apply not only to Reo but, in principle, to any language whose semantics can be defined in terms of such automata. (C) 2017 Elsevier B.V. All rights reserved.",
keywords = "Benchmarks, CHANNEL-BASED COORDINATION, COMPONENT CONNECTORS, Compilation, Concurrency, Coordination protocols, IMPLEMENTATION, LTL MODEL-CHECKING, NETS, REACTIVE SYSTEMS, SOFTWARE TRANSACTIONAL MEMORY, SPECIFICATIONS, SYNCHRONIZATION, VERIFICATION",
author = "S.-S.T.Q. Jongmans and Arbab",
year = "2018",
month = "8",
day = "1",
doi = "10.1016/j.scico.2017.06.004",
language = "English",
volume = "160",
pages = "48--77",
journal = "Science of computer programming",
issn = "0167-6423",
publisher = "ELSEVIER SCIENCE BV",

}

Centralized coordination vs. partially-distributed coordination with Reo and constraint automata. / Jongmans, S.-S.T.Q.; Arbab.

In: Science of Computer Programming, Vol. 160, 01.08.2018, p. 48-77.

Research output: Contribution to journalArticleAcademicpeer-review

TY - JOUR

T1 - Centralized coordination vs. partially-distributed coordination with Reo and constraint automata

AU - Jongmans, S.-S.T.Q.

AU - Arbab, null

PY - 2018/8/1

Y1 - 2018/8/1

N2 - High-level concurrency notations and abstractions have several well-known software engineering advantages when it comes to programming concurrency protocols among threads. To also explore their complementary performance advantages, in ongoing work, we are developing compilation technology for a high-level coordination language, Reo, based on this language's formal automaton semantics. By now, as shown in our previous work, our tools are capable of generating code that can compete with carefully handcrafted code, at least for some protocols. An important prerequisite to further advance this promising technology, now, is to gain a better understanding of how the significantly different compilation approaches that we developed so far, which vary in the amount of parallelism in their generated code, compare against each other. For instance, to better and more reliably tune our compilers, we must learn under which circumstances parallel protocol code, with high throughput but also high latency, outperforms sequential protocol code, with low latency but also low throughput.In this paper, we report on an extensive performance comparison between these approaches for a substantial number of protocols, expressed in Reo. Because we have always formulated our compilation technology in terms of a general kind of communicating automaton (i.e., constraint automata), our findings apply not only to Reo but, in principle, to any language whose semantics can be defined in terms of such automata. (C) 2017 Elsevier B.V. All rights reserved.

AB - High-level concurrency notations and abstractions have several well-known software engineering advantages when it comes to programming concurrency protocols among threads. To also explore their complementary performance advantages, in ongoing work, we are developing compilation technology for a high-level coordination language, Reo, based on this language's formal automaton semantics. By now, as shown in our previous work, our tools are capable of generating code that can compete with carefully handcrafted code, at least for some protocols. An important prerequisite to further advance this promising technology, now, is to gain a better understanding of how the significantly different compilation approaches that we developed so far, which vary in the amount of parallelism in their generated code, compare against each other. For instance, to better and more reliably tune our compilers, we must learn under which circumstances parallel protocol code, with high throughput but also high latency, outperforms sequential protocol code, with low latency but also low throughput.In this paper, we report on an extensive performance comparison between these approaches for a substantial number of protocols, expressed in Reo. Because we have always formulated our compilation technology in terms of a general kind of communicating automaton (i.e., constraint automata), our findings apply not only to Reo but, in principle, to any language whose semantics can be defined in terms of such automata. (C) 2017 Elsevier B.V. All rights reserved.

KW - Benchmarks

KW - CHANNEL-BASED COORDINATION

KW - COMPONENT CONNECTORS

KW - Compilation

KW - Concurrency

KW - Coordination protocols

KW - IMPLEMENTATION

KW - LTL MODEL-CHECKING

KW - NETS

KW - REACTIVE SYSTEMS

KW - SOFTWARE TRANSACTIONAL MEMORY

KW - SPECIFICATIONS

KW - SYNCHRONIZATION

KW - VERIFICATION

U2 - 10.1016/j.scico.2017.06.004

DO - 10.1016/j.scico.2017.06.004

M3 - Article

VL - 160

SP - 48

EP - 77

JO - Science of computer programming

JF - Science of computer programming

SN - 0167-6423

ER -