6,428 research outputs found
On-stack replacement, distilled
On-stack replacement (OSR) is essential technology for adaptive optimization, allowing changes to code actively executing in a managed runtime. The engineering aspects of OSR are well-known among VM architects, with several implementations available to date. However, OSR is yet to be explored as a general means to transfer execution between related program versions, which can pave the road to unprecedented applications that stretch beyond VMs. We aim at filling this gap with a constructive and provably correct OSR framework, allowing a class of general-purpose transformation functions to yield a special-purpose replacement. We describe and evaluate an implementation of our technique in LLVM. As a novel application of OSR, we present a feasibility study on debugging of optimized code, showing how our techniques can be used to fix variables holding incorrect values at breakpoints due to optimizations
Visual Debugging of Object-Oriented Systems with the Unified Modeling Language
The Department of Defense (DoD) is developing a Joint Battlespace Infosphere, linking a large number of data sources and user applications. Debugging and analysis tools are required to aid in this process. Debugging of large object-oriented systems is a difficult cognitive process that requires understanding of both the overall and detailed behavior of the application. In addition, many such applications linked through a distributed system add to this complexity. Standard debuggers do not utilize visualization techniques, focusing mainly on information extracted directly from the source code. To overcome this deficiency, this research designs and implements a methodology that enables developers to analyze, troubleshoot and evaluate object-oriented systems using visualization techniques. It uses the standard UML class diagram coupled with visualization features such as focus+context, animation, graph layout, color encoding and filtering techniques to organize and present information in a manner that facilitates greater program and system comprehension. Multiple levels of abstraction, from low-level details such as source code and variable information to high-level structural detail in the form of a UML class diagram are accessible along with views of the program s control flow. The methods applied provide a considerable improvement (up to 1110%) in the number of classes that can be displayed in a set display area while still preserving user context and the semantics of UML, thus maintaining system understanding. Usability tests validated the application in terms of three criteria software visualization, debugging, and general system usability
Space Efficient Breadth-First and Level Traversals of Consistent Global States of Parallel Programs
Enumerating consistent global states of a computation is a fundamental
problem in parallel computing with applications to debug- ging, testing and
runtime verification of parallel programs. Breadth-first search (BFS)
enumeration is especially useful for these applications as it finds an
erroneous consistent global state with the least number of events possible. The
total number of executed events in a global state is called its rank. BFS also
allows enumeration of all global states of a given rank or within a range of
ranks. If a computation on n processes has m events per process on average,
then the traditional BFS (Cooper-Marzullo and its variants) requires
space in the worst case, whereas ou r
algorithm performs the BFS requires space. Thus, we
reduce the space complexity for BFS enumeration of consistent global states
exponentially. and give the first polynomial space algorithm for this task. In
our experimental evaluation of seven benchmarks, traditional BFS fails in many
cases by exhausting the 2 GB heap space allowed to the JVM. In contrast, our
implementation uses less than 60 MB memory and is also faster in many cases
Coarse-grained parallel genetic algorithms: Three implementations and their analysis
Although solutions to many problems can be found using direct analytical methods such as those calculus provides, many problems simply are too large or too difficult to solve using traditional techniques. Genetic algorithms provide an indirect approach to solving those problems. A genetic algorithm applies biological genetic procedures and principles to a randomly generated collection of potential solutions. The result is the evolution of new and better solutions. Coarse-Grained Parallel Genetic Algorithms extend the basic genetic algorithm by introducing genetic isolation and distribution of the problem domain. This thesis compares the capabilities of a serial genetic algorithm and three coarse-grained parallel genetic algorithms (a standard parallel algorithm, a non-uniform parallel algorithm and an adaptive parallel algorithm). The evaluation is done using an instance of the traveling salesman problem. It is shown that while the standard course-grained parallel algorithm provides more consistent results than the serial genetic algorithm, the adaptive distributed algorithm out-performs them both. To facilitate this analysis, an extensible object-oriented library for genetic algorithms, encompassing both serial and coarse-grained parallel genetic algorithms, was developed. The Java programming language was used throughout
A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs
The actor model is an attractive foundation for developing concurrent
applications because actors are isolated concurrent entities that communicate
through asynchronous messages and do not share state. Thereby, they avoid
concurrency bugs such as data races, but are not immune to concurrency bugs in
general. This study taxonomizes concurrency bugs in actor-based programs
reported in literature. Furthermore, it analyzes the bugs to identify the
patterns causing them as well as their observable behavior. Based on this
taxonomy, we further analyze the literature and find that current approaches to
static analysis and testing focus on communication deadlocks and message
protocol violations. However, they do not provide solutions to identify
livelocks and behavioral deadlocks. The insights obtained in this study can be
used to improve debugging support for actor-based programs with new debugging
techniques to identify the root cause of complex concurrency bugs.Comment: - Submitted for review - Removed section 6 "Research Roadmap for
Debuggers", its content was summarized in the Future Work section - Added
references for section 1, section 3, section 4.3 and section 5.1 - Updated
citation
SPEEDY: An Eclipse-based IDE for invariant inference
SPEEDY is an Eclipse-based IDE for exploring techniques that assist users in
generating correct specifications, particularly including invariant inference
algorithms and tools. It integrates with several back-end tools that propose
invariants and will incorporate published algorithms for inferring object and
loop invariants. Though the architecture is language-neutral, current SPEEDY
targets C programs. Building and using SPEEDY has confirmed earlier experience
demonstrating the importance of showing and editing specifications in the IDEs
that developers customarily use, automating as much of the production and
checking of specifications as possible, and showing counterexample information
directly in the source code editing environment. As in previous work,
automation of specification checking is provided by back-end SMT solvers.
However, reducing the effort demanded of software developers using formal
methods also requires a GUI design that guides users in writing, reviewing, and
correcting specifications and automates specification inference.Comment: In Proceedings F-IDE 2014, arXiv:1404.578
UML Assisted Visual Debugging for Distributed Systems
The DOD is developing a Joint Battlespace Infosphere, linking a large number of data sources and user applications. To assist in this process, debugging and analysis tools are required. Software debugging is an extremely difficult cognitive process requiring comprehension of the overall application behavior, along with detailed understanding of specific application components. This is further complicated with distributed systems by the addition of other programs, their large size and synchronization issues. Typical debuggers provide inadequate support for this process, focusing primarily on the details accessible through source code. To overcome this deficiency, this research links the dynamic program execution state to a Unified Modeling Language (UML) class diagram that is reverse-engineered from data accessed within the Java Platform Debug Architecture. This research uses focus + context, graph layout, and color encoding techniques to enhance the standard UML diagram. These techniques organize and present objects and events in a manner that facilitates analysis of system behavior. High-level abstractions commonly used in system design support debugging while maintaining access to low-level details with an interactive display. The user is also able to monitor the control flow through highlighting of the relevant object and method in the display
- …