Fast, Flexible, Polyglot Instrumentation Support for Debuggers and other Tools

@article{Vanter2018FastFP,
  title={Fast, Flexible, Polyglot Instrumentation Support for Debuggers and other Tools},
  author={Michael L. Van de Vanter and Chris Seaton and Michael Haupt and Christian Humer and Thomas W{\"u}rthinger},
  journal={ArXiv},
  year={2018},
  volume={abs/1803.10201}
}
Context: Software development tools that interact with running programs such as debuggers, profilers, and dynamic analysis frameworks are presumed to demand difficult tradeoffs among implementation complexity (cost), functionality, usability, and performance. Among the many consequences, tools are often delivered late (if ever), have limited functionality, require non-standard configurations, and impose serious performance costs on running programs. Inquiry: Can flexible tool support become a… 
Exploring Aspects of Polyglot High-Performance Virtual Machine GraalVM
TLDR
Graal is an aggressively optimizing compiler implementing common compiler optimizations, with emphasis on outstanding inlining and escape analysis algorithms, and this paper compares Graal with some of the best-specialized competitors, and presents the results tested within an academic environment.
Exploring Aspects of Polyglot High-Performance Virtual Machine GraalVM
  • M. Sipek, B. Mihaljevic, A. Radovan
  • Computer Science
    2019 42nd International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO)
  • 2019
TLDR
Graal is an aggressively optimizing compiler implementing common compiler optimizations, with emphasis on outstanding inlining and escape analysis algorithms, and this paper compares Graal with some of the best-specialized competitors, and presents the results tested within an academic environment.
Monilogging for executable domain-specific languages
TLDR
This work proposes a language-agnostic, unifying framework for runtime monitoring and logging and demonstrates how it can be used to define loggers, runtime monitors and combinations of the two, aka.
Example-based live programming for everyone: building language-agnostic tools for live programming with LSP and GraalVM
TLDR
This paper shows how an ELP system can be built in a language-agnostic way by leveraging the Language Server Protocol (LSP) and language implementation frameworks such as GraalVM's Truffle.
A concurrency-agnostic protocol for multi-paradigm concurrent debugging tools
TLDR
A concurrency-agnostic debugger protocol is proposed that decouples the debugger from the concurrency models employed by the target application, and the underlying language runtime can define custom breakpoints, stepping operations, and execution events for each concurrency model it supports, and a debugger can expose them without having to be specifically adapted.
Multi-language dynamic taint analysis in a polyglot virtual machine
TLDR
TruffleTaint is introduced, a platform for multi-language dynamic taint analysis that uses language-independent techniques for propagating taint labels to overcome the language boundary but still allows for language-specific taint propagation rules.
Debugging native extensions of dynamic languages
TLDR
GraalVM can execute programs implemented in various dynamic programming languages and, by using the LLVM-IR interpreter Sulong, also their native extensions, and support for source-level debugging to Sulong was added based on GraalVM's debugging framework by associating run-time debug information from the LL emulator level to the original program code.
GraalSqueak
Polyglot programming provides software developers with a broader choice in terms of software libraries and frameworks available for building applications. Previous research and engineering activities
GraalSqueak: toward a smalltalk-based tooling platform for polyglot programming
TLDR
This paper presents GraalSqueak, a Squeak/Smalltalk virtual machine implementation for the GraalVM, and evaluates the performance of the language and the programming environment, and discusses how the system can be used as a tooling platform for polyglot programming.
Sub-method, partial behavioral reflection with Reflectivity: Looking back on 10 years of use
TLDR
Reflectivity, its API, its implementation and its usage in Pharo are presented, and it is shown how it has been used as a basic building block of many innovative ideas, as well as a mature framework for unanticipated, non-intrusive and partial behavioral reflection based on AST annotation.
...
1
2
3
...

References

SHOWING 1-10 OF 36 REFERENCES
Debugging at Full Speed
TLDR
A prototype debugger for Ruby is implemented on the Truffle/Graal platform, demonstrating that basic debugging services can be implemented with modest effort and without significant impact on program performance and indicates that such support could be permanently enabled in production environments.
Building debuggers and other tools: we can "have it all"
TLDR
By building instrumentation directly into the core of a high-performance language implementation framework, tool-support can be always on, with confidence that optimization will apply uniformly to instrumentation and result in near zero overhead.
Maxine: An approachable virtual machine for, and in, java
TLDR
The Maxine VM, a metacircular Java VM implementation, has aggressively used these features since its inception and a co-designed companion tool, the Maxine Inspector, offers integrated debugging and visualization of all aspects of the VM's runtime state.
Techniques and applications for guest-language safepoints
TLDR
An API for using safepoints in languages that were implemented under the Truffle language implementation framework on the Java Virtual Machine is described and several applications of the API are shown to implement useful guest-language functionality.
An Efficient and Generic Event-based Profiler Framework for Dynamic Languages
TLDR
A generic profiler framework for dynamic languages to minimize the recurring implementation effort and serves three purposes: helps users to find the bottlenecks in programs, helps language implementers to improve the performance of their language implementation, and helps to compare and evaluate different languages on cross-language benchmarks.
Trufflereloader: a low-overhead language-neutral reloader
TLDR
TruffleReloader is built, a reusable dynamic updating solution, on top of the Truffle language implementation framework, and it is shown how this approach reduces the effort required to add dynamic update support for existing and future languages.
Jalangi: a selective record-replay and dynamic analysis framework for JavaScript
TLDR
This paper presents a simple yet powerful framework, called Jalangi, for writing heavy-weight dynamic analyses, which incorporates two key techniques: selective record-replay, a technique which enables to record and to faithfully replay a user-selected part of the program, and shadow values and shadow execution, which enables easy implementation of heavy- Weight dynamic analyses.
Application of the HotSwap Technology to Advanced Profiling
A functionality to support dynamic class evolution in running applications has been recently implemented in the Sun’s Java HotSpottm Virtual Machine. This functionality was initially considered
Optimizing R language execution via aggressive speculation
TLDR
Novel optimizations backed up by aggressive speculation techniques and implemented within FastR, an alternative R language implementation, utilizing Truffle -- a JVM-based language development framework developed at Oracle Labs are described.
Efficient dynamic analysis for Node.js
TLDR
A new dynamic analysis framework for JavaScript and Node.js called NodeProf that allows dynamic analyses to be written in Java and JavaScript with compatibility to Jalangi, a state-of-the-art code-level JavaScript instrumentation framework.
...
1
2
3
4
...