Summary The context of this work is a practical, open‐source visualization system, called JIVE, that supports two forms of runtime visualizations of Java programs – object diagrams and sequence diagrams. They capture, respectively, the current execution state and execution history of a Java program. These diagrams are similar to those found in the UML for specifying design–time decisions. In our work, we construct these diagrams at execution time, thereby ensuring continuity of notation from design to execution. In so doing, a few extensions to the UML notation are proposed in order to better represent runtime behavior. As sequence diagrams can become long and unwieldy, we present techniques for their compact representation. A key result in this paper is a novel labeling scheme based upon regular expressions to compactly represent long sequences and an O(r2) algorithm for computing these labels, where r is the length of the input sequence, based upon the concept of ‘tandem repeats’ in a sequence. Horizontal compaction greatly helps minimize the extent of white space in sequence diagrams by the elimination of object lifelines and also by grouping lifelines together. We propose a novel extension to the sequence diagram to deal with out‐of‐model calls when the lifelines of certain classes of objects are filtered out of the visualization, but method calls may occur between in‐model and out‐of‐model calls. The paper also presents compaction techniques for multi‐threaded Java execution with different forms of synchronization. Finally, we present experimental results from compacting the runtime visualizations of a variety of Java programs and execution trace sizes in order to demonstrate the practicality and efficacy of our techniques. Copyright © 2016 John Wiley & Sons, Ltd.
Hard real-time systems have stringent timing and resource requirements. As such, debugging and tracing such systems often requires low-level hardware support, and online debugging is usually precluded entirely. In other areas, however, visual debugging has greatly improved program understanding and late cycle development times for nonreal-time applications. In this paper, we introduce a visual test and debug framework for hard real-time Java applications built around the JIVE platform and realized in the Fiji virtual machine.Our framework, called JI.FI ["dZIfi], provides high-level debugging support over low-level execution traces. JI.FI provides both powerful visualizations and real-time centric temporal query support. To ensure preservation of the real-time characteristics of the application being tested and debugged, JI.FI leverages a real-time event log infrastructure that logs only relevant application and virtual machine level events, such as synchronization and modifications to priorities or thread state. Our performance results indicate that our logging infrastructure is suitable for hard real-time systems, as the performance impact is both uniform and quantifiable. 2457dumps, requiring hardware support to be effective. This support is realized in the form of specific logic for capturing and filtering traces (logs), as well as buffers to store the trace itself. Unfortunately, such a setup only supports offline debugging via stored hardware traces.The loss of online symbolic debugging with breakpoints, stop-and-examine capabilities, and direct manipulation of program state due to real-time requirements creates a need for a replacement debugging technology. Pervasive software tracing with predictable performance coupled with offline tools capable of reconstructing detailed, symbolic debugger-style call graphs, and symbolic traces can help fill this need. Although many tools exist to help real-time embedded systems developers early in the software life-cycle, for instance to help debug models [5], only a handful of software tools exist for late life-cycle debugging [6].In this paper, we present the following contributions:1. An extensible visual debugging tool, JI.FI, for Java-based, hard real-time embedded systems built on the JIVE [7, 8] debugging platform. 2. A Java virtual machine (VM) independent, light-weight logging format to gather relevant debugging information for a given execution run. Unlike standard Java debug logging formats, this event log can be gathered in real-time. 3. A real-time aware temporal query processing engine able to answer temporal queries about the execution of the program. 4. An extension to the JI.FI system for debugging Safety Critical Java (SCJ) applications. 5. A detailed performance evaluation of the JI.FI system. This paper is an extended version of a work [9] that was previously published in the Proceedings of ACM JTRES 2012. This version includes details on an SCJ-specific extension to JI.FI and related evaluation; additional material on queries, including examples and ...
scite is a Brooklyn-based organization that helps researchers better discover and understand research articles through Smart Citations–citations that display the context of the citation and describe whether the article provides supporting or contrasting evidence. scite is used by students and researchers from around the world and is funded in part by the National Science Foundation and the National Institute on Drug Abuse of the National Institutes of Health.
customersupport@researchsolutions.com
10624 S. Eastern Ave., Ste. A-614
Henderson, NV 89052, USA
Copyright © 2024 scite LLC. All rights reserved.
Made with 💙 for researchers
Part of the Research Solutions Family.