Efficient Testing of Concurrent Programs with Abstraction-Guided Symbolic Execution

Rungta, Neha; Mercer, Eric; Visser, Willem

doi:10.1007/978-3-642-02652-2_16

Cited by 30 publications

(16 citation statements)

References 26 publications

(34 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…However, none of those approaches can generate symbolic resource estimations, as our approach does, neither take advantage of a resource policy to guide the TDG process. The most related work to our resource-driven approach is [19], which proposes to use an abstraction of the program in order to guide symbolic execution and prune the execution tree as a way to scale up. An important difference is that our trace-based abstraction is an over-approximation of the actual paths which allows us to select the most expensive paths.…”

Section: Conclusion and Related Workmentioning

confidence: 99%

Resource-Driven CLP-Based Test Case Generation

Albert

Gómez-Zamalloa

Rojas

2012

Logic-Based Program Synthesis and Transformation

View full text Add to dashboard Cite

Abstract. Test Data Generation (TDG) aims at automatically obtaining test inputs which can then be used by a software testing tool to validate the functional behaviour of the program. In this paper, we propose resource-aware TDG, whose purpose is to generate test cases (from which the test inputs are obtained) with associated resource consumptions. The framework is parametric w.r.t. the notion of resource (it can measure memory, steps, etc.) and allows using software testing to detect bugs related to non-functional aspects of the program. As a further step, we introduce resource-driven TDG whose purpose is to guide the TDG process by taking resource consumption into account. Interestingly, given a resource policy, TDG is guided to generate test cases that adhere to the policy and avoid the generation of test cases which violate it.

show abstract

Section: Conclusion and Related Workmentioning

confidence: 99%

Resource-Driven CLP-Based Test Case Generation

Albert

Gómez-Zamalloa

Rojas

2012

Logic-Based Program Synthesis and Transformation

View full text Add to dashboard Cite

show abstract

“…Furthermore, we plan to investigate how to combine data-flow analyses like the one presented here with model checking. For instance, Rungta et al [2009] have recently shown how to effectively guide a model checker to problem points previously determined through a (generic) static analysis. Such an approach would allow programmers to rule out even more (if not all) false positives than Clara does.…”

Section: Resultsmentioning

confidence: 99%

Partially Evaluating Finite-State Runtime Monitors Ahead of Time

Bodden

Lam

Hendren

2012

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

Finite-state properties account for an important class of program properties, typically related to the order of operations invoked on objects. Many library implementations therefore include manually-written finite-state monitors to detect violations of finite-state properties at runtime. Researchers have recently proposed the explicit specification of finite-state properties and automatic generation of monitors from the specification. However, runtime monitoring only shows the presence of violations, and typically cannot prove their absence. Moreover, inserting a runtime monitor into a program under test can slow down the program by several orders of magnitude.In this work, we therefore present a set of four static whole-program analyses that partially evaluate runtime monitors at compile time, with increasing cost and precision. As we show, ahead-of-time evaluation can often evaluate the monitor completely statically. This may prove that the program cannot violate the property on any execution or may prove that violations do exist. In the remaining cases, the partial evaluation converts the runtime monitor into a residual monitor. This monitor only receives events from program locations that the analyses failed to prove irrelevant. This makes the residual monitor much more efficient than a full monitor, while still capturing all property violations at runtime.We implemented the analyses in Clara, a novel framework for the partial evaluation of AspectJ-based runtime monitors, and validated our approach by applying Clara to finite-state properties over several large-scale Java programs. Clara proved that most of the programs never violate our example properties. Some programs required monitoring, but in those cases Clara could often reduce the monitoring overhead to below 10%. We observed that several programs did violate the stated properties.

show abstract

“…Through this evaluation, PRSS was shown to be effective (some speedups more than 100x) for exploring various concurrent programs using JPF version 3.1.2 across a reasonably small number (5)(6)(7)(8)(9)(10)(11)(12)(13)(14)(15)(16)(17)(18)(19)(20) of parallel machines. However, it is not Paper Metric(s) Search Type Used Randomness Machine Configuration CAPP [8] Transitions Stateful Yes Cluster CAPP [8] Schedules Stateless Yes Cluster Controlling Factors [2] States Stateful Yes Cluster CTrigger [18] Time Stateless No Single machine Depth Bounding [11] States, Transitions, Time, Memory Stateful No Not specified Distributed Reachability [15] Time Stateless Yes Cluster Gambit [7] Time, Memory Hybrid Yes Not specified ICB [4] States, Time Hybrid No Not specified PENELOPE [19] Time Stateless No Not specified PRSS [3] States Stateful Yes Cluster Random Backtracking [12] States, Transitions Stateful Yes Not specified Swarm [5] States, Time, Memory Stateful Yes Single machine clear whether similar results could be obtained for (i) other concurrent programs, (ii) stateless exploration, (iii) different search strategy, or (iv) the latest version of JPF which incorporates many new optimizations.…”

Section: A Parallel Randomized State-space Searchmentioning

confidence: 98%

“…The techniques can be categorized in many different ways. One category of techniques consists of strategies that prioritize or select the exploration of certain parts of the state space by leveraging additional information or heuristics [4], [6]- [12]. A recent, promising strategy in this category is known as Iterative Context-Bounding (ICB) [4], which prioritizes exploration according to the number of preemptive context switches between threads.…”

Section: Introductionmentioning

confidence: 99%

Evaluating Machine-Independent Metrics for State-Space Exploration

Jagannath

Kirn

Lin

et al. 2012

2012 IEEE Fifth International Conference on Software Testing, Verification and Validation

View full text Add to dashboard Cite

Many recent advancements in testing concurrent programs can be described as novel optimization and heuristic techniques for exploring the tests of such programs. To empirically evaluate these techniques, researchers apply them on subject programs and capture a set of metrics that characterize the techniques' effectiveness. From a user's perspective, the most important metric is often the amount of real time required to find an error (if one exists), but using real time for comparison can be misleading because it is necessarily dependent on the machine configuration used for the experiments. On the other hand, using machine-independent metrics can be meaningless if they do not correlate highly with real time. As a result, it can be difficult to select metrics for valid comparisons among exploration techniques. This paper presents a study of the commonly used machineindependent metrics for two different exploration frameworks for Java (JPF and ReEx) by revisiting and extending a previous study (Parallel Randomized State-Space Search) and evaluating the correlation of the metrics with real time both on a single machine and on a high-performance cluster of machines. Our study provides new evidence for selecting metrics in future evaluations of exploration techniques by showing that several machine-independent metrics are a good substitute for real time, and that reporting real time results even from clusters can provide useful information.

show abstract

Efficient Testing of Concurrent Programs with Abstraction-Guided Symbolic Execution

Cited by 30 publications

References 26 publications

Resource-Driven CLP-Based Test Case Generation

Resource-Driven CLP-Based Test Case Generation

Partially Evaluating Finite-State Runtime Monitors Ahead of Time

Evaluating Machine-Independent Metrics for State-Space Exploration

Contact Info

Product

Resources

About