5,240 research outputs found
Fault Localization in Multi-Threaded C Programs using Bounded Model Checking (extended version)
Software debugging is a very time-consuming process, which is even worse for
multi-threaded programs, due to the non-deterministic behavior of
thread-scheduling algorithms. However, the debugging time may be greatly
reduced, if automatic methods are used for localizing faults. In this study, a
new method for fault localization, in multi-threaded C programs, is proposed.
It transforms a multi-threaded program into a corresponding sequential one and
then uses a fault-diagnosis method suitable for this type of program, in order
to localize faults. The code transformation is implemented with rules and
context switch information from counterexamples, which are typically generated
by bounded model checkers. Experimental results show that the proposed method
is effective, in such a way that sequential fault-localization methods can be
extended to multi-threaded programs.Comment: extended version of paper published at SBESC'1
Validity-Preserving Delta Debugging via Generator
Reducing test inputs that trigger bugs is crucial for efficient debugging.
Delta debugging is the most popular approach for this purpose. When test inputs
need to conform to certain specifications, existing delta debugging practice
encounters a validity problem: it blindly applies reduction rules, producing a
large number of invalid test inputs that do not satisfy the required
specifications. This overall diminishing effectiveness and efficiency becomes
even more pronounced when the specifications extend beyond syntactical
structures. Our key insight is that we should leverage input generators, which
are aware of these specifications, to generate valid reduced inputs, rather
than straightforwardly performing reduction on test inputs. In this paper, we
propose a generator-based delta debugging method, namely GReduce, which derives
validity-preserving reducers. Specifically, given a generator and its
execution, demonstrating how the bug-inducing test input is generated, GReduce
searches for other executions on the generator that yield reduced, valid test
inputs. To evaluate the effectiveness, efficiency, and versatility of GReduce,
we apply GReduce and the state-of-the-art reducer Perses in three domains:
graphs, deep learning models, and JavaScript programs. The results of GReduce
are 28.5%, 34.6%, 75.6% in size of those from Perses, and GReduce takes 17.5%,
0.6%, 65.4% time taken by Perses
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
On Performance Debugging of Unnecessary Lock Contentions on Multicore Processors: A Replay-based Approach
Locks have been widely used as an effective synchronization mechanism among
processes and threads. However, we observe that a large number of false
inter-thread dependencies (i.e., unnecessary lock contentions) exist during the
program execution on multicore processors, thereby incurring significant
performance overhead. This paper presents a performance debugging framework,
PERFPLAY, to facilitate a comprehensive and in-depth understanding of the
performance impact of unnecessary lock contentions. The core technique of our
debugging framework is trace replay. Specifically, PERFPLAY records the program
execution trace, on the basis of which the unnecessary lock contentions can be
identified through trace analysis. We then propose a novel technique of trace
transformation to transform these identified unnecessary lock contentions in
the original trace into the correct pattern as a new trace free of unnecessary
lock contentions. Through replaying both traces, PERFPLAY can quantify the
performance impact of unnecessary lock contentions. To demonstrate the
effectiveness of our debugging framework, we study five real-world programs and
PARSEC benchmarks. Our experimental results demonstrate the significant
performance overhead of unnecessary lock contentions, and the effectiveness of
PERFPLAY in identifying the performance critical unnecessary lock contentions
in real applications.Comment: 18 pages, 19 figures, 3 table
Enhancing Formal Modelling Tool Support with Increased Automation
Progress report for the qualification exam report for PhD Student Kenneth Lausdahl. Initial work on enhancing tool support for the formal method VDM and the concept of unifying a abstract syntax tree with the ability for isolated extensions is described. The tool support includes a connection to UML and a test automation principle based on traces written as a kind of regular expressions
- …