Instrumenting where it hurts

Tzoref, Rachel; Ur, Shmuel; Yom-Tov, Elad

doi:10.1145/1273463.1273469

Cited by 21 publications

References 27 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

Data mining for defects in multicore applications: an entropy‐based call‐graph technique

Eichinger¹,

Pankratius

Böhm

2012

Concurrency and Computation

View full text Add to dashboard Cite

SUMMARYMulticore computers are ubiquitous. Expert developers as well as developers with little experience in parallelism are now asked to create multithreaded software in order to exploit parallelism in mainstream shared-memory hardware. However, finding and fixing parallel programming errors is a complex and arduous task. Programmers thus rely on tools such as race detectors that typically focus on reporting errors due to incorrect usage of synchronization constructs or due to missing synchronization. This arsenal of debugging techniques, however, is incomplete. This article presents a new perspective and addresses a largely unexplored direction of defect localization where a wrong usage of non-parallel programming constructs might cause wrong parallel application behavior. In particular, we make a contribution by showing how to use data-mining techniques to locate defects in multithreaded shared-memory programs. Our technique analyzes execution anomalies in a condensed representation of the dynamic call graphs of a multithreaded object-oriented application and identifies methods that contain a defect. Compared to race detectors that concentrate on finding incorrect synchronization, our method is able to reveal a wider range of defects that affect the control flow of a parallel program. Results from controlled experiments show that our data-mining approach not only finds race conditions in different types of multicore applications, but also other errors that cause incorrect parallel program behavior. Data-mining techniques offer a fruitful new ground for parallel program debugging, and we also discuss long-term directions for this interesting field.

show abstract

Data mining for defects in multicore applications: an entropy‐based call‐graph technique

Eichinger¹,

Pankratius

Böhm

2012

Concurrency and Computation

View full text Add to dashboard Cite

show abstract

Boosted decision trees for behaviour mining of concurrent programmes

Avros

Dudka

Křena

et al. 2017

Concurrency and Computation

View full text Add to dashboard Cite

SummaryTesting of concurrent programmes is difficult since the scheduling nondeterminism requires one to test a huge number of different thread interleavings. Moreover, repeated test executions that are performed in the same environment will typically examine similar interleavings only. One possible way how to deal with this problem is to use the noise injection approach, which influences the scheduling by injecting various kinds of noise (delays, context switches, etc) into the common thread behaviour. However, for noise injection to be efficient, one has to choose suitable noise injection heuristics from among the many existing ones as well as to suitably choose values of their various parameters, which is not easy. In this paper, we propose a novel way how to deal with the problem of choosing suitable noise injection heuristics and suitable values of their parameters (as well as suitable values of parameters of the programmes being tested themselves). Here, by suitable, we mean such settings that maximize chances of meeting a given testing goal (such as, eg, maximizing coverage of rare behaviours and thus maximizing chances to find rarely occurring concurrency‐related bugs). Our approach is, in particular, based on using data mining in the context of noise‐based testing to get more insight about the importance of the different heuristics in a particular testing context as well as to improve fully automated noise‐based testing (in combination with both random as well as genetically optimized noise setting).

show abstract

Advances in noise‐based testing of concurrent software

Fiedor

Hrubá

Křena

et al. 2014

Software Testing Verif & Rel

View full text Add to dashboard Cite

SummaryTesting of concurrent software written in programming languages like Java and C/C++ is a highly challenging task owing to the many possible interactions among threads. A simple, cheap, and effective approach that addresses this challenge is testing with noise injection, which influences the scheduling so that different interleavings of concurrent actions are witnessed. In this paper, multiple results achieved recently in the area of noise‐injection‐based testing by the authors are presented in a unified and extended way. In particular, various concurrency coverage metrics are presented first. Then, multiple heuristics for solving the noise placement problem (i.e. where and when to generate noise) as well as the noise seeding problem (i.e. how to generate the noise) are introduced and experimentally evaluated. In addition, several new heuristics are proposed and included into the evaluation too. Recommendations on how to set up noise‐based testing for particular scenarios are then given. Finally, a novel use of the genetic algorithm for finding suitable combinations of the many parameters of tests and noise techniques is presented. Copyright © 2014 John Wiley & Sons, Ltd.

show abstract

Instrumenting where it hurts

Cited by 21 publications

References 27 publications

Data mining for defects in multicore applications: an entropy‐based call‐graph technique

Data mining for defects in multicore applications: an entropy‐based call‐graph technique

Boosted decision trees for behaviour mining of concurrent programmes

Advances in noise‐based testing of concurrent software

Contact Info

Product

Resources

About