Information Technology Reference
In-Depth Information
3.2
Dynamic Analysis
Dynamic analysis is applied to debug the IL program with respect to the input
stimuli of a failure trace. Instead of debugging all parts of an IL program,
the failure trace is analyzed to determine the
sensitive path
.
For this purpose, the failure trace is simulated on the CDFG to obtain the
assigned values on each node in the CDFG at first. Afterwards, an affect anal-
ysis is performed based on path tracing [1], i.e., a path from an observed faulty
behavior at an observation point to the primary inputs is computed [21]. The
path is extracted by following the controlling values, i.e., the operations that
are responsible for the current value at the observation point
v
faulty
(
.In
difference to dynamic slicing [2], path tracing returns statements that are
re-
sponsible
for the current value at the observation points instead of statements
that
might affect
the value only.
For example, the controlling paths for a logical
AND
with output value
OP
i
)
0
are the inputs with value
0
assigned. An input with
1
assigned is not
responsible for the output value
and thus cannot be responsible for the
faulty behavior. If both inputs are controlling paths, the algorithm follows
both paths.
The dynamic analysis is performed for all observation points
OP
i
and all
m
failure traces in linear time. Thereby, each failure trace is simulated on the
CDFG, followed by path tracing. All nodes on the sensitive path from any
observation point are potential fault candidates. Like for the static analysis,
either the intersection or the union is computed for all sensitive paths while
assuming single faults or multiple faults, respectively [21].
0
3.3
Correction-Based Debugging
Static analysis and the dynamic debugging technique use information about
the observation points
OP
i
and the input stimuli only. Correction-based de-
bugging is a technique to obtain higher accuracy by considering additionally
the expected output responses at the observation points
OP
i
[17]. The input
for the debugging algorithm is a CDFG, a set of
m
failure traces and the
expected responses for each observation point
v
expected
(
.
In contrast to static analysis and debugging based on simulation, the
returned fault candidates are proved to fix the failure trace while assuming a
non-deterministic behavior of a component. That is, the output behavior of
a component is replaced by an unconstrained new input that may have any
value assigned. This allows to check whether the application of any correction
at the component fixes the faulty behavior at all observation points, i.e., it
holds
OP
i
)
R
.
For each component
correction logic
is inserted in the CDFG as described
in [9]. That is, each right-hand side of an expression and all control predicates
can be replaced by a non-deterministic value. One
abnormal predicate
for each
component controls the activation at all expressions and control predicates
∀
i
:
v
expected
(
OP
i
)=
v
faulty
(
OP
i
)
,
1
≤
i
≤
