Using meta-level compilation to check FLASH protocol code

Building systems suchasOSkernels and embedded software is di cult. An important source of this di culty is the numerous rules they must obey: interrupts cannot be disabled for \too long, " global variables must be protected by locks, user pointers passed to OS code must be checked for safety before use, etc. A single violation can crash the system, yet typically these invariants are unchecked, existing only on paper or in the implementor's mind. This paper is a case study in how system implementors can use a new programming methodology, metalevel compilation (MC), to easily check suchinvariants. It focuses on using MC to check for errors in the code used to manage cache coherence on the FLASH shared memory multiprocessor. The only real practical method known for verifying such code is testing and simulation. We showthat simple, system-speci c checkers can dramatically improve this situation by statically pinpointing errors in the program source. These checkers can be written by implementors themselves and, by exploiting the system-speci c information this allows, can detect errors unreachable with other methods. The checkers in this paper found 34 bugs in FLASH code despite the care used in building it and the years of testing it has undergone. Many of these errors fall in the worst category of systems bugs: those that show up sporadically only after days of continuous use. The case study is interesting because it shows that the MC approach nds serious errors in well-tested, non-toy systems code. Further, the code to nd such bugs is usually 10-100 lines long, written in a few hours, and exactly locates errors that, if discovered during testing, would require several days of investigation by an experienced implementor. The paper presents8checkers we wrote, their applicationto ve di erent protocol implementations, and a discussion of the errors that we found.

Symbolic Crosschecking of Data-Parallel Floating Point Code

In this thesis we present a symbolic execution-based technique for cross-checking programs accelerated using SIMD or OpenCL against an unaccelerated version, as well as a technique for detecting data races in OpenCL programs. Our techniques are implemented in KLEE-CL, a symbolic execution engine based on KLEE that supports symbolic reasoning on the equivalence between expressions involving both integer and floating-point operations. While the current generation of constraint solvers provide good support for integer arithmetic, there is little support available for floating-point arithmetic, due to the complexity inherent in such computations. The key insight behind our approach is that floating-point values are only reliably equal if they are essentially built by the same operations. This allows us to use an algorithm based on symbolic expression matching augmented with canonicalisation rules to determine path equivalence. Under symbolic execution, we have to verify equivalence along every feasible control-flow path. We reduce the branching factor of this process by aggressively merging conditionals, if-converting branches into select operations via an aggressive phi-node folding transformation. To support the Intel Streaming SIMD Extension (SSE) instruction set, we lower SSE instructions to equivalent generic vector operations, which in turn are interpreted in terms of primitive integer and floating-point operations. To support OpenCL programs, we symbolically model the OpenCL environment using an OpenCL runtime library targeted to symbolic execution. We detect data races by keeping track of all memory accesses using a memory log, and reporting a race whenever we detect that two accesses conflict. By representing the memory log symbolically, we are also able to detect races associated with symbolically indexed accesses of memory objects. We used KLEE-CL to find a number of issues in a variety of open source projects that use SSE and OpenCL, including mismatches between implementations, memory errors, race conditions and compiler bugs

Caractérisation de la sûreté de fonctionnement de systèmes à base d'intergiciel

Les systèmes critiques sont soumis, comme le reste de l'industrie informatique, à des contraintes de coût de plus en plus sévères. Cette pression pousse les développeurs à privilégier la réutilisation de logiciels, plutôt que de procéder à des développements spécifiques à chaque projet. Cette tendance à l'utilisation de composants logiciels "sur étagère", souvent développés par des tiers, est renforcée par des besoins technologiques de plus en plus complexes, en particulier l'intégration des systèmes dans des réseaux de communication. L'utilisation de composants sur étagère permet aux industriels de se concentrer sur leur domaine de compétence, sans gaspiller de l'effort à redévelopper des fonctions qui ont déjà été implantées dans d'autres secteurs. Cette tendance à la réutilisation, ainsi que l'interconnexion croissante des systèmes, a favorisé l'émergence de standards d'interface, qui permettent l'interopérabilité de systèmes, même lorsqu'ils sont développés par des groupes différents. L'un des standards d'interface pour l'intégration de systèmes est les intergiciels de communication tels que la plate-forme CORBA. Ces intergiciels facilitent l'interaction entre des applications disparates, s'exécutant sur des plates-formes matérielles et logicielles hétérogènes. Pour les intégrateurs de systèmes distribués, ces technologies sont attractives pour plusieurs raisons, autant technologiques qu'économiques : elles constituent un moyen rapide d'intégration de nouvelles technologies, d'augmentation de la souplesse et l'ouverture vers d'autres systèmes. Toutefois, cette attractivité est conditionnée par des craintes concernant la robustesse des composants intergiciels, qui n'ont pas bénéficié de la rigueur du processus de développement utilisé dans le contexte de systèmes critiques. Les intégrateurs de systèmes distribués semi-critiques souhaitent avoir des assurances sur la qualité et la robustesse des composants qu'ils intègrent au sein de leurs systèmes. Ils souhaitent des informations sur les modes de défaillance de l'intergiciel, sur les canaux de propagation d'erreur qu'il introduit. Ils souhaitent avoir des informations quantitatives leur permettant de comparer différentes implémentations candidates du point de vue de la sûreté de fonctionnement, afin de sélectionner le candidat qui est le mieux adapté à leurs besoins. La problématique que nous venons d'énoncer peut se résumer en deux points : - obtenir une meilleure connaissance des types de fautes et d'erreurs qui existent dans les systèmes à base d'intergiciel de communication ; - développer une méthode permettant de caractériser expérimentalement la robustesse de candidats intergiciels. Il existe actuellement très peu de travaux qui permettent de répondre à ces interrogations. L'objectif de cette thèse est de proposer une méthode de caractérisation qui puisse être appliquée à des intergiciels cibles, et de répondre ainsi aux problèmes des intégrateurs de systèmes semi-critiques, ainsi qu'aux développeurs de composants intergiciel. Notre contribution est de proposer une méthodologie pour l'analyse de la sûreté de fonctionnement d'un intergiciel. Notre méthode est basée sur une analyse structurelle des intergiciels de communication, sur l'élaboration d'un modèle de fautes, une classification des modes de défaillance, et le développement d'un ensemble de techniques d'injection de faute adaptées à l'intergiciel. Nous avons validé notre approche en menant des campagnes d'injection de faute ciblant plusieurs implémentations de la norme CORBA. ABSTRACT : We propose a method for the dependability assessment and failure mode characterization of communications middleware. The method is based on the structural analysis of communications-oriented middleware, the identification of a fault model, a failure modes classification, and the development of a number of fault injection techniques that can be used to target middleware implementations. We have applied our method by carrying out fault injection campaigns targeting a number of CORBA implementations, and obtained quantitative measures of the robustness of the different candidates. Our work allows integrators of dependable distributed systems to obtain assurances on the robustness of the software components they place at the heart of their systems, and provides information to middleware vendors regarding robustness failings in their products