A platform to evaluate the fault sensitivity of superscalar processors

Abstract

The aggressive shrinking of transistors, which led to the reductions in the operating voltage, has been providing enormous benefits in terms of computational power while keeping the energy consumption at an acceptable level. However, as feature size and voltage decrease, the susceptibility to soft errors tends to increase, and the importance of fault evaluations grows. Superscalar processors, which nowadays dominate the market, are a significant example of systems that take advantage of these technological improvements and are more susceptible to errors. Along with that, there exist several methods for fault injection, which is an efficient means to evaluate the resiliency of such processors. However, traditional fault injection methods, such as the hardware-based technique, impose that the processor must be physically implemented before the tests can be conducted, while not providing reasonable levels of controllability. On the other hand, techniques based on simulators implemented in Software offer high levels of controllability. However, while high-level SW simulators (which are fast) may lead to an incomplete, or even misguided, evaluation of the system’s resiliency since they don’t model the hardware internals (such as the pipeline registers), low-level SW simulators are extremely slow and are hardly available at RTL (Register-Transfer Level). Considering this scenario, we propose a platform that bridges the gap between the HW and SW approaches to evaluate faults in superscalar processors: it is fast, with high controllability, available in software, flexible, and, most importantly, it models the processor at RTL. The tool was implemented on top of the framework used to generate the Berkeley Out-of-Order Machine (BOOM) superscalar processor, which is a highly scalable and parameterizable processor. This property allowed us to experiment with three different architectures of the processor: single-, dual-, and quad-issue out-of-order cores, and, by analyzing how the resiliency to faults is influenced by the complexity of different processors, use them to validate our tool.

A diminuição agressiva dos transistores, a qual levou a reduções na tensão de operação, vem proporcionando enormes benefícios em termos de poder computacional, mantendo o consumo de energia em um nível aceitável. No entanto, à medida que o tamanho dos recursos e a tensão diminuem, a susceptibilidade a falhas tende a aumentar e a importância das avaliações com falhas cresce. Os processadores superescalares, que hoje dominam o mercado, são um exemplo significativo de sistemas que se beneficiam destas melhorias tecnológicas e são mais suscetíveis a erros. Juntamente com isso, existem vários métodos para injeção de falhas, que é um meio eficiente para avaliar a resiliência desses processadores. No entanto, os métodos tradicionais de injeção de falhas, como a técnica baseada em hardware, impõem que o processador seja implementado fisicamente antes que os testes possam ser conduzidos, sem fornecer níveis razoáveis de controlabilidade. Por outro lado, as técnicas baseadas em simuladores implementados em software oferecem altos níveis de controlabilidade. No entanto, enquanto os simuladores em SW de alto nível (que são rápidos) podem levar a uma avaliação incompleta, ou mesmo equivocada, da resiliência do sistema, uma vez que não modelam os componentes internos do hardware (como os registradores do pipeline), simuladores em SW de baixo nível são extremamente lentos e dificilmente estão disponíveis em RTL (Register-Transfer Level). Considerando este cenário, propomos uma plataforma que preenche a lacuna entre as abordagens em HW e SW para avaliar falhas em processadores superescalares: é rápida, tem alta controlabilidade, disponível em software, flexível e, o mais importante, modela o processador em RTL. A ferramenta foi implementada sobre a plataforma usada para gerar o processador superescalar The Berkeley Out-of-Order Machine (BOOM), que é um processador altamente escalável e parametrizável. Esta propriedade nos permitiu experimentar três arquiteturas diferentes do processador: single-, dual- e quad-issue, e, ao analisar como a resiliência a falhas é influenciada pela complexidade de diferentes processadores, usamos os processadores para validar nossa ferramenta.