research-article

A principled approach towards debugging communicating event-loops

Authors:

Carmen Torres Lopez,

Elisa Gonzalez Boix,

Christophe Scholliers,

Hanspeter MössenböckAuthors Info & Claims

AGERE 2017: Proceedings of the 7th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control

Pages 41 - 49

https://doi.org/10.1145/3141834.3141839

Published: 23 October 2017 Publication History

Abstract

Since the multicore revolution, software systems are more and more inherently concurrent. Debugging such concurrent software systems is still hard, but in the recent years new tools and techniques are being proposed. For such novel debugging techniques, the main question is how to make sure that the proposed techniques are sufficiently expressive. In this paper, we explore a formal foundation that allows researchers to identify debugging techniques and assess how complete their features are in the context of message-passing concurrency. In particular, we describe a principled approach for defining the operational semantics of a debugger. Subsequently, we apply this technique to derive the operational semantics for a communicating event-loop debugger. We show that our technique scales for defining the semantics of a wide set of novel breakpoints recently proposed by systems such as REME-D and Kómpos. To the best of our knowledge, this is the first formal semantics for debugging asynchronous message passing-based concurrency models.

References

[1]

Karen L. Bernstein and Eugene W. Stark. 1995. Operational Semantics of a Focusing Debugger. Electronic Notes in Theoretical Computer Science 1 (1995), 13 – 31. MFPS XI, Mathematical Foundations of Programming Semantics, Eleventh Annual Conference.

[2]

Elisa Gonzalez Boix, Carlos Noguera, and Wolfgang De Meuter. 2014. Distributed debugging for mobile networks. Journal of Systems and Software 90 (2014), 76–90.

Digital Library

[3]

Gilad Bracha, Peter von der Ahé, Vassili Bykov, Yaron Kashai, William Maddox, and Eliot Miranda. 2010. Modules as Objects in Newspeak. In ECOOP 2010 – Object-Oriented Programming. LNCS, Vol. 6183. Springer, 405–428.

[4]

Fabio Q. B. da Silva. 1992. Correctness proofs of compilers and debuggers: an approach based on structural operational semantics. Ph.D. Dissertation. University of Edinburgh, UK. British Library, EThOS.

[5]

GianLuigi Ferrari and Emilio Tuosto. 2001. A Debugging Calculus for Mobile Ambients. In Proceedings of the 2001 ACM Symposium on Applied Computing (SAC ’01). ACM, New York, NY, USA, Article 1.

Digital Library

[6]

Gian Luigi Ferrari, Roberto Guanciale, Daniele Strollo, and Emilio Tuosto. 2008. Debugging Distributed Systems with Causal Nets. ECEASST 14 (2008). Tetali, Tyson Condie, Todd Millstein, and Miryung Kim. 2016. BigDebug: Debugging Primitives for Interactive Big Data Processing in Spark. In Proceedings of the 38th International Conference on Software Engineering (ICSE ’16). ACM, New York, NY, USA, 784–795.

[7]

V. Jagannath, Z. Yin, and M. Budiu. 2011. Monitoring and Debugging DryadLINQ Applications with Daphne. In 2011 IEEE International Symposium on Parallel and Distributed Processing Workshops and Phd Forum. 1266–1273.

Digital Library

[8]

Casey Klein, John Clements, Christos Dimoulas, Carl Eastlund, Matthias Felleisen, Matthew Flatt, Jay A. McCarthy, Jon Rafkind, Sam Tobin-Hochstadt, and Robert Bruce Findler. 2012. Run your research: on the effectiveness of lightweight mechanization. In POPL, John Field and Michael Hicks (Eds.). ACM, 285–296.

Digital Library

[9]

Leslie Lamport. 1978. Time, Clocks, and the Ordering of Events in a Distributed System. Commun. ACM 21, 7 (July 1978), 558–565.

Digital Library

[10]

Max Leske, Andrei Chi c s, and Oscar Nierstrasz. 2016. A Promising Approach for Debugging Remote Promises. In Proceedings of the 11th Edition of the International Workshop on Smalltalk Technologies (IWST’16). ACM, New York, NY, USA, Article 18, 9 pages.

Digital Library

[11]

He Li, Jie Luo, and Wei Li. 2014. A formal semantics for debugging synchronous message passing-based concurrent programs. Science China Information Sciences 57, 12 (01 Dec 2014), 1–18.

[12]

Stefan Marr and Hanspeter Mössenböck. 2015. Optimizing Communicating Event-Loop Languages with Truffle. (26 October 2015).

[13]

Stefan Marr, Carmen Torres Lopez, Dominik Aumayr, Elisa Gonzalez Boix, and Hanspeter Mössenböck. 2017. A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools. In Proceedings of the 13th Symposium on Dynamic Languages (DLS’17). ACM, 12.

Digital Library

[14]

Charles E McDowell and David P Helmbold. 1989. Debugging concurrent programs. ACM Computing Surveys (CSUR) 21, 4 (1989), 593–622.

Digital Library

[15]

Mark S Miller, E Dean Tribble, and Jonathan Shapiro. 2005. Concurrency among strangers. In International Symposium on Trustworthy Global Computing. Springer, 195–229.

Digital Library

[16]

Michael Perscheid, Benjamin Siegmund, Marcel Taeumel, and Robert Hirschfeld. 2016. Studying the advancement in debugging practice of professional software developers. Software Quality Journal 25, 1 (2016), 83–110.

Digital Library

[17]

Semih Salihoglu, Jaeho Shin, Vikesh Khanna, Ba Quan Truong, and Jennifer Widom. 2015. Graft: A Debugging Tool For Apache Giraph. In Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data (SIGMOD ’15). ACM, New York, NY, USA, 1403– 1408.

Digital Library

[18]

Guido Salvaneschi and Mira Mezini. 2016. Debugging for Reactive Programming. In Proceedings of the 38th International Conference on Software Engineering (ICSE ’16). ACM, New York, NY, USA, 796–807.

Digital Library

[19]

Jan Schäfer and Arnd Poetzsch-Heffter. 2010. JCoBox: Generalizing Active Objects to Concurrent Components. In ECOOP 2010 – ObjectOriented Programming (LNCS), Vol. 6183. Springer, Berlin, 275–299.

[20]

Terry Stanley, Tyler Close, and Mark Miller. 2009. Causeway: A message-oriented distributed debugger. Technical Report. HP Labs. 1–15 pages.

[21]

Tom Van Cutsem, Elisa Gonzalez Boix, Christophe Scholliers, Andoni Lombide Carreton, Dries Harnie, Kevin Pinte, and Wolfgang De Meuter. 2014. AmbientTalk: programming responsive mobile peer-to-peer applications with actors. Computer Languages, Systems and Structures 40, 3–4 (2014), 112–136.

[22]

Tom Van Cutsem, Stijn Mostinckx, Elisa Boix Gonzalez, Jessie Dedecker, and Wolfgang De Meuter. 2007. AmbientTalk: Objectoriented Event-driven Programming in Mobile Ad hoc Networks. XXVI International Conference of the Chilean Society of Computer Science (SCCC’07) (2007), 3–12.

Digital Library

[23]

Roland Wismüller. 1997. Debugging Message Passing Programs Using Invisible Message Tags. In PVM/MPI (Lecture Notes in Computer Science), Marian Bubak, Jack Dongarra, and Jerzy Wasniewski (Eds.), Vol. 1332. Springer, 295–302.

Cited By

Bagherzadeh MFireman NShawesh AKhatchadourian R(2020)Actor concurrency bugs: a comprehensive study on symptoms, root causes, API usages, and differencesProceedings of the ACM on Programming Languages10.1145/34282824:OOPSLA(1-32)Online publication date: 13-Nov-2020
https://dl.acm.org/doi/10.1145/3428282
Mathur AOzkan BMajumdar RChechina NFrancalanza A(2018)iDeA: an immersive debugger for actorsProceedings of the 17th ACM SIGPLAN International Workshop on Erlang10.1145/3239332.3242762(1-12)Online publication date: 29-Sep-2018
https://dl.acm.org/doi/10.1145/3239332.3242762

Index Terms

A principled approach towards debugging communicating event-loops
1. Software and its engineering
  1. Software creation and management
    1. Software verification and validation
      1. Software defect analysis
        Software testing and debugging
  2. Software notations and tools
    1. General programming languages
      1. Language types
        Concurrent programming languages

Recommendations

A concurrency-agnostic protocol for multi-paradigm concurrent debugging tools
DLS 2017: Proceedings of the 13th ACM SIGPLAN International Symposium on on Dynamic Languages

Today's complex software systems combine high-level concurrency models. Each model is used to solve a specific set of problems. Unfortunately, debuggers support only the low-level notions of threads and shared memory, forcing developers to reason about ...
Advanced debugging techniques to identify concurrency bugs in actor-based programs
SPLASH Companion 2017: Proceedings Companion of the 2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity

Actor-based programs are not exempt from concurrency bugs. Inspiring contributions for debugging actor-based programs have been developed, however there is no approach that reliably identifies the root cause of complex concurrency bugs. Solving this ...
Semantics for an Actor-Based Real-Time Language
WPDRTS '96: Proceedings of the 4th International Workshop on Parallel and Distributed Real-Time Systems

We give formal semantics for a distributed concurrent object-oriented real-time programming language based on a variant of the actor model which includes an extension enabling the specification of time constraints on message-invocation. Real-time ...

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences

AGERE 2017: Proceedings of the 7th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control

October 2017

57 pages

ISBN:9781450355162

DOI:10.1145/3141834

General Chairs:
Joeri De Koster,
Federico Bergenti

Copyright © 2017 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Sponsors

SIGPLAN: ACM Special Interest Group on Programming Languages

In-Cooperation

SIGAda: ACM Special Interest Group on Ada Programming Language

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 23 October 2017

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Conference

SPLASH '17

Sponsor:

SIGPLAN

SPLASH '17: Conference on Systems, Programming, Languages, and Applications: Software for Humanity

October 23, 2017

BC, Vancouver, Canada

Acceptance Rates

Overall Acceptance Rate 19 of 35 submissions, 54%

Upcoming Conference

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

2
Total Citations
View Citations
97
Total Downloads

Downloads (Last 12 months)6
Downloads (Last 6 weeks)0

Reflects downloads up to 15 Oct 2024

Other Metrics

View Author Metrics

Citations

Cited By

Bagherzadeh MFireman NShawesh AKhatchadourian R(2020)Actor concurrency bugs: a comprehensive study on symptoms, root causes, API usages, and differencesProceedings of the ACM on Programming Languages10.1145/34282824:OOPSLA(1-32)Online publication date: 13-Nov-2020
https://dl.acm.org/doi/10.1145/3428282
Mathur AOzkan BMajumdar RChechina NFrancalanza A(2018)iDeA: an immersive debugger for actorsProceedings of the 17th ACM SIGPLAN International Workshop on Erlang10.1145/3239332.3242762(1-12)Online publication date: 29-Sep-2018
https://dl.acm.org/doi/10.1145/3239332.3242762

View Options

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Media

Figures

Other

Tables

View Table of Contents