An Empirical Study on Performance Bugs for Highly Configurable
Detecting, Localizing, and Optimizing Synchronization Bottlenecks (SyncProf)
Writing concurrent programs is a challenge because developers must consider both functional correctness and
performance requirements. Numerous program analyses and testing techniques have been proposed to detect functional
faults, e.g., caused by incorrect synchronization. However, little work has been done to help developers address
performance problems in concurrent programs, e.g., because of inefficient synchronization.
SyncProf is a concurrency-focused profiling approach that helps in detecting,
localizing, and optimizing synchronization bottlenecks. In contrast to traditional profilers,
SyncProf repeatedly executes a program with various inputs and summarizes the observed performance behavior.
A key novelty is a graph-based representation of relations between critical sections, which is the basis for
computing the performance impact of critical sections, for identifying the root cause of a bottleneck,
and for suggesting optimization strategies to the developer. We evaluate SyncProf on 19 versions of eight
C/C++ projects with both known and previously unknown synchronization bottlenecks. The results show that
SyncProf effectively localizes the root causes of these bottlenecks with higher precision than a state of the art lock
contention profiler and that it suggests valuable strategies to avoid the bottlenecks.
Testing for Virtual Devices (VDTest)
Automatically Predicting Configuration Bug Reports and Extracting Configuration Options (CoLUA)
Predicting Testability of Concurrent Programs
Regression Testing for Concurrent Programs (SimRT)
Concurrent programs are prone to various classes of difficult-to-detect faults, of which data races are particularly prevalent.
Prior work has attempted to increase the cost-effectiveness of approaches for testing for data races by employing race detection
techniques, but to date, no work has considered cost-effective approaches for re-testing for races as programs evolve.
SimRT is an automated regression testing framework for use in detecting races introduced by code modifications.
SimRT employs a regression test selection technique, focused on sets of program elements related to race detection,
to reduce the number of test cases that must be run on a changed program to detect races that occur due to code modifications,
and it employs a test case prioritization technique to improve the rate at which such races are detected.
Our empirical study of SimRT reveals that it is more efficient and effective for revealing races than other approaches,
and that its constituent test selection and prioritization components each contribute to its performance.
Testing for System-level Elusive Faults (SimExplorer)
Modern computer software systems are prone to various classes of runtime faults due to their reliance
on features such as concurrency and peripheral devices such as sensors.
Testing remains a common method for uncovering faults in these systems.
However, commonly used testing techniques that execute the program with test
inputs and inspect program out- puts to detect failures are often ineffective on
these systems. In addition, existing testing techniques focus primarily on single applications,
neglecting elusive faults that occur at the whole-system level due to complex system event interactions.
SIMEXPLORER allows engineers to effectively test for subtle and intermittent faults in modern software systems by
providing them with greater observability and controllability. The testing framework first employs dynamic analysis
techniques to observe system execution, identify program locations of interest, and report faults related to oracles.
It next employs virtualization to achieve fine-grained controllability that exercises event interleavings that are likely
to expose faults. The framework also supports testing of evolving software.
The ultimate benefit of SimExplorer is its ability to test for broader classes of elusive faults that
cannot be effectively detected by existing approaches.
These faults include: (1) concurrency faults between applications and hardware interrupts;
(2) concurrency faults caused by improper shared resource accesses among multiple processes,
and software signals; (3) violations of expected worst-case interrupt latencies (WCILs);
and (4) data races induced in evolving software.