Localizing Defects in Multithreaded Programs by Mining Dynamic Call Graphs

Writing multithreaded software for multicore computers confronts many developers with the difficulty of finding parallel programming errors. In the past, most parallel debugging techniques have concentrated on finding race conditions due to wrong usage of synchronization constructs. A widely unexplored issue, however, is that a wrong usage of non-parallel programming constructs may also cause wrong parallel application behavior. This paper presents a novel defect-localization technique for multithreaded shared-memory programs that is based on analyzing execution anomalies. Compared to race detectors that report just on wrong synchronization, this method can detect a wider range of defects affecting parallel execution. It works on a condensed representation of the call graphs of multithreaded applications and employs data-mining techniques to locate a method containing a defect. Our results from controlled application experiments show that we found race conditions, but also other programming errors leading to incorrect parallel program behavior. On average, our approach reduced in our benchmark the amount of code to be inspected to just 7.1% of all methods

Localizing Defects in Multithreaded Programs by Mining Dynamic Call Graphs

Writing multithreaded software for multicore computers confronts many developers with the difficulty of finding parallel programming errors. In the past, most parallel debugging techniques have concentrated on finding race conditions due to wrong usage of synchronization constructs. A widely unexplored issue, however, is that a wrong usage of non-parallel programming constructs may also cause wrong parallel application behavior. This paper presents a novel defect-localization technique for multithreaded shared-memory programs that is based on analyzing execution anomalies. Compared to race detectors that report just on wrong synchronization, this method can detect a wider range of defects affecting parallel execution. It works on a condensed representation of the call graphs of multithreaded applications and employs data-mining techniques to locate a method containing a defect. Our results from controlled application experiments show that we found race conditions, but also other programming errors leading to incorrect parallel program behavior. On average, our approach reduced in our benchmark the amount of code to be inspected to just 7.1% of all methods

How Developers Use Data Race Detection Tools

Developers need help with multithreaded programming. We investigate how two program analysis tools are used by de-velopers at Google: THREADSAFETY, an annotation-based static data race analysis, and TSAN, a dynamic data race de-tector. The data was collected by interviewing seven veteran industry developers at Google, and provides unique insight into how four different teams use tooling in different ways to help with multithreaded programming. The result is a collec-tion of perceived pros and cons of using THREADSAFETY and TSAN, as well as general issues with multithreading

Analyse statique/dynamique pour la validation et l'amélioration des applications parallèles multi-modèles

Supercomputing plays an important role in several innovative fields, speeding up prototyping or validating scientific theories. However, supercomputers are evolving rapidly with now millions of processing units, posing the questions of their programmability. Despite the emergence of more widespread and functional parallel programming models, developing correct and effective parallel applications still remains a complex task. Although debugging solutions have emerged to address this issue, they often come with restrictions. However programming model evolutions stress the requirement for a convenient validation tool able to handle hybrid applications. Indeed as current scientific applications mainly rely on the Message Passing Interface (MPI) parallel programming model, new hardwares designed for Exascale with higher node-level parallelism clearly advocate for an MPI+X solutions with X a thread-based model such as OpenMP. But integrating two different programming models inside the same application can be error-prone leading to complex bugs - mostly detected unfortunately at runtime. In an MPI+X program not only the correctness of MPI should be ensured but also its interactions with the multi-threaded model, for example identical MPI collective operations cannot be performed by multiple nonsynchronized threads. This thesis aims at developing a combination of static and dynamic analysis to enable an early verification of hybrid HPC applications. The first pass statically verifies the thread level required by an MPI+OpenMP application and outlines execution paths leading to potential deadlocks. Thanks to this analysis, the code is selectively instrumented, displaying an error and synchronously interrupting all processes if the actual scheduling leads to a deadlock situation.L’utilisation du parallélisme des architectures actuelles dans le domaine du calcul hautes performances, oblige à recourir à différents langages parallèles. Ainsi, l’utilisation conjointe de MPI pour le parallélisme gros grain, à mémoire distribuée et OpenMP pour du parallélisme de thread, fait partie des pratiques de développement d’applications pour supercalculateurs. Des erreurs, liées à l’utilisation conjointe de ces langages de parallélisme, sont actuellement difficiles à détecter et cela limite l’écriture de codes, permettant des interactions plus poussées entre ces niveaux de parallélisme. Des outils ont été proposés afin de palier ce problème. Cependant, ces outils sont généralement focalisés sur un type de modèle et permettent une vérification dite statique (à la compilation) ou dynamique (à l’exécution). Pourtant une combinaison statique/- dynamique donnerait des informations plus pertinentes. En effet, le compilateur est en mesure de donner des informations relatives au comportement général du code, indépendamment du jeu d’entrée. C’est par exemple le cas des problèmes liés aux communications collectives du modèle MPI. Cette thèse a pour objectif de développer des analyses statiques/dynamiques permettant la vérification d’une application parallèle mélangeant plusieurs modèles de programmation, afin de diriger les développeurs vers un code parallèle multi-modèles correct et performant. La vérification se fait en deux étapes. Premièrement, de potentielles erreurs sont détectées lors de la phase de compilation. Ensuite, un test au runtime est ajouté pour savoir si le problème va réellement se produire. Grâce à ces analyses combinées, nous renvoyons des messages précis aux utilisateurs et évitons les situations de blocage

A viewer tool for multi-active object

International audienceActive object is a concurrency design pattern, which is based on allocating a singlethread and control for each independent activity. However today in the era ofmulticore machines using one thread is a great disadvantage. Using a single threadmay also cause deadlocks during the execution. That is why solution calledmultiactive object was presented and implemented in a java library called ProActive.The core idea of this solution is to make these activities multithreaded. In this work Iwill present a tool, which demonstrates the behavior of the multiactive objects basedon the logs made by the library. The main purpose of the tool is to help users to debugtheir applications. Several use cases will be presented revealing main features of thetool and the way user should use them

CONTEXT-AWARE DEBUGGING FOR CONCURRENT PROGRAMS

Concurrency faults are difficult to reproduce and localize because they usually occur under specific inputs and thread interleavings. Most existing fault localization techniques focus on sequential programs but fail to identify faulty memory access patterns across threads, which are usually the root causes of concurrency faults. Moreover, existing techniques for sequential programs cannot be adapted to identify faulty paths in concurrent programs. While concurrency fault localization techniques have been proposed to analyze passing and failing executions obtained from running a set of test cases to identify faulty access patterns, they primarily focus on using statistical analysis. We present a novel approach to fault localization using feature selection techniques from machine learning. Our insight is that the concurrency access patterns obtained from a large volume of coverage data generally constitute high dimensional data sets, yet existing statistical analysis techniques for fault localization are usually applied to low dimensional data sets. Each additional failing or passing run can provide more diverse information, which can help localize faulty concurrency access patterns in code. The patterns with maximum feature diversity information can point to the most suspicious pattern. We then apply data mining technique and identify the interleaving patterns that are occurred most frequently and provide the possible faulty paths. We also evaluate the effectiveness of fault localization using test suites generated from different test adequacy criteria. We have evaluated Cadeco on 10 real-world multi-threaded Java applications. Results indicate that Cadeco outperforms state-of-the-art approaches for localizing concurrency faults

Towards Advanced Debugging Support for Actor Languages: Studying Concurrency Bugs in Actor-based Programs

With the ubiquity of multicore hardware, concurrent and parallel programming has become a fundamental part of software development. If writing concurrent programs is hard, debugging them is even harder. The actor model is attractive for developing concurrent applications because actors are isolated concurrent entities that communicates through asynchronous message sending and do not share state, thus they avoid common concurrency bugs such as race conditions. However, they are not immune to bugs. This paper presents initial work on a taxonomy of concurrent bugs for actor based applications. Based on this study, we propose debugging tooling to assist the development process of actor-based applications

Monisäikeistävän C++-ohjelmistokehyksen toteuttaminen

Monisäikeistä ohjelmistoa suunniteltaessa ja toteutettaessa on usein järkevää aloittaa luomalla ohjelmistokehys, joka hallinnoi toistuvia, hankalasti hahmotettavia ja monimutkaisia rinnakkaisuuteen liittyviä toimenpiteitä. Kehyksen luonti saattaa itse asiassa olla ohjelmistoprojektin aikaa vievin osuus, ja itse toiminnallisuuden lisäys onkin vain viimeinen silaus muuten valmiiseen järjestelmään. Tässä esitellään säikeidenväliseen kommunikointiin tarkoitetun kehyksen luontiprosessia ja sen toteutukseen vaikuttaneita syitä. Tavoitteena oli toteuttaa pienessä mittakaavassa toimiva mutta mahdollisimman monta käyttötarkoitusta tukeva ohjelmistokehys, joka ei kuitenkaan olisi tarpeettoman tehoton. Lisäksi tarkoitus oli pyrkiä kehittämään monisäikeisten ohjelmien ymmärrettävyyttä ja vähentää niiden monimutkaisuutta. Ohjelman varsinainen käyttötarkoitus on mahdollistaa monisäikeisen pelimoottorin vakaa ydin. Niinkin monipuolisessa aiheessa kuin monisäikeinen ohjelmointi ei ole olemassa yleispätevää ratkaisua, joka selvittää kaikki kehittämisongelmat. On kuitenkin mahdollista löytää tiettyjä toimintatapoja, joita käyttämällä voidaan merkittävästi helpottaa osaa ongelmista. Työssä on keskitytty täysin yksiprosessiseen ohjelmistoon, mutta muokkaamalla ja uudelleenkäyttämällä olemassa olevia rajapintoja, kehyksen voi saada toimimaan useiden prosessien välisessä kommunikoinnissa. Työssä on mitattu tehokkuutta perinteisestä monisäikeisestä ohjelmasta ja vastaavan toiminnallisuuden sisältävästä ohjelmistokehystä käyttävästä ohjelmasta. Tuloksista saa käsityksen, että kehystä käytettäessä tehokkuus on heikentynyt merkittävästi. Lisäksi erityisesti pienissä ohjelmissa ohjelmiston lähdekoodinluettavuus - hieman yllättäen - kärsii monimutkaisemmasta rakenteesta ja kehyksen käytön aiheuttamasta lisästä. Voidaan kuitenkin olettaa, että suuremmissa ohjelmistoprojekteissa, joissa perinteinen monisäikeinen ohjelmisto saattaa muodostua äärimmäisen monimutkaiseksi, ohjelmistokehys selkeyttää ohjelmaa tehokkuuden kustannuksella.When designing and implementing multithreaded software, it is often justified to start by building a robust framework that handles the repetetive and complicated procedures required of a multithreaded application. This can be the most time consuming process, and adding the actual functionality on top of the framework can be considered only as the final touch. In the thesis work, a multithreading framework has been designed and implemented from scratch. The goal was to build a relatively small framework which could be used for practically any multithreaded program. Yet, it was attempted to keep in mind some of the most important aspects of multithreaded programming, such as understandability, complexity and performance. For such a complex topic as multithreaded programming, there is no silver bullet approach to solve all problems, but one approach can still fit to many needs. The implemented framework concentrates on single-process applications, but by reimplementing some parts of the framework, also inter-process communication can be made possible. The actual intended use for the framework is to form the core for a multithreaded game engine. Performance analysis is provided in small scale by implementing well-knownalgorithms. The analysis shows that performance is clearly degraded compared to conventional multithreading solutions, and that, especially in small projects, code readability suffers from the more complex nature of framework usage. This implies that frameworks suits larger projects better, as in such projects the conventional approach tends to grow into an unmaintainable and messy source code