PROCESAMIENTO DE DATOS EN MASA CON RASPBERRY PI

Procesamiento de datos en masa con Raspberry Pi Por Rubén Cuenca Martínez y María Ascensión Gómiz Guirao, alumnos de 2º de bachillerato en el IES Saavedra Fajardo de Murcia Tutora del proyecto: Dª. María Dolores Cánovas Amorós Fecha de presentación: 23/02/2020

Índice 1. Introducción……………………………………………………………………......…………….…...……3 2. Antecedentes…………………………………………………………………..……………………………4 2.1. Tarjetas Raspberry Pi………………………………………………………..……….......................…..4 2.2. Clúster……………………………………………………………..…………………..………….....…..4 2.3. NOOB lite………………………………………………………..……………………………....……...4 2.4. Raspbian……………………………………………………………………...…………………....….....4 2.5. Lenguaje de programación C++………………………………………………...………….……………4 2.6. Aplicación e importancia de los números primos…………………………………...…………...……...4 2.7. Algoritmo demostración para el cálculo de números primos……………………………………....……5 3. Hipótesis y objetivos de la investigación…………………………………………………………………..7 3.1. Hipótesis…………………………………………………………………………………………………7 3.2. Objetivo 1: Construcción e instalación del clúster………………………………………………………7 3.3. Objetivo 2: Redacción del programa demostración………………………………………...…………...7 4. Materiales y métodos…………………………………………………………………………………….....8 4.1. Materiales………………………………………………………………………………………………..8 4.2. Métodos………………………………………………………………………………………………….8 4.2.1. Construcción del clúster………………………………………………………………………...8 4.2.2. Instalación del clúster…………………………………………………………………………...9 4.2.3. Programa redactado en lenguaje C++……………………………………………………....….10 4.2.4. Aplicación del algoritmo y demostración de la hipótesis………………………………….......10 5. Resultados………………………………………………………………………………………….…...….11 6. Conclusiones……………………………………………………………………………………….…...….13 7. Agradecimientos………………………………………………………………………………….……......14 8. Bibliografía y webgrafía……………………………………………………………………….……….....15

1

Abstract A raíz del interés suscitado por el mundo de la programación y la informática, se nos planteó construir un superordenador a partir de tarjetas Raspberry Pi, enlazadas en paralelo, y ejecutar en estas un programa desarrollado para el cálculo de números primos, de gran importancia en la computación y en las matemáticas. Se nos presentó entonces una hipótesis: el número de núcleos procesando datos y el tiempo que para ello necesitan siguen una relación inversamente proporcional; y dos objetivos directamente relacionados: en primer lugar la construcción e instalación del clúster, y en segundo la redacción del programa demostración. La metodología empleada para la demostración de la hipótesis, tras la construcción del cluster y redacción del programa en C++, se basa en la comparación entre tomas que hicimos del tiempo que el cluster tarda en hacer el cálculo del programa en función del número de núcleos de las tarjetas empleados para ello. Atendiendo a los resultados hemos podido afirmar que el tiempo de cada toma y el número de núcleos empleados presentan una relación potencial decreciente, pues a más núcleos, mucho menor será el tiempo de cálculo. Este tipo de supercomputadores pueden emplearse para muchos otros proyectos, pudiéndose aplicar especialmente en aquellos que impliquen el procesamiento de datos en masa. No olvidemos que hoy en día vivimos en un mundo de la información, de datos.

In the wake of the aroused interest in the world of programming and informatics, we considered constructing a supercomputer from Raspberry pi cards, parallely linked to each other, and execute with them a program developed for the calculation of prime numbers, of great significance in IT and mathematics. We then posed the hypothesis that the number of processor cores was inversely proportional to the time it took them to complete the calculation of the algorithm; and therefore the two following objectives: first the construction and installation of the cluster, and second the writing of the demonstration program. The followed methodology for finding a valid proof for the hypothesis was based on comparing the time it took the cluster to complete the calculus depending on the amount of processing cores working at a time for the mentioned purpose. Attending to the gathered results, we were able to affirm that the time taken for completing the calculation presented a decreasing potential relation with the processing cores used for this purpose. This sort of supercomputers can be used in many other projects, specially those implying processing mass data. We must not forget that in the present, we live in a world of information, of data.

2

1. Introducción El siguiente trabajo tiene como fin demostrar la capacidad de procesamiento de datos en masa con Raspberry Pi. Para ello elaboraremos un programa demostración que calculará cuántos números primos hay por debajo de un número hasta llegar al cero y el tiempo empleado por cada tarjeta para ello.

Las tarjetas Raspberry Pi son placas que soportan varios componentes necesarios en un ordenador común.

Pueden enlazarse entre ellas para potenciar su rendimiento y capacidad de procesamiento. Nuestro proyecto tratará de ejecutar el mismo programa demostración en cuatro tarjetas enlazadas en paralelo; una tarjeta principal controla remotamente a las otras tres tarjetas subordinadas. De esta manera demostraremos cómo aumenta la capacidad de procesamiento con un mayor número de núcleos programados en hilos.

Elegimos este proyecto debido a la creciente popularidad de Raspberry Pi, cosa que nos llamó la atención y por ello decidimos investigar más sobre el tema. Finalmente encontramos un proyecto similar realizado por un estudiante universitario estadounidense, quien había hecho un supercomputador con 1200 tarjetas Raspberry Pi. Nos pareció asombroso todo lo que se podía hacer uniendo estas tarjetas y por ello decidimos realizar nuestro propio supercomputador a menor escala, con un añadido: un programa demostración redactado por nosotros mismos que sea capaz de calcular cuántos números primos hay desde cualquier número hasta cero.

3

2. Antecedentes.

2.1. Tarjetas Raspberry PI Raspberry PI es una placa computadora simple con una capacidad de procesamiento similar a la de un ordenador de sobremesa corriente. Se utiliza de manera extensa como una computadora común o en otros campos como la robótica. Fue desarrollada y lanzada a la venta en 2012 por la Raspberry PI Foundation, y es el fácil acceso que se tiene a ellas lo que las hace tan adecuadas para su uso en la enseñanza, objetivo por el cual fueron creadas.

2.2. Clúster Un clúster es un conjunto de tarjetas trabajando en paralelo. Al enlazar varias tarjetas de forma paralela se optimiza, como cabe esperar, su rendimiento, pues un número determinado de nodos estarán realizando una misma tarea. De esta manera podremos diferenciar dos tipos de tarjetas según su función en el clúster: principales y subordinadas. Esta forma de procesamiento es idónea para cálculos con grandes iteraciones, y es por eso por lo que haremos uso de ella para enlazar nuestras tarjetas.

2.3. NOOBS lite Es una aplicación de Raspberry PI que se descarga en la tarjeta de memoria y sirve como instalador del sistema operativo de Raspberry (raspbian).

2.4. Raspbian Es un sistema operativo creado por Raspberry y muy recomendado para Raspberry Pi porque está optimizado para su hardware. Está basado en una versión de GNU/Linux llamada Debian. Utilizaremos la versión Raspbian Pixel porque necesitamos un entorno gráfico completo, tal y como se utiliza en un ordenador de sobremesa.

2.5. Lenguaje de programación C++ C++ es un lenguaje de programación sencillo recomendado para principiantes en la programación e indicado para el sistema operativo Raspbian.

2.6. Aplicación e importancia de los números primos Los números primos son aquellos que solamente se pueden dividir por sí mismos y por 1. En la descomposición factorial de cualquier número, sólo aparecen factores primos. De esta forma: 9 = 3·3, 58 = 2·29, 15 = 3·5, etc. Y es en esto en lo que radica la gran importancia de los números primos. Aún no se ha hallado la sucesión que siguen los números primos, si es que siguieran alguna, pero sí que existen algoritmos para hallarlos, como el que aplicaremos en nuestro programa y que viene explicado en el próximo apartado.

Podemos justificar su importancia de muchas formas. Dando un ejemplo aplicado, sirven para codificar información de manera segura mediante códigos criptográficos. Estos códigos criptográficos se descomponen en el producto de dos números primos muy grandes secretos, siendo entonces muy difíciles de hallar y de descifrar el código.

4

2.7. Algoritmo demostración para el cálculo de números primos (elaboración propia) Un algoritmo es un conjunto de operaciones sistemáticas que permite hacer un cálculo con el objetivo final de obtener una solución a algún problema. El algoritmo que introduciremos en el programa nos permitirá hallar los números primos contenidos entre el cero y un número natural que nosotros elijamos.

Justificaremos el algoritmo de la siguiente manera: El primer resultado es necesario para demostrar el segundo, la caracterización de los números primos que se usa en el programa. a) Teorema. Algoritmo de la división para enteros positivos.

Si n, d son dos enteros positivos entonces existen enteros q y r tales que n = d·q + r, 0 ≤ r < d y son únicos.

Demostración: Como n no es una cantidad infinita existirá un número máximo de veces que se puede sustraer d de n. Si q es ese número entonces d·q ≤ n, y tomando r = n - d·q tenemos que 0 ≤ r. Si d ≤ r entonces 0 ≤ r - d = n - d·q - d = n - d·(q + 1) y q no sería el número máximo de veces que se puede sustraer d de n. Entonces tenemos que existen q y r tales que n = d·q + r, 0 ≤ r < d Para ver que son únicos supongamos que existen s y t tales que n = d·s + t, 0 ≤ t < d Entonces si r = t tendremos que 0 = n - n = d·q + r - d·s - t = d·(q - s) y por tanto q - s = 0 y q = s. Si r y t son distintos, por ejemplo, r < t tendremos que 0 = n - n = d·q + r - d·s - t = d·(q - s) + r - t → t - r = d·(q - s) y entonces t - r es un múltiplo de d menor que d. La única posibilidad es t - r = 0 y como antes q - s = 0.

En cualquier caso q = s y r = t. b) Proposición. Cualquier número primo p mayor que 3 es de la forma p = 6·k ± 1.

Demostración: Por el teorema anterior existen q y r tales que p = 6·q + r con 0≤ r < 6. Entonces r = 0, 1, 2, 3, 4, 5.

No puede ser r = 0 porque entonces p = 6·q y p no sería primo.

5

Tampoco puede ser r = 2 porque p = 6·q + 2 = 2·(3·q + 1) y p sería divisible por 2 y tampoco sería primo. Lo mismo ocurre con r = 4.

Tampoco puede ser r = 3 porque p = 6·q + 3 = 3·(2·q + 1) y p sería divisible por 3.

En el caso de r = 1 tendríamos una parte del resultado: p = 6·q + 1, con k = q.

En el caso de r = 5 tendríamos la otra parte: p = 6·q + 5 = 6·q + 6 - 1 = 6·(q + 1) - 1, con k = q + 1.

6

3. Hipótesis y objetivos de la investigación Nuestro proyecto tiene una hipótesis principal y dos objetivos.

3.1 Hipótesis principal El número de núcleos procesando datos y el tiempo que para ello necesitan siguen una relación inversamente proporcional.

La hipótesis principal sustenta que cuanto mayor sea el número de núcleos que procesan una cantidad determinada de datos, menor será el tiempo invertido en ello.

Esto es debido a la llamada programación en paralelo, la cual usaremos en nuestro proyecto para demostrar cómo dividiendo el número de datos que cada núcleo debe procesar, disminuimos el tiempo de cálculo.

En nuestro proyecto emplearemos cuatro tarjetas Raspberry Pi con cuatro núcleos cada una, lo cual hace dieciséis núcleos en total.

3.2 Objetivo 1: Construcción e instalación del clúster En primer lugar nos proponemos enlazar cuatro tarjetas Raspberry Pi en paralelo, estableciendo una tarjeta principal y otras tres subordinadas.

3.3 Objetivo 2: Redacción del programa demostración En segundo lugar buscamos redactar un programa para el cálculo de números primos en hilos en lenguaje de programación C++ y aplicarlo al clúster, de manera que podamos demostrar la hipótesis principal.

4. Materiales y métodos 4.1 Materiales Para construir el clúster hemos usado: ● ● ● ● ● ● ● ● ● ● ● ●

Cuatro tarjetas Raspberry Pi 4 Un monitor HDMI de la marca Acer Un teclado USB Un ratón inalámbrico Cuatro unidades de potencia Micro-USB de 1V a 5V Cuatro cables latiguillos de red Un conmutador de red de ocho puertos Una conexión a Internet Cuatro tarjetas SD compatibles con Raspberry Pi de 32GB Cuatro ventiladores para el sistema de refrigeración de las tarjetas Cuatro bases separadoras para Raspberry Pi Barras hexagonales roscadas

7

4.2 Métodos Nuestro proyecto tiene dos vertientes, una física (construcción del clúster) y otra informática (instalación del clúster y redacción del programa y demostración del algoritmo empleado para el cálculo de números primos).

4.2.1 Construcción del clúster Para construir el clúster seguimos varios pasos: ●

Paso 1. Atornillar cada tarjeta a su base transparente correspondiente y adherir los disipadores de calor.

●

Paso 2. Atornillar cada ventilador a la base de la tarjeta que va sobre la cual a la que vamos a conectar el ventilador.

●

Paso 3. Para instalar el ventilador de la última tarjeta lo atornillamos al separador que sirve como techo del clúster, además este separador incluye una rejilla metálica de ventilación.

●

Paso 4. Conectamos los ventiladores a las tarjetas, el cable rojo al segundo pin GPIO por la derecha y el cable negro al tercer pin GPIO por la derecha.

●

Paso 5. Ponemos las tarjetas, ya montadas sobre sus bases y con los ventiladores conectados, una sobre otra.

Posteriormente enroscamos las barras hexagonales de manera de que clúster queda unido y asegurado. ● Paso 6. Conectamos los cables latiguillos de red a cada tarjeta y al conmutador de red, lo haremos por orden, es decir, al primer puerto del conmutador conectaremos la primera tarjeta y así sucesivamente. ● Paso 7. Conectamos las fuentes de alimentación a cada tarjeta y a la red. ● Paso 8. Conectamos los cables HDMI a cada tarjeta. Aquí nos encontramos la complicación de solo podíamos conectar una tarjeta al monitor, por ello, debíamos ir cambiando el cable HDMI cada vez que queríamos cambiar de tarjeta.

● Paso 9. Conectamos el teclado USB y el ratón a la tarjeta principal, al igual que con el HDMI, solo podíamos Figura 1. Proceso de elaboración del clúster. Elaboración propia. conectarlo a cada tarjeta cada vez. ●

Paso 10. Insertamos las tarjetas SD en cada raspberry.

4.2.2 Instalación del clúster Para instalar el clúster seguimos varios pasos: ●

Paso 1. Formateamos las tarjetas SD y copiamos los archivos de NOOBS lite (se pueden descargar en la propia web de Raspberry Pi).

●

Paso 2. Una vez que tenemos los archivos de NOOBS lite descargados y descomprimidos, iniciamos las tarjetas una por una y descargamos el sistema operativo Raspbian en su versión completa. Antes de instalarlo nos pide el idioma que vamos a usar y el del teclado, nosotros usamos inglés para comunicarnos con el ordenador y español para el teclado debido a caracteres especiales como la ‘ñ’.

8

Cuando el sistema operativo haya sido instalado, requerirá una clave para cada tarjeta que posteriormente será necesaria para poder enlazarlas.

Tras realizar este paso en cada una de las tarjetas tenemos cuatro ordenadores independientes, para que trabajen en paralelo deberemos enlazar tres tarjetas a una principal. ●

Paso 3. Actualizar la configuración del sistema para la activación del HDMI y la resolución de la pantalla introduciendo en la ventana de comandos las siguientes líneas. Esto permitirá que el vídeo de cada raspberry se adapte a nuestro monitor. sudo nano /boot/config.txt hdmi_force_hotplug=1 hdmi_group=1 hdmi_mode=5

●

Paso 4. Actualizamos el sistema operativo para trabajar con la última versión utilizando el comando: sudo apt-get update

●

Paso 5. Para enlazar las tarjetas necesitamos averiguar las direcciones IP de cada tarjeta. Para ello utilizaremos el siguiente comando: ip addr show eth0 De esta manera aparecerá en la ventana de comandos la dirección IP de cada tarjeta tras la palabra ‘inet’. La dirección aparecerá de la forma xxx.xxx.xxx.xx/xx, los dos últimos dígitos tras la barra no son necesarios por lo que prescindiremos de ellos.

●

Paso 6. En el menú Preferences/Raspberry Pi Configuration pestaña se cambia el nombre Hostname a ‘raspberrypi1’, ‘raspberrypi2’, ‘raspberrypi3’ o ‘raspberrypi4’ según la tarjeta. En la pestaña Interfaces se habilita SSH; un protocolo de administración remota a través del cual se puede controlar y modificar servidores remotos de contraseñas, ya que toda la información está cifrada. Por tanto la comunicación entre los sistemas cliente y servidor es segura, evitando de esta manera posibles intercepciones de la comunicación entre ambos sistemas y/o personificaciones de un determinado host.

●

Paso 7. Se establece la conexión segura desde la ventana de comandos de la tarjeta principal llamando mediante el comando ssh pi@xxx.xxx.xx a cada tarjeta subordinada. Tras llamar a una tarjeta la clave de dicha tarjeta nos será requerida, deberemos teclear la clave que establecimos en el paso 2 al iniciar el sistema operativo.

●

Paso 8. Añadir la clave pública a la lista de claves autorizadas (se debe instalar la clave de la raspberry pi 1 en la raspberry pi 2 y la de la raspberry pi 3 en la raspberry pi 4), usando el comando: $ ssh-copy-id pi@xxx.xxx.xxx.xxx

Esto lo realizaremos en cada tarjeta subordinada e introduciremos la clave establecida en el paso dos para la tarjeta principal.

Esto permite realizar operaciones sin que se pida la contraseña.

Por ejemplo, para copiar archivos desde la pi1 a la pi2: scp <ARCHIVO> 9

pi@xxx.xxx.xxx.xx: <DIRECTORIO> Para ejecutar un programa en la pi2 ordenándolo desde la pi1 usamos el comando: pi@raspberrypi2:˜ $ sudo <PROGRAMA> 4.2.3 Programa redactado en lenguaje C++ El programa está dividido en un programa servidor y un programa cliente. El programa cliente se ejecutará en la tarjeta principal y será en este donde introduciremos el número de rango máximo de cálculo del algoritmo y con cuántas tarjetas e hilos por tarjeta haremos el cálculo. Por otra parte, el programa servidor debe ser ejecutado en todas las tarjetas que queramos usar para el cálculo, ya que será aquel que realice las operaciones y establezca con cuántos hilos trabaja cada tarjeta según los datos introducidos.

Para iniciar el programa, se debe llamar al programa servidor en cada una de las tarjetas. Una vez hecho esto, llamaremos el programa cliente en la tarjeta principal.

Con el fin de demostrar nuestra hipótesis principal, el código del programa fue redactado de tal manera que en pantalla se muestre cuánto tiempo tarda en realizar el cálculo de números primos cada tarjeta y con cuántos hilos lo ha hecho.

Además, para evitar que el programa se sature, establecimos un número máximo que es 100 000 000. Esto quiere decir que a partir de ese número el programa no se ejecutará.

4.2.4 Aplicación del algoritmo y demostración de la hipótesis Está claro que podremos confirmar que hemos construido un clúster si al probarlo y al ejecutar el programa el clúster funciona correctamente.

El método que seguiremos para demostrar la hipótesis se basa en el cálculo de datos por hilos. Estableceremos un hilo de cálculo por núcleo para obtener la mayor eficiencia posible, al tener cuatro tarjetas y cuatro núcleos por cada una de ellas el número de hilos que emplearemos irá de uno a dieciséis. Correspondiendo un hilo a un núcleo de una tarjeta y los dieciséis hilos a los cuatro núcleos de las cuatro tarjetas.

No se harán tomas de tiempo para combinaciones de tarjetas y núcleos que resulten en el mismo número de núcleos trabajando con distinto número de tarjetas. Así por ejemplo, si programamos el clúster para que trabaje una tarjeta con dos hilos por tarjeta, haremos que trabajen dos hilos. Así mismo, si escribimos que el clúster trabaje con dos tarjetas y con un hilo por tarjeta habrá dos hilos trabajando de la misma forma. En ambos casos sería hacer cada cálculo de la misma manera y llevaría exactamente el mismo tiempo.

Además, no estableceremos más de un hilo por cada núcleo para no ralentizar el proceso de cálculo ya que de esa manera uno de ellos debería trabajar el doble lo que supondría un mayor tiempo y por tanto un incorrecto aprovechamiento del clúster.

Después de esto se representarán los datos del tiempo tomado para cada cálculo en función del número de tarjetas empleadas para el mismo en una nube de puntos. De esta manera podremos manejar y visualizar los datos fácilmente para posteriormente llegar a las conclusiones oportunas.

10

5. Resultados En la imagen siguiente se puede ver cómo queda terminado el clúster tras su construcción con éxito.

A continuación se muestran las tablas con los resultados obtenidos tras la aplicación del algoritmo. Estas muestran la relación entre el tiempo que le toma al clúster hacer el cálculo del algoritmo en función del número de hilos que se emplean.

La toma de datos se ha realizado para el cálculo de números primos dentro de distintos rangos de números. Estos rangos de números se indican encima de cada tabla, en los que el número indicado es el tope hasta el que se hace el cálculo empezando desde el cero.

El algoritmo está programado de tal forma que para hacer las tarjetas funcionar se debe indicar el número de hilos con los Figura 2. Clúster terminado. Elaboración propia. que trabaja cada núcleo de cada tarjeta. La manera más eficiente de hacerlas trabajar es con hilo por núcleo, de otra forma se ralentizará el proceso. Por ello el máximo de hilos por tarjeta es cuatro, ya que corresponde con el número de núcleos de cada tarjeta.

Figura 3. Tiempos en función del nº de hilos para 10 000 000.

Elaboración propia.

Figura 5. Tiempos en función del nº de hilos para 30 000 000.

Elaboración propia.

Figura 4. Tiempos en función del nº de hilos para 20 000 000.

Elaboración propia.

Figura 6. Tiempos en función del nº de hilos para 40 000 000.

Elaboración propia.

11

Figura 7. Tiempos en funciĂłn del nÂş de hilos para 50 000 000.

ElaboraciĂłn propia.

Figura 8. Tiempos en funciĂłn del nÂş de hilos para 60 000 000.

ElaboraciĂłn propia.

Figura 9. Tiempos en funciĂłn del nÂş de hilos para 70 000 000.

ElaboraciĂłn propia.

Figura 10. Tiempos en funciĂłn del nÂş de hilos para 80 000 000.

ElaboraciĂłn propia.

Figura 11. Tiempos en funciĂłn del nÂş de hilos para 90 000 000.

ElaboraciĂłn propia.

Figura 12. Tiempos en funciĂłn del nÂş de hilos para 100 000 000.

ElaboraciĂłn propia.

Como se muestra en las tablas, el tiempo necesario para realizar el cĂĄlculo disminuye describiendo, aproximadamente, una curva potencial de la forma đ?&#x2018;Ś = đ?&#x2018;Ľ đ?&#x2018;&#x203A; con n<0 segĂşn aumentamos el nĂşmero de hilos empleados para realizar dicho cĂĄlculo. Esto se produce debido a que al aumentar el nĂşmero de hilos, la cantidad de datos que debe procesar cada nĂşcleo disminuye y se distribuye en funciĂłn del nĂşmero de hilos que hayamos determinado para realizar el cĂĄlculo.

De este modo podemos comprobar en las tablas como el menor valor para el tiempo coincide con el mayor nĂşmero de hilos y viceversa. Estableciendo asĂ­ una proporcionalidad inversa entre ambas variables. Esto se cumple para todos los casos, sin importar el rango de nĂşmeros sobre los que se tiene que hacer el cĂĄlculo.

12

6. Conclusiones Remitiéndonos al trabajo de campo podemos concluir que hemos conseguido construir un clúster con éxito ya que desde la raspberry principal podemos llamar a las otras tres tarjetas subordinadas y poder operar así desde una de ellas sin necesidad de un conmutador de vídeo, teclado y ratón. Con esto logramos cumplir el objetivo 1: Construcción e instalación del clúster.

Además, al redactar un programa que es capaz de calcular cuántos números primos hay desde el cero hasta cierto número y con un número de hilos, determinados ambos por el usuario, cumplimos también nuestro objetivo 2: Redacción del programa demostración de datos en masa.

Habiendo logrado los objetivos propuestos y como se muestra en las gráficas del apartado de resultados (figuras 3-11) podemos verificar nuestra hipótesis principal, y además afirmar que el número de núcleos procesando datos y el tiempo que para ello necesitan siguen una relación potencial decreciente.

Esto se debe al hacer uso de hilos para procesar datos en paralelo, si establecemos un hilo por cada núcleo de cada tarjeta y los hacemos funcionar, el tiempo que cada hilo necesitará para realizar el cálculo de números primos será el mínimo posible. Esto se debe a que al dividir la cantidad de cálculos que debe hacer el núcleo de cada tarjeta independientemente de las demás el rendimiento se optimizan notablemente.

Por el contrario, si estableciésemos más de un hilo por núcleo lo sobrecargaríamos, y el tiempo de cálculo sería mayor ya que un mismo núcleo debería trabajar el doble.

En un futuro, una interesante ampliación de este proyecto sería el enlazamiento de un número mayor de tarjetas, quizá de hasta ocho tarjetas Raspberry pi, lo que resultaría en un supercomputador mucho más potente que el anterior.

Además, este tipo de supercomputadores puede emplearse para muchos otros proyectos que impliquen el procesamiento de datos en masa como son por ejemplo el análisis de grandes nubes de datos para la recreación de relieves por fotogrametría.

13

7. Agradecimientos En última instancia nos gustaría dedicar un apartado para reconocer el esfuerzo y cuidado de aquellos que han contribuido a la realización de este proyecto, de principio a fin. A Doña María Dolores Cánovas Amorós, tutora del proyecto, a Doña Virginia Verdú Tortosa, profesora en la asignatura de Investigación y a Don Antonio Gómiz, matemático.

14

8. Bibliografía y webgrafía.

Dennis, A. K. (2013). Raspberry Pi Super Cluster. Birmingham-Mumbai: Packt publishing.

Sánchez Laguna, J. A. (2019). Tecnología de la programación: Introducción a C. Murcia: Universidad de Murcia, Facultad de Informática.

Autor desconocido (2019). C++. www.cplusplus.com [Consulta: 1 de octubre de 2019].

15