Standard

A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools. / Marr, Stefan; Torres Lopez, Carmen; Gonzalez Boix, Elisa; Aumayr, Dominik; Mossenbock, Hanspeter.

13th ACM SIGPLAN International Symposium on Dynamic Languages (DLS 2017). ed. / Davide Ancona. ACM, 2017. p. 3-14.

Research output: Chapter in Book/Report/Conference proceedingConference paperResearch

Harvard

Marr, S, Torres Lopez, C, Gonzalez Boix, E, Aumayr, D & Mossenbock, H 2017, A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools. in D Ancona (ed.), 13th ACM SIGPLAN International Symposium on Dynamic Languages (DLS 2017). ACM, pp. 3-14, Vancouver, Canada, 24/10/17. https://doi.org/10.1145/3133841.3133842

APA

Marr, S., Torres Lopez, C., Gonzalez Boix, E., Aumayr, D., & Mossenbock, H. (2017). A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools. In D. Ancona (Ed.), 13th ACM SIGPLAN International Symposium on Dynamic Languages (DLS 2017) (pp. 3-14). ACM. https://doi.org/10.1145/3133841.3133842

Vancouver

Marr S, Torres Lopez C, Gonzalez Boix E, Aumayr D, Mossenbock H. A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools. In Ancona D, editor, 13th ACM SIGPLAN International Symposium on Dynamic Languages (DLS 2017). ACM. 2017. p. 3-14 https://doi.org/10.1145/3133841.3133842

Author

Marr, Stefan ; Torres Lopez, Carmen ; Gonzalez Boix, Elisa ; Aumayr, Dominik ; Mossenbock, Hanspeter. / A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools. 13th ACM SIGPLAN International Symposium on Dynamic Languages (DLS 2017). editor / Davide Ancona. ACM, 2017. pp. 3-14

BibTeX

@inproceedings{2432e634d6304794973b271843b9ff69,
title = "A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools",
abstract = "Today’s complex software systems combine high-level concurrencymodels. Each model is used to solve a specific setof problems. Unfortunately, debuggers support only the lowlevelnotions of threads and shared memory, forcing developersto reason about these notions instead of the high-levelconcurrency models they chose.This paper proposes a concurrency-agnostic debuggerprotocol that decouples the debugger from the concurrencymodels employed by the target application. As a result, theunderlying language runtime can define custom breakpoints,stepping operations, and execution events for each concurrencymodel it supports, and a debugger can expose themwithout having to be specifically adapted.We evaluated the generality of the protocol by applying itto SOMns, a Newspeak implementation, which supports adiversity of concurrency models including communicatingsequential processes, communicating event loops, threadsand locks, fork/join parallelism, and software transactionalmemory. We implemented 21 breakpoints and 20 steppingoperations for these concurrency models. For none of these,the debugger needed to be changed. Furthermore, we visualizeall concurrent interactions independently of a specificconcurrency model. To show that tooling for a specific concurrencymodel is possible, we visualize actor turns andmessage sends separately.",
keywords = "Breakpoints, Concurrency, Debugging, Stepping, Tooling, Visualization",
author = "Stefan Marr and {Torres Lopez}, Carmen and {Gonzalez Boix}, Elisa and Dominik Aumayr and Hanspeter Mossenbock",
year = "2017",
month = "10",
day = "24",
doi = "10.1145/3133841.3133842",
language = "English",
pages = "3--14",
editor = "Davide Ancona",
booktitle = "13th ACM SIGPLAN International Symposium on Dynamic Languages (DLS 2017)",
publisher = "ACM",

}

RIS

TY - GEN

T1 - A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools

AU - Marr, Stefan

AU - Torres Lopez, Carmen

AU - Gonzalez Boix, Elisa

AU - Aumayr, Dominik

AU - Mossenbock, Hanspeter

PY - 2017/10/24

Y1 - 2017/10/24

N2 - Today’s complex software systems combine high-level concurrencymodels. Each model is used to solve a specific setof problems. Unfortunately, debuggers support only the lowlevelnotions of threads and shared memory, forcing developersto reason about these notions instead of the high-levelconcurrency models they chose.This paper proposes a concurrency-agnostic debuggerprotocol that decouples the debugger from the concurrencymodels employed by the target application. As a result, theunderlying language runtime can define custom breakpoints,stepping operations, and execution events for each concurrencymodel it supports, and a debugger can expose themwithout having to be specifically adapted.We evaluated the generality of the protocol by applying itto SOMns, a Newspeak implementation, which supports adiversity of concurrency models including communicatingsequential processes, communicating event loops, threadsand locks, fork/join parallelism, and software transactionalmemory. We implemented 21 breakpoints and 20 steppingoperations for these concurrency models. For none of these,the debugger needed to be changed. Furthermore, we visualizeall concurrent interactions independently of a specificconcurrency model. To show that tooling for a specific concurrencymodel is possible, we visualize actor turns andmessage sends separately.

AB - Today’s complex software systems combine high-level concurrencymodels. Each model is used to solve a specific setof problems. Unfortunately, debuggers support only the lowlevelnotions of threads and shared memory, forcing developersto reason about these notions instead of the high-levelconcurrency models they chose.This paper proposes a concurrency-agnostic debuggerprotocol that decouples the debugger from the concurrencymodels employed by the target application. As a result, theunderlying language runtime can define custom breakpoints,stepping operations, and execution events for each concurrencymodel it supports, and a debugger can expose themwithout having to be specifically adapted.We evaluated the generality of the protocol by applying itto SOMns, a Newspeak implementation, which supports adiversity of concurrency models including communicatingsequential processes, communicating event loops, threadsand locks, fork/join parallelism, and software transactionalmemory. We implemented 21 breakpoints and 20 steppingoperations for these concurrency models. For none of these,the debugger needed to be changed. Furthermore, we visualizeall concurrent interactions independently of a specificconcurrency model. To show that tooling for a specific concurrencymodel is possible, we visualize actor turns andmessage sends separately.

KW - Breakpoints

KW - Concurrency

KW - Debugging

KW - Stepping

KW - Tooling

KW - Visualization

UR - http://www.scopus.com/inward/record.url?scp=85037065958&partnerID=8YFLogxK

U2 - 10.1145/3133841.3133842

DO - 10.1145/3133841.3133842

M3 - Conference paper

SP - 3

EP - 14

BT - 13th ACM SIGPLAN International Symposium on Dynamic Languages (DLS 2017)

A2 - Ancona, Davide

PB - ACM

ER -

ID: 35598238