Herramienta gráfica para guiar a investigadores a realizar experimentos bajo radiación memorias

1 Herramienta gráfica para guiar a investigadores a realizar experimentos bajo radiación memorias Autor: Jesús Alguacil González Director: Juan Antonio Clemente Barreira Trabajo de Fin de Grado – Grado en Ingeniería Informática Facultad de informática – Curso 2020/2021 Universidad Complutense de Madrid 2 Graphic tool to guide researchers to perform experiments with memories under the effects of radiation Author: Jesús Alguacil González Director: Juan Antonio Clemente Barreira Trabajo de Fin de Grado – Grado en Ingeniería Informática Facultad de informática – Curso 2020/2021 Universidad Complutense de Madrid 3 Agradecimientos A mi familia y a mis amigos que siempre dan su apoyo para que dé lo mejor de mí mismo. 4 Índice RESUMEN ..................................................................................................................................... 5 PALABRAS CLAVE ......................................................................................................................... 5 SUMMARY .................................................................................................................................... 6 KEYWORDS ................................................................................................................................. 6 1. INTRODUCCIÓN ...................................................................................................................... 7 1.1 EFECTOS DE LA RADIACIÓN EN LOS DISPOSITIVOS .................................................................... 7 1.2 FUENTES DE RADIACIÓN ......................................................................................................... 8 1.3 MÉTODOS DE MITIGACIÓN FRENTE A LOS EFECTOS DE LA RADIACIÓN ........................................ 9 1.3.1 Mitigación por tecnología ............................................................................................. 9 1.3.2 Mitigación por diseño ................................................................................................. 11 1.3.3 Mitigación por redundancia ........................................................................................ 12 1.4 MOTIVACIÓN DE ESTE TRABAJO DE FIN DE GRADO ................................................................ 13 2. ESTIMACIÓN DEL NÚMERO DE FALSOS MCUS ............................................................... 14 2.1 LA “PARADOJA DEL CUMPLEAÑOS”......................................................................................... 14 2.2 ECUACIONES DE DETECCIÓN EN FUNCIÓN DE LA DISTANCIA ENTRE CELDAS ............................. 15 3. DESARROLLO DE LA APLICACIÓN .................................................................................... 18 3.1 PLAN DE TRABAJO ................................................................................................................ 18 3.2 PLATAFORMA DE DESARROLLO ............................................................................................. 18 3.3 JAVAFX ............................................................................................................................... 18 3.4 CONFIGURACIÓN DEL PROYECTO .......................................................................................... 21 3.5 ESTRUCTURA DEL PROYECTO ............................................................................................... 23 3.6 CÓDIGO ............................................................................................................................... 24 3.6.1 Formulario .................................................................................................................. 24 3.6.2 Control de escenas .................................................................................................... 27 3.5.3 Cálculo de errores ...................................................................................................... 28 3.7 PORTABILIDAD DE LA APLICACIÓN .......................................................................................... 31 4. RESULTADOS ........................................................................................................................ 32 4.1 ESTUDIO DE LAS ECUACIONES DE PROBABILIDAD ................................................................... 32 4.2 ESTUDIO DE EXPERIMENTOS PREVIOS CON MEMORIAS EN ACELERADORES DE PARTÍCULAS ...... 36 4.2.1 Primer experimento .................................................................................................... 36 4.2.2 Segundo experimento ................................................................................................ 38 4.2.3 Tercer experimento .................................................................................................... 40 5. CONCLUSIONES DE ESTE TRABAJO DE FIN DE GRADO ............................................... 42 5. CONCLUSIONS OF THIS BACHELOR’S THESIS................................................................ 43 BIBLIOGRAFÍA........................................................................................................................... 44 5 Resumen Según avanza la tecnología de fabricación de memorias, éstas se vuelven cada vez más sensibles a los efectos de la radiación natural del entorno que las rodea. Diversas fuentes de radiación (protones, neutrones, partículas alfa…) son capaces de inducir cambios en la lógica combinacional de estos dispositivos o incluso afectar al contenido de las celdas de memoria, corrompiendo la información que almacenan. Esto es debido a que las partículas incidentes, al impactar con las celdas de memoria, depositan la suficiente energía como para inducir cambios en su contenido (de 0 a 1 o viceversa). Aunque hay técnicas a la hora de fabricación para reducir la aparición de estos efectos, hasta ahora no es posible evitarlos por completo. Por ello, los equipos de investigación deben realizar pruebas simulando estos efectos, y una de las técnicas más populares y realistas de conseguirlo es exponer los dispositivos a la radiación en un acelerador de partículas. Cuando una partícula impacta con el dispositivo, ésta puede causar un evento simple, que consiste en el cambio de un único bit de información; o un evento múltiple que consiste en el cambio de varios bits de información físicamente cercanos. Cuando se analizan los resultados obtenidos tras la exposición de un dispositivo a la radiación, una problemática que surge es la probabilidad de aparición de “falsos eventos múltiples”, que se manifiestan como eventos múltiples, pero realmente se produjeron por acumulación de eventos simples que casualmente afectaron a celdas vecinas o cercanas. La probabilidad de aparición de dichos falsos eventos múltiples es mayor cuanto mayor sea el tiempo de exposición del dispositivo frente a la radiación y el flujo de partículas incidente. De este modo, el objetivo de este trabajo es crear una herramienta que ayude a los investigadores a visualizar el tiempo óptimo de exposición donde se obtendrán el máximo de resultados minimizando, o al menos controlando, la probabilidad de aparición de falsos eventos múltiples en el experimento. Palabras clave Radiación, Memorias, Interfaz gráfica de usuario (GUI), Investigación, Optimización, Hardware. 6 Summary As memory fabrication technology scales down, memories have become more and more sensitive to the effects of natural radiation of the surrounding environment. Different sources of radiation (protons, neutrons, alpha particles…) are able to induce changes in the combinational logic of these devices or even capable of affecting the contents of the memory cells, corrupting the information that they store. This phenomenon occurs when charged particles impact with memory cells and they deposit enough energy to flip their contents (from 0 to 1 or vice versa). Even though there exist techniques that mitigate the appearance of these effects, this is still a not fully resolved problem that needs to be addressed. Thus, research teams must simulate these effects, and one of the most popular and realistic techniques of attaining this objective is to expose devices against the radiation by using a particle accelerator. When a particle hits the device, it may cause a simple event, which consists in the alteration of one unique bit of information, or a multiple event, which consists in the alteration of several bits of information that are allocated physically close. When the results of exposing the device to the radiation are analyzed, an issue that arises is the appearance of “false multiple events” that manifest as multiple events but were, in fact, produced by accumulation of various simple events that, coincidentally, affected neighbor cells. The greater the time of exposure to the radiation and to incidental flux of particles, the greater is the probability of the aforementioned events to appear. Thus, the goal of this project is to create a tool that would help the researcher visualize the optimal time in which he/she will get the maximum number of results while minimizing, or at least, controlling the probability of appearance of false multiple events in the experiment. Keywords Radiation, Memories, Graphical User Interface (GUI), Research, Optimization, Hardware. 7 1. Introducción 1.1 Efectos de la radiación en los dispositivos Los dispositivos electrónicos de nueva generación son cada vez más sensibles a los efectos de la radiación ambiental que les rodea. Según se expone en [1], estos efectos varían en función de la fuente de la radiación. Se pueden distinguir dos clases de fallos dependiendo del fenómeno que afecte a la memoria. El primero consiste en la creación de defectos Frenkel en la estructura cristalina del silicio del que están compuestos estos chips. Este fenómeno también es conocido como daño por desplazamiento o “displacement damage” [1]. En otro tipo de situaciones, la radiación Gamma, los rayos X y otras fuentes de radiación son capaces de generar una carga eléctrica dentro del circuito integrado de la memoria, llegando a veces a afectar a los transistores. Esta carga dura poco pero su intensidad puede provocar cambios en el estado eléctrico y alterar su contenido. En este último escenario, se producen los conocidos como Single Event Effects (SEEs). Estos eventos se pueden clasificar en diferentes categorías (Figura 1), pero los principales que van a ser estudiados a lo largo del trabajo serán los Single Event Upsets (SEUs). Los SEUs consisten en la modificación de la información almacenada en una o varias celdas de la memoria, lo que también se conoce con el nombre de bitflips. Los SEUs se clasifican en función de su multiplicidad entre Single Bit Upsets (SBUs) y Multiple Cell Upsets (MCUs). Otros tipos de SEEs (Single Event Transients (SETs), Single Event Functional Interrupts (SEFIs) y errores permanentes) también están incluidos en [1]. En la Figura 1 se proporciona la clasificación de estos eventos y se resalta cuáles son de interés en este trabajo. Figura 1. Clasificación de los diferentes tipos de SEEs Los SBUs consisten en un evento aislado que solo afecta a un bit de la memoria. Alternativamente, se encuentran los Multiple Bit Upsets (MBUs) y los ya mencionados MCUs que, como sus nombres indican, son eventos que afectan a varios bits o varias celdas de la memoria. Al ser provocados por la misma partícula, estos bits o celdas se encuentran muy próximas y, en el caso de los MBUs, afectan a varios bits de una palabra, dificultando de esta forma la recuperación de su contenido original [1]. La diferencia principal de los MBUs con los MCUs es que, en el primer caso, los bits 8 afectados por la radiación pertenecen a la misma palabra, mientras que en los MCUs son de palabras diferentes. Para evitar la aparición de MBUs y que aparezcan MCUs en su lugar, los fabricantes implementan la técnica de “bit interleaving” o “entrelazado de memoria” [2], [3] [4]. Esta técnica consiste en intercalar bits pertenecientes a diferentes palabras consiguiendo que, cuando dos o más bits vecinos se vean afectados por un evento múltiple, éste no afecte a varios bits de una palabra sino a un bit de varias palabras, permitiendo que los “Error Correcting Codes (ECC)” estándar puedan recuperar los datos que han sido modificados (Figura 2) [4] [5]. Figura 2. Funcionamiento del "bit interleaving". En un entorno donde existe radiación natural, y en particular, en un acelerador de partículas, donde es esperable observar una gran cantidad de eventos para obtener resultados estadísticamente válidos, ocurren de forma frecuente los conocidos como falsos MCUs. Este fenómeno se manifiesta cuando aparentemente se observa un MCU, pero que en realidad fueron dos o más SBUs diferentes los que modificaron celdas vecinas o muy próximas, en vez de ser sólo una partícula la que provocase el cambio múltiple. A la hora de estudiar los eventos múltiples, la aparición de estos eventos falsos dificulta enormemente el avance de la investigación ya que provocan que los resultados obtenidos no sean absolutamente fiables. 1.2 Fuentes de radiación Existen dos principales fuentes de radiación que provocan la aparición de los SEEs. Una fuente son las impurezas radioactivas en los componentes de los dispositivos electrónicos y la otra son los rayos cósmicos provenientes del espacio exterior [6]. El primer tipo de radiación se genera cuando los materiales que se usan para construir los componentes de la memoria no son debidamente purificados a la hora de su extracción. Elementos como el estaño y el plomo suelen contener trazas de materiales radioactivos como el uranio y el torio que, si no son purificados apropiadamente, pueden generar la radiación necesaria como para desencadenar un SEE [7]. Por otro lado, están los rayos cósmicos que proceden del espacio exterior y que interfieren con los equipos electrónicos que se usan en las naves espaciales [8] y en los satélites [9], y en algunas ocasiones en situaciones cotidianas [10]. En este último caso se han observado varios casos en los que los rayos han provocado alteraciones en los chips de memoria. A pesar de que muchas de las partículas de estos rayos, mayoritariamente protones, son repelidas por el campo magnético terrestre, algunos 9 llegan a atravesarlo y provocar multitud de eventos. Por otro lado, los protones también interactúan con los átomos de la atmósfera, provocando “duchas” de partículas secundarias (Figura 3), entre ellas neutrones de varias energías [11]. Éstos, a pesar de no poseer carga eléctrica, son capaces de interactuar con elementos como el boro [6] el cual, desafortunadamente, tiene una gran presencia en la electrónica en componentes como la capa BPSG (“Borophosphosilicate Glass”). Figura 3. Extensive Air Showers. Imagen extraída de 1 1.3 Métodos de mitigación frente a los efectos de la radiación Una vez conocidos qué son y cómo se pueden generar los SEEs, en la literatura se han propuesto y desarrollado métodos para la mitigación de sus efectos. Ninguno de los métodos que se van a exponer a continuación son infalibles ya que, dependiendo del tipo de electrónica con la que se esté trabajando, pueden tener una eficacia diferente. Además, cabe mencionar que factores como la fuente de alimentación, la temperatura o la frecuencia del reloj del dispositivo pueden afectar a la sensibilidad de los dispositivos ante los SEEs [6]. 1.3.1 Mitigación por tecnología El primero de los métodos es la mitigación usando la tecnología, cuyo objetivo es el de mejorar la tecnología de fabricación de chips para que aumente su tolerancia a la aparición de SEEs. Con este propósito se han se han producido una serie de avances tecnológicos entre los que destacan los siguientes: 1 https://indico.cern.ch/event/763013/contributions/3358878/attachments/1817838/2971899/Grou pD_CosmicRays.pdf 16 Figura 8. Celdas que se encuentran a una distancia D = 1, 2 o 3 con respecto a una celda central (coloreada en gris) en el método MD (a) y en el método IND (b) [27]. Estos métodos, junto con el parámetro 𝐷, se utilizarán para determinar si dos celdas afectadas por bitflips están a una distancia menor que esa distancia umbral. En el caso de usar el método MD, y de que se puedan asociar las direcciones lógicas a las físicas, estas últimas son colocadas en un plano XY [𝑎𝑖 → (𝑥𝑖 ,𝑦𝑖 ),𝑎𝑗→ (𝑥𝑗,𝑦𝑗 )] [26]. Si este nuevo par se encuentra a una distancia menor que 𝐷, se considera que ese par forma parte de un MCU. De tal forma que: 𝑑𝑀𝐷(𝑎𝑖,𝑎𝑗)= |𝑥𝑖− 𝑥𝑗|+|𝑦𝑖− 𝑦𝑗| ≤𝐷 Ecuación 2. Manhattan Distance (MD). Extraída del artículo [26]. Por otro lado, y de forma similar, se encuentra el método IND, cuya ecuación es expresada de la siguiente manera: 𝑑𝐼𝑁𝐷(𝑎𝑖,𝑎𝑗)= max(|𝑥𝑖− 𝑥𝑗|,|𝑦𝑖− 𝑦𝑗|) ≤𝐷 Ecuación 3. Infinite Norm Distance (IND). Extraída del artículo [26]. Para poder utilizar estas ecuaciones, lo primero es calcular las posibles parejas de celdas de memoria afectadas por la radiación. Sabiendo que el número total de bitflips observados en un experimento es 𝑁𝐵𝐹, se crea un conjunto con las posibles celdas de memoria que han sido afectadas, obteniendo 𝐴 = {𝑎1,𝑎2,...,𝑎 𝑁𝐵𝐹} [26]. A partir de este conjunto 𝐴, las parejas posibles de bitflips (𝑁𝑃) se calculan obteniendo todas las combinaciones posibles del conjunto 𝐴: 𝑁𝑃= (𝑁𝐵𝐹 2)= 1 2 ∙ 𝑁𝐵𝐹 ∙ (𝑁𝐵𝐹−1) Ecuación 4. Combinaciones del conjunto A. Ecuación extraída del artículo [26]. El siguiente paso es determinar cuáles de las parejas obtenidas se encuentran a una distancia menor que la distancia umbral, usando para ello las ecuacionesEcuación 2 y Ecuación 3. El uso de una u otra ecuación dependerá del investigador y del criterio que desee usar para determinar la distancia 𝐷. 17 Finalmente, utilizando la teoría de combinatoria, y más en concreto, ideas relacionadas con la resolución del problema de las urnas y las bolas 4 , se pueden utilizar los parámetros 𝑁𝑃 y 𝐷, definidos previamente, junto con el tamaño de la memoria (𝐿𝑁), para obtener las ecuaciones finales que devolverán un valor aproximado del posible número de falsos MCUs de multiplicidad 2 que se estima se producirán para un determinado número de bitflips observados en un experimento. Conociendo este número de bitflips, se puede obtener 𝑁𝑃, y con ello, se utilizan el resto de los parámetros para así obtener las ecuaciones Ecuación 5 y Ecuación 6. 𝑁𝐹𝑀2 ≃ 𝐿𝑁−1⋅ 𝑁𝑃 ⋅2 ⋅ 𝐷 ⋅ (𝐷+1) Ecuación 5. Ecuación final para estimar el número de falsos MCUs de multiplicidad 2, utilizando distancia MD. Extraída del artículo [26]. 𝑁𝐹𝑀2 ≃ 𝐿𝑁−1⋅ 𝑁𝑃 ⋅ 4 ⋅ 𝐷 ⋅ (𝐷+1) Ecuación 6. Ecuación final para estimar el número de falsos MCUs de multiplicidad 2, utilizando distancia IND. Extraída del artículo [26]. Estas dos ecuaciones serán las que se usen en la aplicación, la cual tendrá como parámetros el tamaño de la memoria, la distancia 𝐷 y el método a emplear (MD o IND). Con estos datos, se mostrará una gráfica con la probabilidad de aparición de falsos MCUs de multiplicidad 2 (eje Y) para un determinado número de bitflips observados en un experimento (eje X). De esta forma, el investigador podrá estimar de forma más precisa cuántos bitflips son necesarios observar para obtener una cierta probabilidad de aparición de falsos MCUs. Nótese que este trabajo se focaliza únicamente en la aparición de falsos eventos múltiples de multiplicidad 2, que son los primeros que tienen mayor probabilidad de aparecer en experimentos con un gran número de bitflips. A pesar de que puede estimar la probabilidad de ocurrencia de falsos MCUs de multiplicidad 3 [26] o incluso superior, su probabilidad de aparición es muy inferior, por lo que se han excluido del estudio de este trabajo. 4 https://www.statisticshowto.com/urn-model/ 18 3. Desarrollo de la aplicación Una vez explicada la función que cumplirá la aplicación, es hora de hablar de su desarrollo. A continuación, se expondrán los diferentes aspectos asociados al desarrollo como la plataforma, lenguaje de programación, configuración del proyecto y definición del código. 3.1 Plan de trabajo El primer paso a la hora de realizar una aplicación es reunir los requisitos. Para este caso son: • Elegir el lenguaje de programación que se va a usar. • Implementar un formulario para la introducción de datos de entrada. • Recoger los datos de ese formulario. • Dibujar un gráfico que, dados unos parámetros de entrada, muestre los resultados esperados. Por preferencia del autor, además de tener un gran número de librerías que son de ayuda para las interfaces gráficas, se usará Java como lenguaje para el desarrollo de la aplicación. Teniendo esto en cuenta, el punto de partida será desarrollar la funcionalidad básica del formulario y la comunicación del formulario con el gráfico. Una vez desarrollada esta funcionalidad, se deberán implementar los cálculos necesarios para que el gráfico muestre los datos apropiados. Y, por último, la interfaz de usuario, intentando obtener una interfaz que sea amable con el usuario y que sea consistente a lo largo de las diferentes pantallas de la aplicación. 3.2 Plataforma de desarrollo El lenguaje de programación escogido para el desarrollo ha sido Java. Debido a su gran popularidad, el lenguaje está dotado de una gran variedad de librerías de código que agilizan el trabajo del programador, así como una gran cantidad de foros de ayuda donde buscar información referente al funcionamiento de éste. Ya que el lenguaje elegido es Java, se ha decidido usar Eclipse (https://www.eclipse.org/) como plataforma de desarrollo. Esta plataforma aporta gran comodidad para el usuario automatizando tareas básicas y, por lo tanto, agiliza el desarrollo de la aplicación. Otras opciones como NetBeans o IntelliJ fueron descartadas debido a que el autor posee más experiencia con Eclipse que con las demás. Como complemento a esta plataforma, se ha usado GitHub (https://github.com/) como herramienta de almacenamiento en la nube. Bien es conocido que GitHub es una de las plataformas predilectas para que los programadores guarden su código. Sus funcionalidades de gestionado de versiones, así como su detección automática de los cambios hacen que se merezca su popularidad. Además, ofrece la posibilidad de crear repositorios privados que pueden ser publicados con un solo clic. 3.3 JavaFX Para el diseño gráfico de la aplicación se han utilizado las librerías externas de JavaFX (https://openjfx.io/). Estas librerías aportan clases con un diseño 19 predeterminado para determinadas funcionalidades. En este caso se ha utilizado principalmente para el gráfico resultante tras aplicar los cálculos. Para el formulario que recopila los datos de entrada que se pedirán al usuario, se ha usado JavaFX también pero no se ha usado un diseño predeterminado. En su lugar se ha utilizado un diseño propio del autor creado mediante la herramienta SceneBuilder cuya integración con Eclipse es facilitada por JavaFX. Esta integración permite la creación de archivos FXML, que son archivos de código HTML pero adaptados para que puedan ser leídos por las clases de JavaFX. Los archivos FXML son editados desde el programa SceneBuilder con una interfaz gráfica. Cuando el diseñador guarda los cambios dentro del programa SceneBuilder, se actualiza el fichero FXML con el código HTML asociado a los elementos que estén actualmente en la interfaz gráfica. Figura 9. Menú de contexto de un fichero FXML. Haciendo clic derecho en un fichero FXML, el menú de opciones muestra la opción de abrir con SceneBuilder. Esto abre la interfaz gráfica de desarrollo del elemento que hayamos escogido. En el caso de la Figura 10, el formulario que recoge los datos de entrada. Figura 10. Interfaz gráfica de SceneBuilder. 20 En el panel de la izquierda se puede observar el panel de herramientas que utiliza SceneBuilder con todos los elementos que se pueden añadir al fichero FXML (Figura 11), así como los elementos que se están usando en el fichero actual (Figura 12). Figura 11. Menú de opciones de SceneBuilder. Figura 12. Lista de elementos usados en SceneBuilder. 21 En la derecha se sitúa el panel de opciones para un elemento. Al seleccionar un elemento (por ejemplo, una etiqueta de texto), se podrán gestionar desde este panel opciones de estilo, disposición, así como un identificador que posteriormente se podrá usar en el código JavaFX o un identificador de clase CSS. Figura 13. Menú de opciones de un elemento. 3.4 Configuración del proyecto Al ser JavaFX un conjunto de librerías externas es necesario realizar cierta configuración al proyecto para poder obtener su funcionalidad. Figura 14. Extensión e(fx)clipse. 22 Lo primero es instalar una extensión desde el Marketplace de Eclipse llamada e(fx)clipse (Figura 14). Esta extensión permitirá a Eclipse crear proyectos de JavaFX y ficheros de tipo FXML. Una vez creado el proyecto con la nueva opción que ha sido habilitada, es necesario añadir las librerías correspondientes a JavaFX al propio proyecto. En versiones anteriores del Java Development Kit (JDK), estas librerías venían incluidas, pero en versiones más recientes hay que instalarlas aparte. Para ello, es necesario descargarse el fichero SDK desde la página web de JavaFX y añadirlo como librerías de usuario al Build Path del proyecto. Figura 15. Librería de usuario para JavaFX. Una vez creada la librería, por último, es necesario añadirla al “Modulepath” del proyecto junto con el propio SDK, el cual será añadido al Classpath (Figura 15 y Figura 16). Figura 16. Java Build Path del proyecto. 23 3.5 Estructura del proyecto La estructura del proyecto se compone de tres paquetes diferentes. El primer paquete, cuyo nombre es “form”, es el que contiene la clase “AlternativeMain.java” que ejecuta el programa y muestra el formulario dado un fichero “Form.fxml” y otro fichero “Form.css”, que aportan el estilo de la interfaz de usuario. Dentro de este paquete también se encuentra la clase “FormFX.java”, que controla los datos introducidos por el usuario en el formulario con apoyo de los enumerados “MethodSelection.java” y “SizeSelection.java”. El segundo paquete, que tiene como nombre “linechart”, usa la clase Memory.java para realizar los cálculos y mostrar el gráfico. Y, por último, el paquete “resources” que contiene los ficheros FXML y CSS, además de las clases controladoras de escenas. Estas clases controladoras se encargan de recoger los datos necesarios de una escena y enviarlos a la nueva escena que se va a mostrar al usuario. Estas clases, junto con los ficheros FXML y CSS, los cuales se encargan de aportar estilo a la interfaz, con las encargadas de crear estas escenas y mostrarlas al usuario por pantalla. Figura 17. Estructura del proyecto en Eclipse. Adicionalmente a estos paquetes, los proyectos de JavaFX requieren de un archivo module-info.java. Este fichero contiene requerimientos, así como permisos del módulo de JavaFX para que funcione correctamente. En este caso: 24 Figura 18. Clase module-info.java. El módulo HelloFX contiene los requerimientos de librerías de JavaFX que usa la aplicación: javafx.controls, javafx.graphics, javafx.fxml y javafx.base. Estas son las librerías que se usan en toda la aplicación y gracias a la instrucción “opens” (Figura 18), se permite el acceso de los paquetes de la aplicación a las librerías de JavaFX correspondientes. Adicionalmente, la instrucción “exports” sirve para que a la hora de exportar el proyecto a un formato JAR ejecutable, este ´sea exportado junto con las librerías necesarias. 3.6 Código A continuación, se explicará el código desarrollado para el funcionamiento de la aplicación. En esta explicación se seguirá el flujo de ejecución normal del programa explicando la funcionalidad de cada clase y cuándo se ejecuta cada parte del código. 3.6.1 Formulario Lo primero que el usuario puede observar al ejecutar la aplicación es el formulario de introducción de parámetros. Como ya se ha expuesto en apartados anteriores, estos parámetros son el tamaño de la memoria en Mbits, la distancia 𝐷, y el método de agrupación de bitflips. Además, también se da la opción de realizar los cálculos hasta que se llegue a una probabilidad del 99% de aparición de falsos MCUs. Figura 19. Formulario de parámetros. 25 Como se ha explicado en el apartado “3.3 JavaFX”, se ha usado la herramienta SceneBuilder para crear la interfaz de usuario de la Figura 19, resultando en el fichero FXML “Form.fxml”. En la Figura 20 se muestra parte de este fichero, en concreto, el código asociado al campo de la distancia 𝐷. Este extracto muestra el código asociado al texto “Distance” (líneas 77 a 84), así como el del campo de introducción de datos (líneas 85 a 92) y el de la etiqueta de error que aparece cuando los datos introducidos no son válidos (líneas 93 a 100). También se puede observar que dos de estos elementos tienen la propiedad “fx:id” ("distanceTextField" y "distanceError"). Estos identificadores servirán para poder conectar el código Java con el código FXML y permitir el traspaso de datos entre escenas. Figura 20. Fragmento de código extraído del fichero Form.fxml Complementando al fichero FXML, es posible añadir un fichero CSS para definir el estilo gráfico de la ventana. Aunque SceneBuilder es capaz de configurar gran cantidad de parámetros de estilo, hay algunos como el color del fondo o los bordes que se han de añadir desde un fichero externo (Figura 21). Figura 21. Fichero CSS asociado al formulario principal. 32 4. Resultados Una vez desarrollada la aplicación, se ha procedido al análisis de los resultados aportados por la misma dando diferentes valores a los datos de entrada que se le solicitan al usuario. El objetivo es compararlos con diversos experimentos realizados con anterioridad en campañas de irradiación realizadas por el grupo de investigación GHADIR de la Universidad Complutense de Madrid y analizar si, en aquellos casos, el uso de la herramienta hubiese conllevado una mayor eficiencia y un mayor ahorro de tiempo y recursos. 4.1 Estudio de las ecuaciones de probabilidad Las figuras Figura 33 - Figura 38 muestran los resultados obtenidos por la aplicación para memorias de tamaños 1Mx8 bits y 2Mx8 bits que ya han sido estudiadas y cuyos resultados son conocidos. Estas memorias están fabricadas por Infineon Technologies y fueron estudiadas bajo radiación en las publicaciones [28] - [30] . Figura 33. Análisis de la probabilidad de aparición de falsos MCUs, para una memoria de tamaño = 1MX8 bits y D = 1. Método MD. Como se puede observar, al usar el método MD (Figura 33), que considera un menor rango de celdas como celdas vecinas, la probabilidad de aparición de falsos MCUs aumenta más lentamente que en el caso de la Figura 34, llegando a un 99% de probabilidad de aparición de falsos MCUs con 4396 bitflips, en comparación con los 3109 que requiere una memoria de idéntico tamaño, pero utilizando el método IND. 33 Figura 34. Análisis de la probabilidad de aparición de falsos MCUs, para una memoria de tamaño = 1MX8 bits y D = 1. Método IND. Figura 35. Análisis de la probabilidad de aparición de falsos MCUs, para una memoria de tamaño = 1MX8 bits y D = 5. Método MD. 34 Figura 36. Análisis de la probabilidad de aparición de falsos MCUs, para una memoria de tamaño = 1MX8 bits y D = 5. Método IND. A continuación, en las Figura 35 y Figura 36, se observa que, al aumentar la distancia D de 1 a 5, se incrementa de forma drástica la probabilidad de aparición de falsos eventos múltiples para una memoria del mismo tamaño, ya que el número de celdas vecinas que se agruparán bajo el mismo evento múltiple aumenta con el parámetro D. Esto tiene un claro impacto en las Figura 33 y Figura 34. En lo que antes se necesitaban 4396 y 3109 bitflips respectivamente, en estos casos se necesitan 1136 y 803 respectivamente. Figura 37. Análisis de la probabilidad de aparición de falsos MCUs, para una memoria de tamaño = 2MX8 bits y D = 1. Método MD. 35 Figura 38. Análisis de la probabilidad de aparición de falsos MCUs, para una memoria de tamaño = 4MX8 bits y D = 1. Método MD. Finalmente, en las Figura 37 yFigura 38, se compara lo obtenido para una memoria de tamaño 2Mx8 bits y otra cuyo tamaño es el doble (4Mx8 bits). Al aumentar el tamaño de la memoria, se aumenta el número de direcciones que se pueden ver afectadas por los SEEs. Por tanto, para un mismo número de bitflips repartidos entre toda la memoria, es menos probable que se vean afectadas dos celdas vecinas y, por lo tanto, aumenta el número de bitflips necesarios para llegar a la misma probabilidad de aparición de falsos MCUs. En todos estos casos se puede observar que la curva de probabilidad tiene una forma similar, ya que la pantalla en la que se muestra se adapta de forma proporcional a la cantidad de resultados que ha de mostrar. Esto ayuda enormemente a ver la dependencia que tiene la aparición de los falsos MCUs con el tamaño de la memoria, el criterio de agrupación elegido y distancia que el investigador elija para agrupar bitflips en MCUs. Figura 39. Obtención del número máximo de bitflips que se deben observar para que la probabilidad de aparición de falsos MCUs sea menor o igual que p. 36 Adicionalmente, se ha implementado en la aplicación una funcionalidad de apoyo que consiste en que, dada una probabilidad p0 de aparición de falsos MCUs, la aplicación devuelve el número de bitflips que se deben observar a partir de los cuales esta probabilidad es mayor o igual que p0 (Figura 39). Esto servirá de apoyo para encontrar de forma rápida exactamente cuál es el número de bitflips que, como mucho se deben observar un experimento, si se desea moderar la probabilidad de aparición de falsos MCUs por debajo de un umbral deseado p0. 4.2 Estudio de experimentos previos con memorias en aceleradores de partículas Finalmente, en esta sección se comentan resultados experimentales realizados en investigaciones previas [28] – [30] y se compararán con los datos obtenidos de la aplicación. Al compararlos el objetivo principal es valorar si estos experimentos se realizaron bajo condiciones de alta probabilidad de falsos MCUs comprobando el número de bitflips observados en los mismos y comparándolos con los datos obtenidos de la aplicación. En todos los casos se utilizaron memorias de 16 Mbits de tamaño, una distancia 𝐷 = 3 y MD como método de agrupación. Al introducir estos datos en la aplicación se obtiene la curva de probabilidad representada en la Figura 41. 4.2.1 Primer experimento El primero de los experimentos analizados [28], realizado en Mayo de 2015, se centró en el estudio de la sensibilidad a los SEEs de las memorias de tipo SRAM que sean comerciales o COTS (“Commercial-Off-The-Shelf”), ya que cada vez son más populares en los ámbitos aeronáuticos y espaciales en los que la radiación está muy presente. El motivo del uso de este tipo de memorias es su bajo coste y su fiabilidad ante estos eventos gracias a los códigos de corrección de errores ya mencionados en la sección 1.3.3 Mitigación por redundancia. Muchos dispositivos actuales permiten el uso de la técnica “Dynamic Voltage Scaling” (DVS) para un uso óptimo de la energía. El objetivo del DVS es conseguir reducir el consumo de energía de los componentes que más consuman cuando no necesiten tanto voltaje y de esta forma ahorrar esa energía. Como consecuencia, y como ya se ha observado en previos estudios [31] [32], al reducirse el voltaje, se aumenta la probabilidad de aparición de SBUs/MCUs, por lo tanto, tanto en este como en el resto de los experimentos analizados, se realizaron diferentes rondas de irradiación con diferentes voltajes para estudiar cómo afecta este factor a la aparición de SBUs y MCUs. Voltaje (V) SBU 2-bit 3-bit 4-bit 5-bit 6-bit 7-bit 8-bit 9-bit 10bit 0.50 1645 96 12 8 2 0 0 0 0 1 0.60 1385 89 10 3 0 0 0 0 0 0 0.70 1215 96 13 3 1 1 0 0 0 0 0.80 1065 97 15 4 0 0 0 0 0 0 0.90 876 99 12 4 0 0 0 0 0 0 1.00 734 79 16 5 0 1 1 0 0 0 1.20 623 69 7 0 0 0 0 0 0 0 3.30 86 12 2 1 0 0 0 0 0 0 Tabla 1. Resultados del experimento [28]. 37 Las pruebas de este primer experimento se realizaron en varias rondas de irradiación con neutrones a 14.2 MeV en el “GEnerator of NEutrons Pulsed and Intense” (GENEPI2) con una memoria de 90-nm fabricada por Infineon Technologies (CY62167EV30LL-45ZXI). Los resultados obtenidos se muestran en la Tabla 1. En este caso, los datos aportados no muestran directamente el número de bitflips por cada ronda, pero sí el número total de SBUs y MCUs con diversas multiplicidades (de 2 a 10). Por tanto, para obtener el número de bitflips de cada experimento solo hace falta sumar todos los eventos multiplicados por su multiplicidad correspondiente obteniendo así el resultado de la Tabla 2. Voltaje (V) Número total de bitflips 0.50 1925 0.60 1605 0.70 1469 0.80 1320 0.90 1126 1.00 973 1.20 782 3.30 120 Tabla 2. Número total de bitflips observados en las rondas experimentales de [28]. Adicionalmente, cabe mencionar que la memoria utilizada estaba dividida en dos módulos iguales y que, debido a un error, uno de ellos quedó inoperativo, por lo que los resultados obtenidos serían los correspondientes a los de una memoria 1Mx8 bits. Al introducir estos parámetros en la aplicación, se obtienen los resultados de la Figura 40. Figura 40. Análisis de la probabilidad de aparición de falsos MCUs, para una memoria de tamaño = 1MX8 bits y D = 3. Método MD. 38 Como se puede observar en la Figura 40, la probabilidad máxima de aparición de falsos MCUs (99%) se produce a partir de los 1795 bitflips, lo cual sitúa la mayoría de las rondas de irradiación por debajo de este umbral. En este caso se decidió realizar rondas de irradiación de muy poco tiempo para optimizar el escaso tiempo disponible del que se disponía en el acelerador. La consecuencia de ir “a ciegas” fue obtener, en algunas de las rondas, muy pocos resultados, lo cual limitó la calidad de las conclusiones obtenidas en ese experimento al no ser estadísticamente muy fuertes. Esto se observa de forma muy clara en las pruebas correspondientes a 1.2V y a 3.3V, donde los eventos múltiples de más de 3 bits son prácticamente inexistentes. Si la aplicación que se ha desarrollado en este Trabajo de Fin de Grado hubiese estado disponible antes de la realización del experimento, habría sido de gran ayuda para que los investigadores pudieran ajustar la extensión del experimento para una utilización óptima del escaso tiempo del que se disponía en el acelerador. 4.2.2 Segundo experimento La idea detrás de este segundo experimento fue reforzar los resultados obtenidos del primero evitando el error que se produjo en aquella ocasión. Estas pruebas [29] tuvieron lugar en Mayo del 2017 en el acelerador GENEPI2 exponiendo las memorias a flujos de neutrones a con una energía media de 14.2 MeV en un rango de 2.00×107 a 2.41×107 𝑛/𝑐𝑚2/𝑠. En este caso se usaron 3 memorias de Infineon Technologies de 65-nm (CY 62167GE30-4 5ZXI), 90-nm (CY 62167EV 30LL 45ZXI) y 130-nm (CY 62167DV 30LL 55ZXI) respectivamente. Duración (mins.) Voltaje (V) Bitflips 3 0.72 4393 3 0.8 3876 3 0.9 3515 3 1 3163 3 1.1 2976 3 1.2 2878 3 1.3 2565 3 1.4 2342 3 1.5 2244 3 1.7 1670 3 2 1188 3 2.5 824 3 2.8 543 3 3.17 516 5 3.17 4160 3 3.17 475 5 3.17 3929 Tabla 3. Resultados del experimento [29] para la memoria de 130-nm. En la Tabla 3 se muestran los resultados para la memoria de 130-nm, los cuales fueron muy similares a los de la memoria de 90-nm [29]. A continuación, en la Tabla 4 se muestran los resultados de la memoria de 65-nm, que era tecnológicamente muy diferente a las otras 2 y que, además, implementaba un código de corrección de errores que hubo que desactivar para realizar los experimentos. 39 Duración (mins.) Voltaje (V) Bitflips 2 0.8 1276 2 0.9 1109 2 1 876 2 1.1 885 5 1.3 1854 2 1.5 734 5 2 1756 5 2.5 1708 5 3.17 1850 Tabla 4. Resultados del experimento [29] para la memoria de 65-nm. Al comparar estos datos con los obtenidos de la aplicación en la Figura 41, se puede observar que a partir de 2538 bitflips, la probabilidad de encontrarse con falsos MCUs es del 99% o superior. Por lo tanto, en el caso de la memoria de 130-nm la situación es la contraria a la del primer experimento, en la cual el resultado de desconocer la probabilidad de falsos MCUs conllevó que el investigador no pudiese ajustar la duración del experimento a una donde hubiese una probabilidad razonable de aparición de falsos MCUs y que, en 9 ocasiones se superase ese umbral de 2538 bitflips, dándose cifras muy superiores en algunas de ellas. Figura 41. Análisis de la probabilidad de aparición de falsos MCUs, para una memoria de tamaño = 2MX8 bits y D = 3. Método MD. Alternativamente, al contrastar los datos de la memoria de 65-nm, todos los resultados quedan en la zona de la gráfica donde esta probabilidad es más baja ya que el caso en el que más bitflips se observan son 1854 (para un voltaje de 1.3V) la probabilidad es de ocurrencia de falsos MCUs en ese caso fue del 91,4%. 40 4.2.3 Tercer experimento Como se ha observado en los anteriores experimentos, el voltaje de alimentación es un factor a tener en cuenta ya que afecta a la sensibilidad de la memoria frente a la radiación. Por ello, este tercer experimento [30] se centra en analizar el impacto que el DVS tiene en la fiabilidad de las SRAMs. Las pruebas [30] fueron realizadas en Marzo del 2021 en el Institut LaueLangevin (ILL) usando el acelerador de neutrones térmicos "Thermal and Epithermal Neutron Irradiation Station" (TENIS) usando las 3 mismas memorias de Infineon Technologies que en el experimento 2. Para cada memoria se realizaron pruebas con rangos de voltajes entre 0.5 y 3.23 V exponiéndolas a un flujo de 2.86×109 𝑛/𝑐𝑚2/𝑠. Los resultados se muestran en la Tabla 5 y la Tabla 6. Voltaje (V) Bitflips observados 65-nm 90-nm 130-nm 3.23 184 716 519 3 189 744 562 2.5 174 696 552 2 153 804 564 1.5 160 766 810 1 446 1044 1606 0.9 565 1392 2110 0.85 710 1498 2396 0.8 975 1756 2938 0.75 1148 1976 3474 0.7 - 2564 4230 0.65 - 3252 4862 0.6 - 3752 6098 0.55 - 4834 7800 0.5 - 6004 9296 Tabla 5. Resultados del experimento [30] (1). Voltaje (V) Bitflips observados 65-nm 90-nm 130-nm 3.23 181 624 510 3 182 646 478 2.5 175 646 428 2 177 654 750 1.5 161 682 788 1 437 926 1620 0.9 645 1254 2042 0.85 760 1438 2376 0.8 935 1722 2852 0.75 1228 2056 3318 0.7 - 2610 3860 0.65 - 3090 4714 0.6 - 3848 5956 0.55 - 4972 7320 0.5 - 6066 9142 Tabla 6. Resultados del experimento [30] (2). 41 En las tres columnas de la derecha de la Tabla 5 y la Tabla 6 se representan el número de bitflips observados en cada prueba que se realizó. Al igual que en los 2 experimentos anteriores, si esta aplicación hubiese estado disponible antes de la realización de este experimento, los investigadores podrían haber consultado de forma preventiva cuál es el máximo número de bitflips que se deberían observar para moderar la probabilidad de aparición de falsos MCUs bajo un cierto umbral. Sin embargo, en aquella ocasión (y en las anteriores, que ya se han explicado), estas pruebas fueron realizadas a ciegas. En este experimento, la situación es la misma a la de la memoria de 130-nm del segundo experimento, donde un gran porcentaje de las pruebas realizadas superan la probabilidad del 99% de falsos MCUs (que, igual que en el experimento 2, se consigue con 2538 bitflips). Por lo tanto, el investigador podría haber utilizado, en ambas situaciones, la información de la aplicación para moderar el tiempo de exposición frente a la radiación y así obtener datos experimentales con menos errores por ronda de irradiación, pero con una probabilidad de aparición de falsos eventos múltiples totalmente controlada. En aquel caso, esta situación se corrigió a posteriori, utilizando las ecuaciones (5) y (6) (explicadas en la sección 2.2) para estimar el número de falsos MCUs y restándolo al número total de MCUs observados. No obstante, esta no resulta una metodología ideal para un análisis exhaustivo de los resultados, ya que, si bien así se puede estimar con precisión el número de MCUs que verdaderamente ocurrieron en el experimento, la existencia de falsos MCUs limita la capacidad de un análisis más profundo de los eventos que ocurrieron, como por ejemplo su “forma” (es decir, si afectaron a celdas organizadas horizontal o verticalmente), u otros aspectos de interés.