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.