Identifying a Unifying Mechanism for the Implementation of Concurrency Abstractions on Multi-language Virtual Machines

Marr, Stefan; D'Hondt, Theo

doi:10.1007/978-3-642-30561-0_13

Cited by 5 publications

(4 citation statements)

References 27 publications

(16 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…From the selected languages we derived a list of debuggers by including the standard debugger for each language (if one exists) and possibly others that are used by a significant number of developers (e.g., debuggers used by popular development environments). The debuggers covered by our survey are: Java Debugger Interface 13 (Java), Visual Studio debugger 14 (C # , C ++ , Visual Basic .NET, JavaScript), PyDev 15 (Python), pdb 16 (Python), perldebug 17 (Perl), GDB 18 (C), Chrome development tools 19 (JavaScript), XDebug 20 (PHP), Zend Debugger 21 (PHP), debug.rb 22 (Ruby), LLDB 23 (Objective-C, Swift), GHCi debugger (Haskell) 24 , Concurrent Haskell debugger [6] (Haskell), SISC debugger 25 (Scheme), Scala asynchronous debugger 26 (Scala), Self debugger 27 (Self), ocamldebug 28 (OCaml), XPCE debugger 29 (Prolog), Pharo debugger. 30…”

Section: Selected Debuggersmentioning

confidence: 99%

See 1 more Smart Citation

Improving live debugging of concurrent threads through thread histories

Leske

Chiș²,

Nierstrasz

2018

Science of Computer Programming

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

Section: Selected Debuggersmentioning

confidence: 99%

“…We further showed how to apply it to local and remote promises. Nonetheless, in practice there exist many other concurrent models as discussed by Marr and D'Hondt [22]. Examples include processes, actors and active objects.…”

Section: Supporting Other Concurrent Modelsmentioning

confidence: 99%

Improving live debugging of concurrent threads through thread histories

Leske

Chiș²,

Nierstrasz

2018

Science of Computer Programming

View full text Add to dashboard Cite

show abstract

“…The ownership-based metaobject protocol (OMOP) proposed by Marr and D'Hondt [2012] is an example of such a MOP. It provides framework and DSL implementers with abstractions to guarantee, e. g., isolation between actors.…”

Section: Metaobject Protocols and Dslsmentioning

confidence: 99%

Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises

2015

Self Cite

View full text Add to dashboard Cite

Runtime metaprogramming enables many useful applications and is often a convenient solution to solve problems in a generic way, which makes it widely used in frameworks, middleware, and domain-specific languages. However, powerful metaobject protocols are rarely supported and even common concepts such as reflective method invocation or dynamic proxies are not optimized. Solutions proposed in literature either restrict the metaprogramming capabilities or require application or library developers to apply performance improving techniques.For overhead-free runtime metaprogramming, we demonstrate that dispatch chains, a generalized form of polymorphic inline caches common to self-optimizing interpreters, are a simple optimization at the language-implementation level. Our evaluation with self-optimizing interpreters shows that unrestricted metaobject protocols can be realized for the first time without runtime overhead, and that this optimization is applicable for just-in-time compilation of interpreters based on meta-tracing as well as partial evaluation. In this context, we also demonstrate that optimizing common reflective operations can lead to significant performance improvements for existing applications.

show abstract

“…Recent attempts at re-implementing or re-engineering the Squeak VM have shown that good performance is difficult to achieve [2,13,17]. To us, Squeak appeared to be too slow to actually emulate in JavaScript, and too complex to subdivide into an interpreter layer and browser graphics layer.…”

Section: Motivationmentioning

confidence: 99%

SqueakJS

Freudenberg¹,

Ingalls²,

Felgentreff³

et al. 2014

Proceedings of the 10th ACM Symposium on Dynamic Languages

View full text Add to dashboard Cite

We report our experience in implementing SqueakJS, a bitcompatible implementation of Squeak/Smalltalk written in pure JavaScript. SqueakJS runs entirely in the Web browser with a virtual file system that can be directed to a server or client-side storage. Our implementation is notable for simplicity and performance gained through adaptation to the host object memory and deployment leverage gained through the Lively Web development environment. We present several novel techniques as well as performance measurements for the resulting virtual machine. Much of this experience is potentially relevant to preserving other dynamic language systems and making them available in a browser-based environment.

show abstract

Identifying a Unifying Mechanism for the Implementation of Concurrency Abstractions on Multi-language Virtual Machines

Cited by 5 publications

References 27 publications

Improving live debugging of concurrent threads through thread histories

Improving live debugging of concurrent threads through thread histories

Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises

SqueakJS

Contact Info

Product

Resources

About