HPC18_ThreadingMultiprocessing_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Computación de Alto Desempeño</h1>\n",
    "<h1 align=\"center\">Threading y Multiprocessing en Python</h1>\n",
    "<h1 align=\"center\">2024</h1>\n",
    "<h1 align=\"center\">MEDELLÍN - COLOMBIA </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "|[![Outlook](https://img.shields.io/badge/Microsoft_Outlook-0078D4?style=plastic&logo=microsoft-outlook&logoColor=white)](mailto:calvarezh@udemedellin.edu.co)||[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/carlosalvarezh/HPC/blob/main/HPC18_ThreadingMultiprocessing_Python.ipynb)\n",
    "|-:|:-|--:|\n",
    "|[![LinkedIn](https://img.shields.io/badge/linkedin-%230077B5.svg?style=plastic&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/carlosalvarez5/)|[![@alvarezhenao](https://img.shields.io/twitter/url/https/twitter.com/alvarezhenao.svg?style=social&label=Follow%20%40alvarezhenao)](https://twitter.com/alvarezhenao)|[![@carlosalvarezh](https://img.shields.io/badge/github-%23121011.svg?style=plastic&logo=github&logoColor=white)](https://github.com/carlosalvarezh)|\n",
    "\n",
    "<table>\n",
    " <tr align=left><td><img align=left src=\"https://github.com/carlosalvarezh/Curso_CEC_EAFIT/blob/main/images/CCLogoColorPop1.gif?raw=true\" width=\"25\">\n",
    " <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license.(c) Carlos Alberto Alvarez Henao</td>\n",
    "</table>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Introducción**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La programación concurrente juega un papel fundamental en la optimización del rendimiento y la eficiencia en las aplicaciones modernas. En Python, existen dos enfoques principales para lograr la concurrencia: **Threading** y **Multiprocessing**. A lo largo de este texto, exploraremos las diferencias entre ambos enfoques, sus ventajas y casos de uso ideales. Además, realizaremos una demostración práctica mediante la descarga de imágenes, evaluando el rendimiento de cada técnica para ilustrar cuándo es más conveniente utilizar uno u otro enfoque."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Concurrencia vs. Paralelismo**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Concurrencia (Threading)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La **concurrencia** es la capacidad de un programa para manejar múltiples tareas de forma simultánea. No implica la ejecución simultánea real en diferentes núcleos de CPU, sino que permite la superposición de tareas mediante el uso de \"cambio de contexto\" (context switching). Así, las tareas parecen ejecutarse al mismo tiempo al alternar rápidamente entre ellas. Esta técnica se emplea en un único núcleo de CPU, maximizando su uso al intercambiar entre las tareas en intervalos cortos de tiempo. \n",
    "\n",
    "Un ejemplo clásico de uso de concurrencia es la descarga de archivos desde la web o la lectura y escritura de datos, donde el programa puede aprovechar los tiempos de espera de una operación de entrada/salida (I/O) para realizar otra tarea, sin detener completamente la ejecución."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Paralelismo (Multiprocessing)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El **paralelismo**, por otro lado, se refiere a la ejecución simultánea real de tareas en múltiples núcleos de CPU. Aquí, las tareas son independientes y se dividen entre varios procesos que se ejecutan en paralelo, lo que permite acelerar significativamente la ejecución. El paralelismo es ideal para tareas que requieren un uso intensivo de CPU, como el procesamiento de grandes volúmenes de datos o cálculos matemáticos complejos, donde cada núcleo puede encargarse de una parte de la tarea.\n",
    "\n",
    "Mientras que la concurrencia ofrece la apariencia de simultaneidad dentro de un solo núcleo, el paralelismo utiliza múltiples núcleos para lograr una verdadera simultaneidad."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Casos de Uso**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Concurrencia (Threading):** Es ideal para tareas **I/O-bound**, donde el programa debe esperar por operaciones externas, como leer archivos, hacer solicitudes a APIs o interactuar con bases de datos. Utilizar hilos permite solapar estas operaciones de espera con otras tareas, mejorando la eficiencia general.\n",
    "  \n",
    "  Ejemplo: El scraping web es un caso donde la concurrencia es útil, ya que permite realizar múltiples solicitudes simultáneamente para recopilar datos de varias páginas web, mejorando el tiempo de respuesta.\n",
    "  \n",
    "- **Paralelismo (Multiprocessing):** Es más adecuado para tareas **CPU-bound**, donde el tiempo de ejecución depende de cálculos intensivos. Al dividir la carga de trabajo entre múltiples núcleos de CPU, se puede acelerar significativamente el procesamiento de datos.\n",
    "\n",
    "  Ejemplo: El procesamiento de grandes volúmenes de datos, donde cada núcleo de la CPU se encarga de una porción de los datos, es un caso típico de paralelismo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Desventajas**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ambos enfoques presentan retos y sobrecargas asociadas.\n",
    "\n",
    "- **Concurrencia (Threading):** \n",
    "  - **Sobrecarga de sincronización:** Coordinar los recursos compartidos entre hilos puede ser complejo, y los errores de sincronización pueden generar condiciones de carrera o bloqueos.\n",
    "  - **Dificultad para depurar:** Los programas concurrentes son más difíciles de depurar debido al comportamiento no determinista generado por la intercalación de los hilos.\n",
    "  \n",
    "- **Paralelismo (Multiprocessing):**\n",
    "  - **Sobrecarga de comunicación:** La coordinación entre procesos requiere mecanismos explícitos como comunicación entre procesos (IPC) o memoria compartida, lo que puede afectar el rendimiento.\n",
    "  - **Desbalance de carga:** En entornos paralelos, es crucial que las tareas estén bien distribuidas entre los procesos; de lo contrario, algunos procesos pueden quedar subutilizados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Threading en Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El **Threading** en Python permite la ejecución concurrente de tareas utilizando múltiples hilos dentro de un único proceso. Estos hilos comparten el mismo espacio de memoria, pero debido al **[Global Interpreter Lock (GIL)](https://realpython.com/python-gil/)**, la ejecución de código en múltiples hilos no puede aprovechar completamente múltiples núcleos de CPU. Por esta razón, el threading es más apropiado para tareas **I/O-bound**, donde los hilos pueden esperar sin bloquear todo el proceso.\n",
    "\n",
    "**Ejemplo de Threading**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importar el modulo threading\n",
    "import threading\n",
    "\n",
    "# definición de la función que se ejecuta con threadings\n",
    "def funcion_hilo(nombre):\n",
    "    print(f\"Hola desde el hilo {nombre}\")\n",
    "\n",
    "# creación de los hilos (threads) y ejecución de la función\n",
    "hilo = threading.Thread(target=funcion_hilo, args=(\"Hilo 1\",))\n",
    "hilo.start()\n",
    "hilo.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Multiprocessing en Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El **Multiprocessing** permite un verdadero paralelismo al utilizar múltiples procesos, cada uno con su propio espacio de memoria. Esto hace que el multiprocessing sea ideal para tareas **CPU-bound** que pueden distribuirse entre varios núcleos.\n",
    "\n",
    "**Ejemplo de Multiprocessing**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importar el modulo multiprocessing\n",
    "import multiprocessing\n",
    "\n",
    "# definición de la función que se ejecuta en paralelo\n",
    "def funcion_proceso(nombre):\n",
    "    print(f\"Hola desde el proceso {nombre}\")\n",
    "\n",
    "# Inicio del procesamiento paralelo.\n",
    "proceso = multiprocessing.Process(target=funcion_proceso, args=(\"Proceso 1\",))\n",
    "proceso.start() # inicializa el proceso paralelo\n",
    "proceso.join()  # finaliza el proceso paralelo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Comparativa: Threading vs. Multiprocessing**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Realizaremos una comparativa de rendimiento mediante una tarea práctica de descarga de imágenes usando ambos enfoques.\n",
    "\n",
    "#### **Código Base para la Comparativa**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import timeit\n",
    "import requests\n",
    "import threading\n",
    "import multiprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crear una lista para almacenar las imágenes descargadas desde la URL del servicio `picsum.photos`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_urls = []\n",
    "for i in range(100,500):\n",
    "    image_urls.append(f'https://picsum.photos/{i}')\n",
    "\n",
    "print(image_urls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `descargar_imagen` se define para gestionar la descarga de imágenes. Toma como parámetro una URL de imagen (`image_url`) y utiliza la biblioteca `requests` para obtener la imagen desde la URL. Si la descarga es exitosa (con un código de estado 200), la imagen se guarda en el directorio `images` con un nombre de archivo derivado de la URL. Si ocurre un error durante la descarga, se imprime un mensaje de error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def descargar_imagen(url):\n",
    "    respuesta = requests.get(url)\n",
    "    if respuesta.status_code == 200:\n",
    "        with open(f\"images/{url.split('/')[-1]}.png\", 'wb') as f:\n",
    "            f.write(respuesta.content)\n",
    "    else:\n",
    "        print(f\"Error al descargar la imagen {url}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejecución Normal (Secuencial)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ejecucion_normal():\n",
    "    inicio = timeit.default_timer()\n",
    "    for url in image_urls:\n",
    "        descargar_imagen(url)\n",
    "    fin = timeit.default_timer()\n",
    "    print(f'Tiempo de Ejecución Normal: {fin-inicio}')\n",
    "    \n",
    "ejecucion_normal()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Ejecución con Threading**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def descarga_threading():\n",
    "    inicio = timeit.default_timer()\n",
    "    threads = []\n",
    "    for url in image_urls:\n",
    "        t = threading.Thread(target=descargar_imagen, args=(url,))\n",
    "        threads.append(t)\n",
    "    for hilo in threads:\n",
    "        hilo.start()\n",
    "    for hilo in threads:\n",
    "        hilo.join()\n",
    "    fin = timeit.default_timer()\n",
    "    print(f'Tiempo de Ejecución con Threading: {fin-inicio}')\n",
    "\n",
    "descarga_threading()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejecución con Multiprocessing**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `descarga_multiprocessing` en Python utiliza el módulo de multiprocesamiento para ejecutar en paralelo la descarga de imágenes desde una lista de URLs, creando un proceso independiente para cada imagen. Los procesos se gestionan con los métodos `start()` y `join()`, y se mide el tiempo de ejecución para evaluar el rendimiento. La función `descargar_imagen` debe estar definida para que la descarga funcione correctamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def descarga_multiprocessing():\n",
    "    inicio = timeit.default_timer()\n",
    "    procesos = []\n",
    "    for url in image_urls:\n",
    "        proceso = multiprocessing.Process(target=descargar_imagen, args=(url,))\n",
    "        procesos.append(proceso)\n",
    "    for proceso in procesos:\n",
    "        proceso.start()\n",
    "    for proceso in procesos:\n",
    "        proceso.join()\n",
    "    fin = timeit.default_timer()\n",
    "    print(f'Tiempo de Ejecución con Multiprocessing: {fin-inicio}')\n",
    "\n",
    "descarga_multiprocessing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Conclusión**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Threading** y **Multiprocessing** en Python son técnicas poderosas que permiten la ejecución concurrente y paralela de tareas, respectivamente. El threading es más adecuado para tareas I/O-bound, mientras que el multiprocessing es ideal para tareas CPU-bound. Aunque threading tiene limitaciones debido al GIL, sigue siendo útil para aplicaciones que requieren concurrencia sin un alto uso de CPU. Por su parte, multiprocessing permite un verdadero paralelismo, aunque a costa de una mayor sobrecarga en recursos del sistema.\n",
    "\n",
    "El uso adecuado de cada enfoque depende del tipo de tarea a ejecutar y los recursos disponibles. Es fundamental comprender las diferencias y limitaciones para lograr un rendimiento óptimo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Comparación directa entre Python y C**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "| Característica               | Threading (Python)            | Multiprocessing (Python)    | OpenMP (C)                   | MPI (C)                      |\n",
    "|------------------------------|-------------------------------|-----------------------------|------------------------------|------------------------------|\n",
    "| **Modelo de paralelismo**     | Concurrencia simulada (GIL)    | Paralelismo real (procesos)  | Paralelismo real (hilos)      | Paralelismo distribuido       |\n",
    "| **Uso de múltiples núcleos**  | Limitado por el GIL            | Completo (sin GIL)           | Completo                     | Completo                     |\n",
    "| **Memoria compartida**        | Sí (entre hilos)               | No (procesos separados)      | Sí (entre hilos)              | No (memoria distribuida)      |\n",
    "| **Comunicación**              | Fácil entre hilos (mismo proceso) | Requiere IPC (más costoso)   | Natural (memoria compartida)  | Paso de mensajes (más costoso)|\n",
    "| **Escalabilidad**             | Limitado a una máquina         | Limitado a una máquina       | Escalable en memoria compartida | Escalable en clústeres       |\n",
    "| **Simplicidad de uso**        | Sencillo, pero limitado        | Relativamente simple         | Sencillo con directivas       | Complejo, control manual      |\n",
    "| **Casos de uso ideal**        | Tareas I/O-bound               | Tareas CPU-bound en una máquina | Tareas CPU-bound en memoria compartida | HPC, simulaciones a gran escala |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **¿Cuándo usar uno u otro?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Usar Threading en Python**:\n",
    "- Cuando las tareas son **I/O-bound** (lectura/escritura de archivos, operaciones de red).\n",
    "- Cuando el paralelismo real no es necesario, y la concurrencia es suficiente.\n",
    "- Cuando se busca una solución sencilla y fácil de implementar.\n",
    "\n",
    "**Usar Multiprocessing en Python**:\n",
    "- Cuando las tareas son **CPU-bound** y necesitan aprovechar múltiples núcleos.\n",
    "- Cuando se busca paralelismo real dentro de una sola máquina sin las limitaciones del GIL.\n",
    "- Cuando se pueden tolerar los costos de memoria y comunicación entre procesos.\n",
    "\n",
    "**Usar OpenMP en C**:\n",
    "- Cuando las tareas son intensivas en CPU y requieren **paralelismo real** en múltiples núcleos.\n",
    "- Cuando el sistema tiene una arquitectura de **memoria compartida**.\n",
    "- Cuando se desea una paralelización sencilla de bucles o secciones críticas del código.\n",
    "\n",
    "**Usar MPI en C**:\n",
    "- Cuando se necesita **paralelismo distribuido** en sistemas de memoria distribuida (clústeres, supercomputadoras).\n",
    "- Para simulaciones y aplicaciones de computación de alto rendimiento (HPC).\n",
    "- Cuando la aplicación requiere escalar a miles de nodos y puede tolerar la complejidad adicional de la programación y la comunicación interproceso.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Ejercicios**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejercicio 1: Cálculo Paralelo de Números Primos en un Rango (CPU-bound)**\n",
    "\n",
    "**Descripción**:  \n",
    "Dado un rango grande de números (por ejemplo, de 1 a 10 millones), queremos encontrar todos los números primos que existen en ese rango. Para optimizar el tiempo de ejecución, dividirás la tarea en subconjuntos más pequeños y usarás **Multiprocessing** para distribuir el trabajo entre varios núcleos.\n",
    "\n",
    "- **Instrucciones**:\n",
    "  1. Crea una función que reciba un rango de números y retorne una lista de números primos dentro de ese rango.\n",
    "  2. Usa `multiprocessing.Pool` para dividir el rango completo (1 a 10 millones) en partes iguales, asignando cada parte a un proceso separado.\n",
    "  3. Recoge los resultados de cada proceso y combina las listas de números primos en una única lista final.\n",
    "  4. Imprime el total de números primos encontrados y mide el tiempo de ejecución total del proceso paralelo.\n",
    "  5. Realiza una comparación del tiempo de ejecución usando multiprocessing versus una ejecución secuencial.\n",
    "\n",
    "- **Específico**:\n",
    "  - El rango debe ser 1 a 10 millones.\n",
    "  - Divide el rango en 8 partes iguales, para que cada proceso maneje 1/8 del total.\n",
    "  - Muestra el total de números primos encontrados y el tiempo de ejecución total.\n",
    "\n",
    "- **Pista**: Usa la función `Pool.map()` para distribuir el trabajo entre los procesos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejercicio 2: Suma de un Arreglo Gigante con Multiprocessing (CPU-bound)**\n",
    "\n",
    "**Descripción**:  \n",
    "Tienes un arreglo de enteros muy grande (por ejemplo, 100 millones de elementos) y necesitas calcular la suma de todos los elementos de manera eficiente. Utiliza **Multiprocessing** para dividir el arreglo en varias partes, asignando cada parte a un proceso separado, y luego combina los resultados.\n",
    "\n",
    "- **Instrucciones**:\n",
    "  1. Genera un arreglo con 100 millones de enteros aleatorios.\n",
    "  2. Divide el arreglo en 10 subarreglos iguales.\n",
    "  3. Crea una función que reciba un subarreglo y retorne la suma de sus elementos.\n",
    "  4. Usa `multiprocessing.Pool` para crear 10 procesos que sumen los subarreglos en paralelo.\n",
    "  5. Al finalizar, combina las sumas parciales para obtener la suma total del arreglo.\n",
    "  6. Imprime la suma total y el tiempo de ejecución total.\n",
    "  7. Compara el tiempo de ejecución con una suma secuencial (sin multiprocessing).\n",
    "\n",
    "- **Específico**:\n",
    "  - El arreglo debe contener exactamente 100 millones de enteros aleatorios generados entre 1 y 1000.\n",
    "  - El arreglo debe dividirse en 10 partes iguales, cada una con 10 millones de elementos.\n",
    "  - Calcula e imprime el tiempo de ejecución paralelo y el secuencial.\n",
    "\n",
    "- **Pista**: Utiliza la librería `numpy` para generar el arreglo rápidamente.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejercicio 3: Simulación de Monte Carlo para Estimar π (CPU-bound)**\n",
    "\n",
    "**Descripción**:  \n",
    "Usarás el método de Monte Carlo para estimar el valor de π. El método consiste en lanzar puntos aleatorios dentro de un cuadrado y calcular cuántos caen dentro de un círculo inscrito. Para mejorar el rendimiento, paralelizarás la simulación usando **Multiprocessing**.\n",
    "\n",
    "- **Instrucciones**:\n",
    "  1. Implementa una función que simule el lanzamiento de `n` puntos aleatorios y calcule cuántos caen dentro del círculo.\n",
    "  2. Usa `multiprocessing.Pool` para dividir la tarea en 6 procesos, cada uno con una parte del total de lanzamientos.\n",
    "  3. Recoge los resultados de los procesos y calcula la estimación final de π usando la fórmula:\n",
    "     \\[\n",
    "     \\pi \\approx 4 \\times \\frac{\\text{puntos dentro del círculo}}{\\text{total de puntos lanzados}}\n",
    "     \\]\n",
    "  4. Imprime el valor estimado de π y el tiempo total de ejecución.\n",
    "  5. Compara los resultados obtenidos y el tiempo de ejecución usando una versión secuencial.\n",
    "\n",
    "- **Específico**:\n",
    "  - El número total de puntos debe ser 100 millones.\n",
    "  - Divide el total en 6 procesos, cada uno lanzando aproximadamente 16.67 millones de puntos.\n",
    "  - Imprime el valor estimado de π y el tiempo de ejecución.\n",
    "\n",
    "- **Pista**: Usa la función `random()` de la librería `random` para generar puntos aleatorios entre 0 y 1.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejercicio 4: Cálculo Paralelo de la Serie de Taylor para e^x (CPU-bound)**\n",
    "\n",
    "**Descripción**:  \n",
    "El número $ e^x $ se puede aproximar usando la serie de Taylor:\n",
    "\n",
    "$$\n",
    "e^x = \\sum_{n=0}^{\\infty} \\frac{x^n}{n!}\n",
    "$$\n",
    "\n",
    "El objetivo de este ejercicio es dividir el cálculo de los primeros $ N $ términos de la serie para un valor dado de $ x $ usando **Multiprocessing**. Cada proceso calculará una parte de la serie y, al final, los resultados se sumarán para obtener la aproximación final.\n",
    "\n",
    "- **Instrucciones**:\n",
    "  1. Crea una función que reciba un rango de valores de $ n $ (desde $ n_{\\text{inicio}} $ hasta $ n_{\\text{fin}} $) y calcule los términos correspondientes de la serie.\n",
    "  2. Usa `multiprocessing.Pool` para dividir el rango de $ n $ en varias partes y asignar cada parte a un proceso diferente.\n",
    "  3. Recoge los resultados de los procesos y combina las sumas parciales para obtener el valor aproximado de $ e^x $.\n",
    "  4. Imprime el valor aproximado de $ e^x $ para $ x = 5 $ utilizando 10,000 términos.\n",
    "  5. Compara el tiempo de ejecución usando multiprocessing versus una implementación secuencial.\n",
    "\n",
    "- **Específico**:\n",
    "  - El número de términos a calcular es 10,000.\n",
    "  - El valor de $ x $ es 5.\n",
    "  - Divide el cálculo en 8 procesos.\n",
    "  - Muestra el valor final de $ e^x $ y el tiempo de ejecución.\n",
    "\n",
    "- **Pista**: Usa la librería `math` para la función factorial y `Pool.map()` para paralelizar el cálculo de los términos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Ejercicio 5: Multiplicación de Matrices en Paralelo (CPU-bound)**\n",
    "\n",
    "**Descripción**:  \n",
    "La multiplicación de matrices es una operación fundamental en matemáticas y computación científica. En este ejercicio, se utilizará **Multiprocessing** para multiplicar dos matrices grandes de manera paralela. Cada proceso se encargará de calcular una submatriz del resultado.\n",
    "\n",
    "- **Instrucciones**:\n",
    "  1. Crea dos matrices $ A $ y $ B $ de tamaño $ 1000 \\times 1000 $ con valores aleatorios.\n",
    "  2. Implementa una función que reciba un subconjunto de filas de la matriz $ A $ y calcule las filas correspondientes de la matriz resultado $ C $, donde $ C = A \\times B $.\n",
    "  3. Usa `multiprocessing.Pool` para dividir las filas de $ A $ en partes iguales y asignar cada parte a un proceso.\n",
    "  4. Combina los resultados parciales para obtener la matriz completa $ C $.\n",
    "  5. Imprime el tiempo total de ejecución y compara el rendimiento con una versión secuencial.\n",
    "\n",
    "- **Específico**:\n",
    "  - Las matrices $ A $ y $ B $ deben ser de tamaño $ 1000 \\times 1000 $.\n",
    "  - Divide el cálculo en 8 procesos, donde cada proceso calcula 1/8 de las filas de la matriz resultado.\n",
    "  - Muestra el tiempo de ejecución total.\n",
    "\n",
    "- **Pista**: Usa la librería `numpy` para generar las matrices y `Pool.map()` para paralelizar la multiplicación.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}