Proyecto

Metodología

Solución propuesta

La solución propuesta para este reto es la realización de un sistema que, mediante la conexión entre múltiples computadoras y el uso de la arquitectura esclava-maestra, permita distribuir el procesamiento de 609 imágenes con una resolución de 3000px de anchura y 3000px de altura. A cada una de estas imágenes se le aplicarán seis filtros:

Escala de grises
Voltear verticalmente a color
Voltear verticalmente en escala de grises
voltear horizontalmente a color
Voltear horizontalmente en escala de grises
Desenfoque, con un valor de núcleo de 55 a 155 pixeles.

Entradas y salidas

Condiciones

Las condiciones de operación del experimento son que la máquina maestra se encuentre conectada con las computadoras esclavas por medio de un Switch Cisco Cataylist 2960 Plus. La computadora maestra deberá leer una carpeta de imágenes en formato .bmp (Bitmap), distribuyendo el procesamiento de estas entre las computadoras esclavas.

Las imágenes son procesadas de forma individual en su computadora esclava asignada, y son regresadas a la computadora maestra. La carpeta de salida generada es una subcarpeta "Results", la cual se guarda en la carpeta de orígen seleccionada. Dentro de la carpeta "Results", se crean subcarpetas que indican el tipo de filtro aplicado. Por ejemplo, la carpeta "Blur".

Proceso de desarrollo

Para desarrollar el código se tomó como base el código del profesor, siendo que primeramente se modificaron las funciones sobre los filtros para el procesamiento de imágenes. Primeramente, se desarrolló una versión del código que procesara una imágen con múltiples filtros. Para ello, se adaptó el código del filtro en blanco y negro dado por el profesor, y se creó el resto de las funciones de los filtros.

Arquitectura

La arquitectura seleccionada para el proyecto fue la de procesamiento distribuído maestro-esclavo. Para desarrollar el proyecto se tomó como referencia el siguiente tutorial para la creación de clusters mediante MPICH, a pesar de que se modificaron algunas cosas:

https://help.ubuntu.com/community/MpichCluster

Para ello fue necesario verificar las especificaciones de las computadoras con el fin de elegir a la computadora maestra. Las especificaciones son las siguientes:

	Sistema Operativo	RAM	Cores	GHz
Sarai	Windows 11	16 GB	6	2.60 GHz
Marlon	Windows 11	16 GB	8	2.30 GHz
Christian	macOS	8 GB	8	4.05 GHz
Alejandro	Arch Linux	16 GB	8	2.30 GHz

En base a esto, se eligió la computadora de Marlon como la maestra, y las computadoras de Saraí y Christian como las esclavas. Una vez elegido esto, se decidió crear las máquinas virtuales con las siguientes especificaciones:

	Nombre de usuario	Nucleos	RAM (MB)	ROM (GB)
Marlon	ub0	6	10240 MB	200 GB
Christian	ub1	8	8192 MB	120 GB
Sarai	ub2	6	9179 MB	100 GB

Máquina virtual maestra

Para crear la máquina virtual de la computadora maestra se utilizó Ubuntu Desktop 24.04. Se le brindó un total de 6 núcleos, 10240 MB de RAM y un espacio de disco virtual de 120 GB. Tras haber creado la máquina virtual se ejecutaron los siguientes comandos:

sudo hostnamectl set-hostname ub0
sudo apt-get update
sudo apt-get install openssh-server nfs-server build-essential mpich keychain mpich

# En caso de estar usando Debian
sudo apt-get install netplan.io

Una vez hecho esto se estableció la configuración de las máquinas virtuales como Red Puenteada con enps03, es decir, la interfaz Ethernet de cada una de las computadoras. Esto se realizó en la interfaz de Oracle VirtualBox.

Como siguiente paso, se modificó el archivo de red (ubicado en /etc) con la siguiente configuración.

# En caso de estar usando Debian
sudo mkdir /etc/netplan

# Siempre
sudo nano /etc/netplan/00-installer-config.yaml

Aplicándole el siguiente contenido:


network:
    version:2
    ethernets:
        enp0s3:
            dhcp4: false
            addresses:
                - 192.168.133.100/24
            nameservers:
                addresses:
                  - 8.8.8.8
                  - 1.1.1.1
            routes:
                - to: 0.0.0.0/0
                  via: 192.168.133.1

sudo netplan apply

# En caso de estar en Debian
sudo systemctl restart systemd-networkd.service

Tras ello, dentro de la computadora se modificó el archivo /etc/hosts con el siguiente contenido: sudo nano /etc/hosts


127.0.0.1     localhost
192.168.133.100 ub0
192.168.133.101 ub1
192.168.133.102 ub2
192.168.133.103 ub3

Tras ello, es necesario crear la carpeta correspondiente que será sincronizada. También se comparte el contenido de la carpeta con otros nodos y se reinicia el servicio en la carpeta maestra.

sudo mkdir /mirror
echo "/mirror *(rw,sync)" | sudo tee -a /etc/exports
sudo service nfs-kernel-server restart

Tras ello se crea un usuario llamado mpiu con ID ub0 en cada una de las computadoras, y se le brinda permisos.

sudo adduser --uid 1234 --home /mirror/mpiu /mpiu

Como siguiente paso, y para generar la comunicación mediante SSH, aplicamos los siguientes comandos:

su - mpiu
ssh-keygen -t rsa
cd .ssh
cat id_rsa.pub >> authorized_keys

#Para probar la conexión
ssh ub1 hostname

Una vez hecho esto es necesario

Máquinas virtuales esclavas

Para crear la máquina virtual de las computadoras esclavas se utilizó Ubuntu. Se les brindó un total de 8 núcleos, 8192 MB de RAM y un espacio de disco virtual de 50 GB. Se le dio nombre a las máquinas por medio del prefijo "ub", seguido del número de computadora al que se refiere. Tras haber las máquinas virtuales se ejecutaron los siguientes comandos.

# Instalar los paquetes necesarios
sudo apt-get update
sudo apt-get install openssh-server nfs-client openmpi-bin libopenmpi-dev

Una vez hecho esto se estableció la configuración de las máquinas virtuales como Red Puenteada con enps03, es decir, la interfaz Ethernet de cada una de las computadoras. Esto se realizó en la interfaz de Oracle VirtualBox.

Como siguiente paso, se modificó el archivo de red (ubicado en /etc) con la siguiente configuración.

sudo nano /etc/netplan/00-installer-config.yaml

Aplicándole el siguiente contenido, donde depende de la dirección IP:


network:
    version:2
    ethernets:
        enp0s3:
            dhcp4: false
            addresses:
                - 192.168.133.102/24
            nameservers:
                addresses:
                  - 8.8.8.8
                  - 1.1.1.1
            routes:
                - to: 0.0.0.0/0
                  via: 192.168.133.1

sudo netplan apply

Tras ello, dentro de la computadora se modificó el archivo /etc/hosts con el siguiente contenido: sudo nano /etc/hosts

127.0.0.1     localhost
192.168.133.100 ub0
192.168.133.101 ub1
192.168.133.102 ub2
192.168.133.103 ub3

Tras ello, es necesario crear la carpeta correspondiente que será sincronizada. sudo mkdir /mirror

Una vez hecho esto se monta la carpeta /mirror del nodo maestro en cada uno de los ordenadores esclavos.

omid@ub1:~$ sudo mount ub0:/mirror /mirror
omid@ub1:~$ sudo mount -a

omid@ub2:~$ sudo mount ub0:/mirror /mirror
omid@ub2:~$ sudo mount -a

omid@ub3:~$ sudo mount ub0:/mirror /mirror
omid@ub3:~$ sudo mount -a

Tras ello se crea un usuario llamado mpiu con ID ub0 en cada una de las computadoras, y se le brinda los permisos necesarios por medio de los siguientes comandos:

sudo useradd -u 1234 -d /mirror/mpiu -s /bin/bash mpiu
getent passwd mpiu

Compilación

Se utilizó este comando para compilar el código tanto en la computadora maestra como en las esclavas, considerando las dos arquitecturas distintas presentes en los dispositivos utilizados.

./build_on_all_nodes.sh

Después se ocupa este comando para comprobar que todos los nodos se encuentre conectados. Si alguno no se encuentra conectado, se cambia el machinefile

generate_machinefile.sh

Por último se ejecuta la interfaz desde python

python interface.py

Resultados

Como resultados se tiene que el sistema funciona correctamente, siendo que permite distribuir el procesamiento de las imágenes entre múltiples ordenadores. Se cumplen los resultados esperados y se hicieron varias pruebas con 100 imágenes, ya que el almacenamiento la computadora maestra no permitió hacer pruebas con 600 imágenes. El resultado que se consideró óptimo fue cuando se ocuparon 8 procesos distribuido en los 3 nodos, con este parámetro; el sistema procesó 100 imágenes en 454.448 segundos. Debido a esto, se estima que el sistema procesa las 600 imágenes en 2,726 segundos, o lo que es igual, en 45 minutos. Otra métrica de evaluación es que todas las imágenes hayan sido procesadas correctamente.

A continuación se muestran las evidencias del funcionamiento del sistema:

Pruebas de 100 imágenes

Prueba 1

Prueba 2

Prueba 3

Pruebas 100 imágenes sin conexión en ub2

Prueba

Estimación de costos

Para la implementación de nuestro sistema, podemos tomar como referencia la Mini PC Lanix Mini, con un procesador Intel Core i3-1215U, 16 GB de RAM, 512 GB de ROM SSD y sin un sistema operativo. Cada una de estas tiene un costo de $9,709.

En nuestro caso, nuestro sistema requiere de 3 computadoras, por lo que el costo es de $29,127. Consideramos que este dispositivo es suficiente para los requisitos especificados. El procesador tiene una velocidad de 4.40 GHz, mientras que cada computadora tiene 6 núcleos. La memoria RAM y ROM, por otro lado, es aún mayor que la usada en las máquinas virtuales.
Por otro lado, si queremos usar la computadora Xtreme PC Gaming Dragonfly-White con un AMD Ryzen 5 8500G, 32 GB de RAM, Windows 11, e incluyendo periféricos, se tiene una cantidad menor de núcleos a costo de una mayor cantidad de RAM. No obstante, los núcleos son un 14% más rápidos a los que tenemos en nuestros procesadores, con una velocidad de 800 MHz (casi el doble) y una velocidad similar de reloj. Se requerirían 3 computadoras, por lo que el costo sería $29,127. Se cumplen los requisitos especificados de velocidad de procesamiento, cada una de estas computadoras tiene 6 núcleos y 4.40 GHz. Las memorias son mayores.

La diferencia en núcleos es pequeña, el nuevo sistema tiene menos núcleos (18 vs. 20), lo que podría resultar en un ligero aumento en el tiempo de procesamiento. El nuevo sistema tiene considerablemente más RAM (48,000 MB vs. 27,611 MB). Esto permite manejar más datos simultáneamente y puede acelerar tareas que requieren mucha memoria. El aumento estimado es entonces de 10 minutos.

Otros datos importantes a mencionar son que este nuevo sistema tiene 6 núcleos en cada computadora, lo que significaría que el rendimiento debería ser similar. Las nuevas computadoras tienen más RAM (32,000 MB), lo que puede ser beneficioso para manejar aplicaciones que requieren mucha memoria. En este caso demasiada para el proyecto, por lo que en este caso en específico no se requiere de una cantidad tan grande. Los periféricos tampoco son necesarios. Debido a todas las características combinadas, se supone un aumento en el tiempo total de procesamiento del 50%, es decir, 21 minutos adicionales. Los periféricos tampoco son necesarios. Si cada computadora costara $11,719, el precio total sería de $35,157.
Por otro lado podemos usar la Workstation Lenovo ThinkStation P3 Tiny con un Intel Core i7-14700, 18 GB de RAM, 512 GB en SSD, una NVIDIA T400 y Windows 11. La nueva computadora tiene significativamente menos núcleos (4 en comparación con 6 en cada computadora), lo que probablemente resultará en un aumento un tanto considerable en el tiempo de procesamiento. No obstante, el modelo de procesador es similar a los que ya tenemos, siendo estos i7 con una velocidad similar. La cantidad de RAM también es menor (16,000 MB frente a 27,611 MB), lo que puede permitir que se procese una mayor cantidad de imágenes.
Finalmente, si deseamos usar la estimación de costos mediante AWS, tenemos las siguientes opciones:
- c5.2xlarge Núcleos: 8 vCPUs RAM: 16 GB Uso: Optimizada para computación intensiva. Precio: Aproximadamente $0.34 por hora. $0.34/hora × 0.7 horas × 3 = $0.714
- m5.2xlarge Núcleos: 8 vCPUs RAM: 32 GB Uso: Balance entre computación y memoria. Precio: Aproximadamente $0.384 por hora. $0.384/hora × 0.7 horas × 3 = $0.8064
- c5n.2xlarge Núcleos: 8 vCPUs RAM: 20 GB Uso: Alta capacidad de red y computación. Precio: Aproximadamente $0.43 por hora. $0.43/hora × 0.7 horas × 3 = $0.903

Condiciones del experimento

El experimento se ejecuta con todas las computadoras conectadas al switch correspondiente y desde la computadora maestra. La computadora maestra debe tener con anterioridad la carpeta de imágenes a procesar.

Conclusiones

Los elementos que consideramos importantes para la obtención de los resultados de la práctica son el tiempo de ejecución total que toma para que todo el sistema logre procesar todas las imágenes. De igual forma creemos que la práctica se realizó correctamente, permitiendo brindarle un sistema distribuido con múltiples alternativas y costos viables al socio formador. De igual manera, este proyecto permitió entender mejor la arquitectura esclavo-maestra y la forma en que es posible usar archivos ejecutables para distribuir la carga de procesamientos entre distintas máquinas. Fue también posible entender cómo las especificaciones de las computadoras influyen en el sistema. Otro tema que consideramos importante fue el abordar el procesamiento de imágenes, la teoría de cómo funcionan estas y la forma en que cada filtro opera diferentemente para producir resultados variados. El uso de C como lenguaje permitió también mejorar y refinar nuestras capacidades al respecto, algo que es fuertemente agradecido.

Cambios futuros

Como cambios futuros se proponen los siguientes cambios:

Optimizar las funciones de procesamiento de las imágenes para reducir el tiempo que tardan.
Probar con cantidades distintas de núcleos en las distintas máquinas virtuales.
Probar con distintas bases de datos de imágenes.

Navigation Menu

Repository navigation