Débogage à large échelle sur des systèmes hétérogènes parallèles

Le traitement parallèle est devenu une nécessité afin de bénéficier du plein potentiel des processeurs centraux modernes. En effet, l'ajout de coeurs de calcul est un des facteurs ayant eu le plus d'impact sur le gain de performance des processeurs dans les dernières années. Pour cette raison, l'usage des processeurs multicoeurs est de plus en plus répandu en industrie ainsi que chez les particuliers, et le nombre de coeurs continue à augmenter. Cependant, le développement de programmes adaptés aux processeurs parallèles apporte de nouveaux défis. En effet, le paradigme de développement séquentiel ne suffit plus, et le programmeur doit prendre en compte le parallélisme. Il doit s'assurer que les interactions entre les fils d'exécution ne créent pas de problèmes. Cela est difficile, notamment lorsque le programme utilise un grand nombre de fils d'exécution, et des problèmes dus au parallélisme peuvent survenir. Cela pose un défi important en industrie, car ces problèmes compliquent le développement logiciel, et peuvent augmenter les coûts de développement. Il est donc nécessaire d'avoir des outils adaptés au développement de programmes parallèles pour permettre aux programmeurs d'identifier et de trouver rapidement ces problèmes. Un outil vital pour le processus de développement logiciel est le débogueur. Cet outil permet à l'utilisateur de contrôler le fonctionnement d'un programme, de l'arrêter à certains endroits et d'utiliser plusieurs autres techniques pour trouver l'origine de problèmes. Or, la majorité des débogueurs et des techniques de débogage utilisés existent depuis plusieurs années, et ont été développés alors que les processeurs parallèles étaient peu répandus. Plusieurs problèmes liés au parallélisme découlent d'une mauvaise synchronisation entre les fils d'exécution. La course de donnée en est un exemple. Elle survient lorsque plusieurs fils d'exécution modifient une variable en mémoire sans synchronisation. La valeur finale de la variable dépend alors de l'ordre d'exécution des fils et peut varier entre différentes exécutions du programme. Ce type de problème n'est donc pas déterministe, et n'arrive pas nécessairement même si on ré-exécute un programme avec les mêmes valeurs de départ. Or, la plupart des techniques de débogage sont intrusives. En effet, stopper un programme et examiner ses variables a un effet important sur la synchronisation. Il arrive donc qu'un problème disparaisse ou change lorsqu'un programme est débogué en raison de l'impact du débogueur. Il est évident que des techniques de débogage minimalement intrusives sont nécessaires afin d'aider les développeurs à déceler ce type d'erreur. Un autre défi présent avec le débogage de programmes parallèles est l'interface utilisateur. En effet, les programmes parallèles contiennent un très grand nombre de fils d'exécution, et peuvent générer un grand débit d'évènements qui doivent être traités par le développeur. Par exemple, il peut être nécessaire d'inspecter l'état de plusieurs dizaines de fils d'exécution lors d'un arrêt du programme pour bien comprendre le contexte. Cela est une tâche pénible, et peut mener le développeur à manquer certains problèmes en raison d'une surcharge d'information. Il peut arriver qu'il soit difficile de trouver l'information pertinente à travers toutes les informations affichées. Il faut donc que l'utilisateur ait accès à une interface qui lui permette de facilement visualiser et contrôler l'état d'un programme.

Abstract

A significant proportion of performance gains in processors in recent years has come from parallel processing. Indeed, adding cores in a processor has been heavily used by most manufacturers to gain performance improvements. For this reason, multi-core and many-core processors are increasingly common in personal computers and industrial systems. However, designing software for parallel processors is not an easy task. Indeed, the sequential programming paradigm traditionally used is not sufficient anymore, as multiple tasks can be processed simultaneously. The software designer must take interactions between threads into account, and write code accordingly. This is a complicated task, especially when a program uses a large number of threads. This can lead to multiple issues, thus increasing development time and cost. Therefore, using development tools suitable for parallel development is essential to allow developers to quickly identify and locate these issues. One of the most important tools is the debugger, a tool to control a program execution and inspect its state. Unfortunately, most debugging tools have been in use for a long time, and were designed to debug single-threaded applications. Many problems can be created by a mistake in thread synchronization. One example is a data race, which occurs when multiple threads try to access a shared variable without concurrency control. In this case, its final value depends on the order in which each thread accesses it, and the result may change between different executions as the thread scheduling varies. Inspecting this type of problem with a debugger can be problematic, as a debugger can be very intrusive and disturb the execution of the program. Therefore, a multi-threading issue may be masked or modified during debugging, greatly diminishing the usefulness of the debugger. Thus, adapted debugging techniques are needed for parallel software. Another challenge is the large amount of data to be handled by the user. Indeed, as parallel software may contain a great number of threads, there is a lot of information to display, and a large number of events can be generated. This can confuse the developer by overloading him with information. Therefore, appropriate techniques to visualize and control multi-threaded software are needed. These two challenges have been addressed during this research project. Two different platforms have been used for tests. The first one is a server with four multi-core processors that has a total of 64 physical cores. The other one is a general-purpose computer with a multi-core processor and a graphic card used for calculations. The GDB debugger has been enhanced to allow dynamic scalable tracing in order to trace parallel programs with minimal overhead. This enhancement has been achieved by modifying GDB to address limitations for parallel tracing, and using LTTng for trace collection. LTTng has also been enhanced to allow dynamic event registration. Finally, the impact of conditional breakpoints has been measured, and a technique to minimize this impact has been proposed.