A promising approach for debugging remote promises

Leske, Max; Chiș, Andrei; Nierstrasz, Oscar

doi:10.1145/2991041.2991059

Cited by 6 publications

(5 citation statements)

References 11 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In this case, the debugger is again missing information that can be dispersed over different call-stack(s): part of the application code, potentially related to the error, is in another thread or has already finished executing. This observation lead to different domain-specific debugging techniques whose goal is to reconstruct causal relations in asynchronous communication to offer an asynchronous track trace [7,12,17]. In this paper, we explore a more general solution to relate information present on different stacks.…”

Section: Listing 1 a Failing Promisementioning

confidence: 99%

“…Our approach takes inspiration from Leske et al [12], who proposed a debugging model for promises in which the call-stack that leads to the generation of the promise is linked to the one of the execution of the promise through proxies. However, our approach potentially applies not only to promises but also to other asynchronous execution models such as the actor model.…”

Section: Relating Dispersed Debugging Informationmentioning

confidence: 99%

“…Other approaches [1,18] propose a graph visualization of the state of the promise, based on run-time information about the asynchronous promise, to help developers understand the execution. The closest work is Leske et al [12] which describe an approach in which the stack of a failing promise execution is linked with the stack of the promising thread, at the point of the promise creation. The developer can then debug a single stack that combines both the frames leading to the promise creation, and the ones of the promise execution.…”

Section: Related Workmentioning

confidence: 99%

See 2 more Smart Citations

Framework-aware debugging with stack tailoring

Marra

Polito

Boix

2020

Proceedings of the 16th ACM SIGPLAN International Symposium on Dynamic Languages

View full text Add to dashboard Cite

Debugging applications that execute within a framework is not always easy: the call-stack offered to developers is often a mix-up of stack frames that belong to different frameworks, introducing an unnecessary noise that prevents developers from focusing on the debugging task. Moreover, relevant application code is not always available in the call-stack because it may have already returned, or is available in another thread. In such cases, manually gathering all relevant information from these different sources is not only cumbersome but also costly.In this paper we introduce Sarto, a call-stack instrumentation layer that allows developers to tailor the stack to make debugging framework-aware. The goal is to improve the quality and amount information present in the call-stack to reduce debugging time without impacting the execution time. Sarto proposes a set of six stack operations that combined hide irrelevant information, introduce missing information, and relate dispersed debugging sources before this is fed to the debugger.We validate Sarto by applying it to four application cases using inherently different frameworks: unit testing, web server, remote promises and big data processing. We showcase our experiences in using Sarto in the different frameworks, and perform some performance benchmarks to demonstrate that Sarto does not generate noticeable overhead when instrumenting a call-stack. We also show that our solution reduces by half the amount of data stored to debug similar exceptions happening in a parallel setup.CCS Concepts: • Software and its engineering → Application specific development environments; Integrated and visual development environments; Error handling and recovery; Software testing and debugging.

show abstract

Section: Listing 1 a Failing Promisementioning

confidence: 99%

Section: Relating Dispersed Debugging Informationmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Framework-aware debugging with stack tailoring

Marra

Polito

Boix

2020

Proceedings of the 16th ACM SIGPLAN International Symposium on Dynamic Languages

View full text Add to dashboard Cite

show abstract

“…In previous work [20] we presented the prototype of a promise library for Pharo that is capable of executing remote promises using Seamless [27], a framework for distributed computing. To provide transparent communication with remote threads, Seamless can use proxies, which is what our model relies upon.…”

Section: Seamlessmentioning

confidence: 99%

“…We discussed the approach for debugging remote promises in a previous work [20]. We also sketched the approach for debugging local threads in a short two-page paper [19].…”

Section: Introductionmentioning

confidence: 99%

Improving live debugging of concurrent threads through thread histories

Leske

Chiș²,

Nierstrasz

2018

Science of Computer Programming

Self Cite

View full text Add to dashboard Cite

Concurrency issues are inherently harder to identify and fix than issues in sequential programs, due to aspects like indeterminate order of access to shared resources and thread synchronisation. Live debuggers are often used by developers to gain insights into the behaviour of concurrent programs by exploring the call stacks of threads. Nevertheless, contemporary live debuggers for concurrent programs are usually sequential debuggers augmented with the ability to display different threads in isolation. To these debuggers every thread call stack begins with a designated start routine and the calls that led to the creation of the thread are not visible, as they are part of a different thread. This requires developers to manually link stack traces belonging to related but distinct threads, adding another burden to the already difficult act of debugging concurrent programs. To improve debugging of concurrent programs we address the problem of incomplete call stacks in debuggers through a thread and debugger model that enables live debugging of child threads within the context of their parent threads. The proposed debugger operates on a virtual thread that merges together multiple relevant threads. To better understand the features of debuggers for concurrent programs we present an in-depth discussion of the concurrency related features in current live debuggers. We test the applicability of the proposed model by instantiating it for simple threads, local and remote promises, and a remote object-oriented database. Starting from these use cases we further discuss implementation details ensuring a practical approach.

show abstract

Design and Implementation of an Efficient Debugging Environment for DSP

Pei

2018

2018 2nd IEEE Advanced Information Management,Communicates,Electronic and Automation Control Conference (IMCEC)

View full text Add to dashboard Cite

A promising approach for debugging remote promises

Cited by 6 publications

References 11 publications

Framework-aware debugging with stack tailoring

Framework-aware debugging with stack tailoring

Improving live debugging of concurrent threads through thread histories

Design and Implementation of an Efficient Debugging Environment for DSP

Contact Info

Product

Resources

About