Use este identificador para citar ou linkar para este item:
http://repositorio.utfpr.edu.br/jspui/handle/1/32547
Título: | Software and hardware interfaces for approximate memories |
Título(s) alternativo(s): | Interfaces software e hardware para memórias aproximadas |
Autor(es): | Fabrício Filho, João |
Orientador(es): | Wanner, Lucas Francisco |
Palavras-chave: | Sistemas de memória de computador Arquitetura de computador Interfaces (Computadores) Falhas de sistemas de computação Computer storage devices Computer architecture Computer interfaces Computer system failures |
Data do documento: | 10-Fev-2022 |
Editor: | Universidade Estadual de Campinas |
Câmpus: | Campo Mourao |
Citação: | FABRÍCIO FILHO, João. Software and hardware interfaces for approximate memories. 2022. Tese (Doutorado em Ciência da Computação) - Universidade Estadual de Campinas, Campinas, 2022. |
Resumo: | Componentes de memória são sensíveis a variações de processo, tensão e temperatura e, para assegurar confiabilidade nos dados armazenados, seus fabricantes especificam os parâmetros de operação considerando o pior caso de projeto com uma margem de proteção. Memórias aproximadas ajustam os parâmetros para fora da margem de proteção, o que permite economia de energia ao custo de erros probabilísticos nos dados armazenados. Enquanto diversas aplicações toleram alguma imprecisão em seus resultados, não são todos os seus dados que toleram erros, e até dados resilientes os toleram até um limite. Erros não controlados podem produzir resultados com mais imprecisão do que o aceitável, o que os torna inúteis, ou até quebrar uma execução da aplicação inesperadamente por causa de erros em dados críticos. Interfaces para acesso a dados controlam quais dados são expostos a erros, por meio da proteção a dados críticos, e quanto erro pode ser inserido para respeitar o limite de imprecisão dos resultados, por meio da configuração da memória aproximada. Esse controle depende da aplicação e do impacto do erro nos resultados da computação. Interfaces tipicamente fiam-se em anotações do programador e métricas de domínio específico para identificar os dados suscetíveis a aproximações ou para configurar a quantidade de erros permitida. Contudo, anotações prejudicam a portabilidade e manutenção do código e métricas de domínio específico demandam algum conhecimento sobre o impacto do erro na aplicação. Além disso, o erro é um elemento dinâmico dependente de um cenário composto de variáveis do ambiente, como temperatura, localidade e processo de fabricação. Mecanismos de interfaces transparentes procuram, de forma automática, proteger dados críticos e controlar o erro no limite aceitável da aplicação, alterando a configuração de erro de acordo com as variáveis do ambiente. Este trabalho propõe interfaces transparentes para o controle de aproximação de memória que melhoram a resiliência da execução e aumentam a eficiência energética. Analisamos a execução das aplicações quando elementos de dados são expostos a erros probabilísticos e encontramos dados críticos que causam quebras de execução e que são comuns a várias aplicações. Então, propusemos mecanismos de hardware e software para tratar esses dados e evitar quebras no intuito de gerar resultados úteis. Apresentamos proteções para endereçamento físico e virtual e investigamos o impacto do erro de diferentes posições na hierarquia de memória, além da exploração de alternativas para um sistema supervisor tratar execuções inválidas para recuperar os dados da aplicação. Finalmente, este trabalho relaciona o comportamento da execução das aplicações com sua tolerância a erros para configurar a memória aproximada de forma transparente. O comportamento é abstraído de estatísticas de execução mensuráveis que são correlacionadas com a configuração utilizando uma base de conhecimento de execuções de treinamento prévias. Nossos resultados evidenciam que as interfaces propostas melhoram a resiliência da execução reduzindo uma fração significativa das quebras e configuram memórias aproximadas com economia de energia e qualidade média próximas às alcançadas por uma busca exaustiva. |
Abstract: | Memory components are sensitive to process, voltage, and temperature variability and, to ensure reliability in the stored data, vendors specify operating parameters considering the worst case in the process design with a guard-band margin. Approximate memories adjust parameters out of the guard-band range, which allows for energy savings at the cost of probabilistic errors in the stored data. While several applications tolerate some imprecision in their results, not all data are resilient to errors, and even resilient data have limits on their tolerance to errors. Uncontrolled errors may produce results with more imprecision than acceptable, which render them useless or even crash an application execution unexpectedly because of errors in critical data. Data access interfaces control what data are exposed to errors, through critical data protection, and how much error can be inserted to respect the imprecision limit of the results, through the configuration of the approximate memory. This control depends on the application and the error impact in the results of the computation. Interfaces typically rely on programmer annotations that change the application and domain-specific metrics to identify the data amenable to approximation or to configure the allowed error amount. Nevertheless, annotations hinder the portability and maintainability of the code, and domain-specific metrics demand some knowledge about the error impact on the application. Moreover, the error is a dynamic element dependent on a scenario that is composed of environment variables, such as temperature and fabrication process. Transparent interface mechanisms attempt to automatically protect critical data and control the error into the threshold that the application tolerates changing the error configuration according to the environment variables. This work proposes transparent interfaces for the control of memory approximation to improve execution resilience and increase energy efficiency. We analyze the execution of applications when data elements are exposed to probabilistic errors and find common critical data that cause execution crashes. Then, we propose hardware and software mechanisms to treat these data and avoid crashes aiming to generate useful results. We present protections for physical and virtual addressing and investigate the impact of error from different memory hierarchy levels, besides the exploration of alternatives for a supervisor system to treat incorrect executions for recovering application data. Lastly, this work relates the execution behavior of applications with their error tolerance to transparently configure the approximate memory. The behavior is abstracted from measurable execution statistics that are correlated with a configuration using a knowledge base of previous training executions. Our results show that these interfaces improve execution resilience by reducing a significant part of the crashes and configure approximate memories with energy savings and average quality close to the achieved by an exhaustive search. |
URI: | http://repositorio.utfpr.edu.br/jspui/handle/1/32547 |
Aparece nas coleções: | PCS - Teses |
Arquivos associados a este item:
Arquivo | Descrição | Tamanho | Formato | |
---|---|---|---|---|
softwarehardwareinterfacesmemories.pdf | 3,35 MB | Adobe PDF | ![]() Visualizar/Abrir |
Os itens no repositório estão protegidos por copyright, com todos os direitos reservados, salvo quando é indicado o contrário.