Xiangyu Li

School of Computer Science

College of Computing

Georgia Institute of Technology

Date: Friday, December 6, 2019

Time: 3:00pm - 5:00pm (EST)

Location: Klaus 3100

Committee:

Alessandro Orso - Advisor, School of Computer Science, Georgia Institute of Technology

David Devecsery - School of Computer Science, Georgia Institute of Technology

Qirun Zhang - School of Computer Science, Georgia Institute of Technology

Spencer Rugaber - College of Computing, Georgia Institute of Technology

Marcelo d'Amorim - Department of Computer Science, Federal University of Pernambuco

Abstract:

Software debugging is an expensive activity that is responsible for a significant part of

software maintenance cost. In particular, locating faulty code (i.e., fault localization) is one

of the most challenging parts. In the past years, researchers have proposed many techniques

that aim at fully automating the task of fault localization. Although these techniques are

shown to be effective in reducing the amount of code developers need to inspect to locate

faults, there is growing evidence that they provide developers with limited help in realistic

debugging scenarios. I believe that a practical automated debugging technique should have

human developers at the center of the debugging process rather than trying to completely

replace them.

In this proposal, I present three projects, two completed and one on-going, that define

techniques to support developer-centric automated debugging. First, I present Enlighten,

an interactive, feedback-driven fault localization technique. Enlighten supports and

automates developers’ debugging workflow as follows. It 1) uses traditional statistical fault

localization (SFL) to formulate an initial hypothesis of where the fault may be; 2) identifies

a relevant subset of execution that can help support or refute the formulated hypothesis;

3) presents the developer with a query about the identified execution subset in the form of

a correctness question about the input-output relation of the partial execution; 4) refines

its hypothesis of the fault by using the developer’s feedback; and 5) repeats these steps

until the fault is found. Second, I discuss my work on improving the accuracy of dynamic

slicing, which allows automated debugging techniques that rely on dynamic dependence

analysis to handle a broader range of faults. I present my finding that existing dynamic

dependence analysis techniques could miss the cause-effect relations between faults and the

observed failures if the faulty program states propagate via incorrect computation of

memory addresses. To address this limitation, I define the concept of potential memory-address

dependence, which explicitly represents this type of causal relations, and describe an

algorithm that computes it. Third, supporting the developer-centric, automated debugging

workflow, which requires collecting, analyzing, and navigating the typically massive amount

of information in the failing execution, can be extremely expensive for non-trivial software

and failures. In fact, many existing interactive debugging techniques are shown to work

well on short executions, but fail to scale to even modest-length executions. My on-going

project aims to address this limitation. By utilizing a record-and-replay system, the technique

efficiently recreates the failing execution, breaks it down into smaller time slices, and

analyzes these slices in a parallelized, and on-demand fashion. I expect this approach to

scale to realistic, potentially long program executions while providing short response time

in the interactive debugging process.