Enhancing trace generation-based software debugging infrastructure for physical and emulated development platforms

Software debugging is now widely reported to constitute the majority of software development time and cost, largely due to the effects of continuously rising software complexity. In a trend which is expected to continue, complex software faults that can require weeks to resolve are becoming increasingly commonplace. Since traditional debugging methods are considered unsuitable for resolving such faults, trace generation is being recognized as a solution to future debugging needs. This thesis presents trace generation infrastructure that includes advanced on-chip supporting hardware, complementary software tools, and interfaces to bridge the gap between them. The contributions enable or enhance the use of trace generation across a variety of software development platforms.Even though embedded software development is increasingly performed on software emulators, many existing emulators lack trace generation capabilities. This thesis provides the ubiquitous QEMU emulator with the ability to perform trace experiments. The described extensions enable continuous instruction-level trace generation to be controlled using a standard software debugger client, which is given the ability to create tracepoints to dynamically log registers and memory addresses. The infrastructure is made aware of operating system context-switching in a unique way, which allows traces to be collected in five different modes: from all executed code, down to a single Linux process.For hardware-based development platforms, the volume of on-chip trace data generated in real-time can exceed the ability to practically transfer or store it. This thesis presents two different schemes for the compression of execution traces, which are vital in establishing the flow of software execution post-hoc. The Architecture-Aware Trace Compression (AATC) scheme eliminates previously unidentified redundancies within typical execution traces using a combination of on-chip predictors, transforms, and encoders. The scheme achieves the highest-performance compression of any similar method, most notably by exploiting the widespread use of linked branches, as well as the compiler-driven movement of return addresses between link-register, stack, and program counter. The Multi-Architectural Trace Compression (MATC) scheme is also introduced to compress the execution traces of any fixed instruction-width soft-core processor deployed on Field-Programmable GateArray (FPGA) platforms. A novel architecture is presented in which five parameterizable variants of a pipelined scheme allow different combinations of unused logic and memory resources to be repurposed for trace compression purposes.Le déboguage est désormais largement reconnu comme la tâche coûtant le plus cher et prenant le plus de temps de développement dans le contexte de projets logiciels. Cela est fortement lié à l'augmentation de la complexité de ce type de projet. Il arrive de plus en plus souvent que la correction de défauts logiciels complexes prenne plusieurs semaines, et cette tendance s'accentue avec le temps. Puisque les méthodes de déboguage traditionnelles ne permettent plus de résoudre ces défauts, de nouvelles méthodes comme la génération de traces sont proposées pour la résolution des bogues modernes. Cette thèse propose une infrastructure de génération de traces incluant une portion matérielle avancée, des outils logiciels complémentaires, ainsi que des interfaces servant à lier ces deux éléments. Ces contributions permettent ou améliorent l'utilisation de la génération de traces à travers diverses plates-formes de développement logiciel.Malgré que le développement de logiciels embarqués soit de plus en plus effectué à l'aide de logiciels d'émulation, ces logiciels sont souvent incapables d'effectuer la génération de traces. Cette thèse présente un ajout à l'émulateur QEMU permettant la génération de traces. Les extensions proposées permettent de générer des traces d'instructions en continu, et ce à l'aide d'un débogueur logiciel standard. Ce débogueur est doté de la capacité de créer des points de traçage pour enregistrer les registres et les adresses mémoire de façon dynamique. Cette infrastructure est de plus prévenue des changements de contexte effectués par le système d'exploitation grâce à une approche unique qui permet de récolter les traces selon cinq modes différents (soit pour tout le code exécuté, soit de façon graduellement plus précise jusqu'à ne retenir qu'un seul processus Linux).Pour les plates-formes de développement matériel, le volume de données associé aux traces générées sur la puce en temps réel peut dépasser la capacité de transfert ou d'enregistrement disponible. Il est donc essentiel de compresser ces données pour permettre de reconstituer le fil de l'exécution du logiciel après coup. Deux approches sont présentées pour la compression des traces d'exécution. L'approche de Compression de Traces Basée sur l'Architecture (AATC) élimine certaines redondances qui étaient auparavant ignorées au sein de traces d'exécution typiques grâce à une combinaison de prédicteurs matériels, de transformées et d'encodeurs. Cette méthode permet d'obtenir une compression supérieure à toutes les méthodes comparables, notamment en tirant profit de l'ubiquité des points de branchage liés ainsi que du déplacement des adresses-retour entre le registre-retour, la pile, et le compteur d'instructions. La seconde approche appelée Compression de Traces Multi-Architecture (MATC) permet quant à elle de compresser les traces d'exécution de tout processeur soft-core utilisant des instructions à taille fixe et déployé sur un circuit logique programmable (FPGA). L'architecture proposée comporte cinq variantes qui permettent divers niveaux de réappropriation des circuits logiques et des ressources mémoire inutilisés pour la compression de traces