TuningFork Publications
2008
Languages and Performance Engineering: Method, Instrumentation, and Pedagogy
Doug Lea, David F. Bacon, David Grove
Proceedings of the 2008 SIGPLAN Workshop on Programming Language Curriculum, pp. 87--92, ACM
Abstract
Programs encounter increasingly complex and fragile mappings to computing platforms, resulting in performance characteristics that are often mysterious to students, practitioners, and even researchers. We discuss some steps toward an experimental methodology that demands and provides a deep understanding of complete systems, the necessary instrumentation and tools to support such a methodology, and a curriculum that teaches the methodology and tools as a fundamental part of the discipline.
2007
Realtime Garbage Collection
David F. Bacon
Queue 5(1), 40--49, ACM, 2007
Abstract
Traditional computer science deals with the computation of correct results. Realtime systems interact with the physical world, so they have a second correctness criterion: they have to compute the correct result within a bounded amount of time. Simply building functionally correct software is hard enough. When timing is added to the requirements, the cost and complexity of building the software increase enormously.
Real-Time Music Synthesis in Java Using the Metronome Garbage Collector
Joshua Auerbach, David F. Bacon, Florian B"omers, Perry Cheng
Proceedings of the International Computer Music Conference, 2007
Abstract (slides)
Automatic memory management via garbage collection is the key to the safety, portability, and high productivity of modern programming languages like Java. However, until now no truly real-time garbage collector has existed for Java. As a result, the extreme real-time requirements of interactive music synthesis and processing have made it impossible to build such systems in Java.
We have developed a hard real-time garbage collector, called Metronome, around which IBM has built a production real-time Java virtual machine running on a real-time variant of Redhat Enterprise Linux. In this paper we demonstrate the real-time capabilities of our virtual machine with a MIDI music synthesizer that we built entirely in standard Java using the full object-oriented feaures of the language.
We show that even with the addition of another thread allocating 8 MB/second of data, our garbage collector is able to sustain error-free 44 KHz music synthesis down to buffer sizes of 1ms, achieving keyboard-to-speaker latencies of 5.0 +/- 0.75ms, comparable to a Kurzweil K2000R synthesizer (3.9 +/- 1ms) and suitable for high-fidelity interactive performance.
TuningFork: a Platform for Visualization and Analysis of Complex Real-Time Systems
David F. Bacon, Perry Cheng, David Grove
Companion to the 22nd ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, pp. 854--855, ACM, 2007
Abstract
Debugging the timing behavior of real-time systems is notoriously difficult, and with a new generation of complex systems consisting of tens of millions of lines of code, the difficulty is increasing enormously. We have developed TuningFork, a tool especially designed for visualization and analysis of large-scale real-time systems. TuningFork is capable of recording high-frequency events at sub-microsecond resolution with minimal perturbation. Users can visualize system activity online in real-time and interactively explore the data. Data can be gathered from multiple layers and/or components and synthesized into visualizations that illuminate whole system interactions. Interactive exploration of hypothesis is naturally supported by direct manipulation to quickly build up complex visualizations.
2006
On-Line Visualization and Analysis of Real-Time Systems with TuningFork (demonstration)
David F. Bacon, Perry Cheng, Daniel Frampton, David Grove, Matthias Hauswirth, V. T. Rajan
Proceedings of the 15th International Conference on Compiler Construction, pp. 96-100, Springer, 2006
Abstract
TuningFork is an online, scriptable data visualization and analysis tool that supports the development and continuous monitoring of real-time systems. While TuningFork was originally designed and tested for use with a particular real-time Java Virtual Machine, the architecture has been designed from the ground up for extensibility by leveraging the Eclipse plug-in architecture. This allows different client programs to design custom data formats, new visualization and analysis components, and new export formats. The TuningFork views allow the visualization of data from time scales of microseconds to minutes, enabling rapid understanding and analysis of system behavior.
Eventrons: a Safe Programming Construct for High-Frequency Hard Real-Time Applications
Daniel Spoonhower, Joshua Auerbach, David F. Bacon, Perry Cheng, David Grove
Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation, pp. 283--294, ACM, 2006
Abstract
While real-time garbage collection has achieved worst-case latencies on the order of a millisecond, this technology is approaching its practical limits. For tasks requiring extremely low latency, and especially periodic tasks with frequencies above 1 KHz, Java programmers must currently resort to the NoHeapRealtimeThread construct of the Real-Time Specification for Java. This technique requires expensive run-time checks, can result in unpredictable low-level exceptions, and inhibits communication with the rest of the garbage-collected application. We present Eventrons, a programming construct that can arbitrarily preempt the garbage collector, yet guarantees safety and allows its data to be visible to the garbage-collected heap. Eventrons are a strict subset of Java, and require no run-time memory access checks. Safety is enforced using a data-sensitive analysis and simple run-time support with extremely low overhead. We have implemented Eventrons in IBM's J9 Java virtual machine, and present experimental results in which we ran Eventrons at frequencies up to 22 KHz (a 45 us period). Across 10 million periods, 99.997\% of the executions ran within 10 us of their deadline, compared to 99.999\% of the executions of the equivalent program written in C.
2005
High-Level Real-Time Programming in Java
David F. Bacon, Perry Cheng, David Grove, Michael Hind, V. T. Rajan, Eran Yahav, Matthias Hauswirth, Christoph M. Kirsch, Daniel Spoonhower, Martin T. Vechev
Proceedings of the Fifth ACM International Conference on Embedded Software, pp. 68--78, ACM, 2005
Abstract (slides)
Real-time systems have reached a level of complexity beyond the scaling capability of the low-level or restricted languages traditionally used for real-time programming.While Metronome garbage collection has made it practical to use Java to implement real-time systems, many challenges remain for the construction of complex real-time systems, some specific to the use of Java and others simply due to the change in scale of such systems.The goal of our current research is the creation of a comprehensive Java-based programming environment and methodology for the creation of complex real-time systems. Our goals include construction of a provably correct real-time garbage collector capable of providing worst case latencies of 100 us, capable of scaling from sensor nodes up to large multiprocessors; specialized programming constructs that retain the safety and simplicity of Java, and yet provide sub-microsecond latencies; the extension of Java's ``write once, run anywhere'' principle from functional correctness to timing behavior; on-line analysis and visualization that aids in the understanding of complex behaviors; and a principled probabilistic analysis methodology for bounding the behavior of the resulting systems.While much remains to be done, this paper describes the progress we have made towards these goals.
