Concurrente

Programación

Alfredo de Jesús Gutiérrez Gómez, Dr.

1. Piense en el nombre de un animal que inicie con la primera letra de su nombre.

2. Este no deberá repetirse.

3. Al presentarse deberá completar la siguiente frase: Mi nombre es: _______ y he venido sobre un/a: _______ a la escuela desde _____

4. Dar respuesta a las preguntas:

4.1 ¿Porqué estudio está carrera?

4.2 ¿Qué me ha gustado de la carrera hasta ahora?

Presentación

Introducción
Conceptos de programación concurrente.
Arquitecturas paralelas y distribuidas.
Algoritmos paralelos y distribuidos.

Temas del curso

Unidad 1.

Hilos.
Exclusión mutua, región crítica y sincronización.
Monitores.
Semáforos.
mpi.

Temas del curso

Unidad 2.

Programación distribuida.

Temas del curso

Unidad 3.

CUDA.

Temas del curso

Unidad 4.

CORBA.

Temas del curso

Unidad 5.

Teléfono móvil en modo silencio.
Las llamadas urgentes /prio se contestan fuera del salón.
Turnos de una sola persona para ir al WC.
Dos faltas a la semana sin justificante perderían derecho a las cuestiones de aprendizaje.
Levantar la mano para participar.
Respetar la participación de cada alumno.

Políticas de clase

Mantenerse informado acerca de las lecturas, actividades y tareas del curso asistiendo por lo menos dos veces por semana, durante la duración del curso.
Cumplir dentro del aula virtual con todas las tareas, foros y actividades detalladas por el programa académico y el profesor, en el tiempo y forma establecidos.
El incumplimiento de las tareas en tiempo y forma llevarán a una no aprobación del curso.

Lineamientos de clase

Realizar el seguimiento personal desde el Aula Virtual.
Estar pendiente de los resultados de las evaluacion/es parcial/es y final/es.
Notificar al tutor por escrito, con copia a la coordinación académica, si, por alguna razón excepcional, se encontrara en una circunstancia especial que le impidiera continuar con el curso y recibir así indicaciones de cómo proceder a partir de ese momento.

Lineamientos de clase

Unidad 1

Descripción de las actividades

Ejercicios
Cuestiones de aprendizaje

Unidad 2

Descripción de las actividades

Solución de ejercicios
Cuestiones de aprendizaje

Unidad 3

Descripción de las actividades

Solución de ejercicios
Cuestiones de aprendizaje

Unidad 4

Descripción de las actividades

Solución de ejercicios
Cuestiones de aprendizaje

Unidad 5

Descripción de las actividades

Solución de ejercicios
Cuestiones de aprendizaje

Actividad

Actividades de encuadre

En una hoja escribe la respuesta a la siguiente pregunta:

¿Qué esperas que se enseñe en este curso?
¿A qué te comprometes en este curso?
¿Qué deseas aprender en este curso?

Una vez contestadas las preguntas anteriores escribir en el foro respectivo la respuesta a cada pregunta.

Act. de encuadre

Se enumeran las recomendaciones que se deben seguir para la realización de las actividades

Recomendaciones

Trabajos:

Presentación / portada
Introducción
Conclusión

Párrafos:

Mayores a tres líneas
Menores a ocho líneas
Coherencia entre párrafos

Recomendación para las actividades

Ortografía - Gramática

Acentuación.
Evitar redundancia.
Pleonasmos.
Mínimo tres errores.

Referencias bibliográfica

Al menos tres citas dentro del trabajo.
En formato APA 7ma edición.

Recomendación para las actividades

Lista referencia bibliográfica

Al menos tres fuentes de diversos autores.
Con sangría francesa al inicio de cuatro espacios.
Fuente Times New Roman.
12 puntos.
Sin enlaces activos.

Introducción y conclusión

Al menos tres párrafos.

Recomendación para las actividades

Formato del trabajo

Fuente Arial.
Tamaño de título: 14 puntos.
Tamaño de texto: 12 puntos.
Interlineado 1.5
Alineación justificada del texto.
Los títulos alineados a la izquierda.
En el encabezado del documento colocar el logotipo del instituto alineado a la derecha. Nombre de la carrera a la izquierda.

Recomendación para las actividades

Diagramas:

Hacerlos en día.
Exportarlos a jpg / png

Códigos fuentes:

Colocarlos en github.
En el documento a entregar, colocar el enlace al código.

Recomendación para las actividades

Tablas:

Colocarle al pie de la tabla un nombre a la tabla, bajo el siguiente formato: <nombre_tabla numero consecutivo>. <nombre_tabla> <fuente:> <donde_fue_tomada> .
Colocar un párrafo descriptivo

Recomendación para las actividades

Tablas:

Colocarle al pie de la tabla un nombre a la tabla, bajo el siguiente formato: <nombre_tabla numero consecutivo>. <nombre_tabla> <fuente:> <donde_fue_tomada> .
Colocar un párrafo descriptivo

Recomendación para las actividades

Imagenes / diagramas / gráficas:

Colocarle al pie de la imagen / diagrama / gráfica un nombre, bajo el siguiente formato: <nombre_objeto numero consecutivo>. <nombre_objeto> <fuente:> <donde_fue_tomada> .
Colocar un párrafo donde se describa la imagen / diagrama / gráfica

Recomendación para las actividades

¿Dudas ?

Introducción
Conceptos de programación concurrente.
Arquitecturas paralelas y distribuidas.
Algoritmos paralelos y distribuidos.

Unidad 1

# Introducción

Es un paradigma de programación que se centra en la ejecución simultánea de múltiples tareas o procesos dentro de un sistema computacional.
Permite que varias operaciones se lleven a cabo al mismo tiempo, aprovechando la capacidad de los sistemas modernos para realizar tareas simultáneas.
Los procesos o hilos de ejecución trabajan de manera independiente, realizando operaciones de manera simultánea o intercalada.
Esto es útil en situaciones como la interacción de varios usuarios en una aplicación, la gestión eficiente de recursos o la optimización del rendimiento en sistemas multiprocesador

# Introducción

Los hilos son unidades de ejecución ligeras que comparten el mismo espacio de direcciones.
Estos pueden ejecutar tareas simultáneas dentro de un proceso y comparten recursos como memoria.

Aspectos Claves

Hilos de Ejecución (Threads):

# Introducción

La sincronización se vuelve esencial para evitar problemas como condiciones de carrera, donde varios hilos intentan acceder o modificar los mismos datos al mismo tiempo.
Métodos como semáforos, mutex y variables de condición se utilizan para coordinar la ejecución de hilos.

Aspectos Claves

Sincronización y Coordinación:

# Introducción

Los procesos concurrentes a menudo necesitan intercambiar información.
Los mecanismos de comunicación, como colas, tuberías y memoria compartida, permiten que los procesos compartan datos de manera segura.

Aspectos Claves

Comunicación entre Procesos:

# Introducción

Existen desafíos comunes en la programación concurrente, como el problema del productor-consumidor, el problema del lector-escritor y el problema de los filósofos cenando.
Estos desafíos ilustran situaciones típicas que deben abordarse de manera eficiente en entornos concurrentes.

Aspectos Claves

Problemas Clásicos de Concurrencia:

# Introducción

Permite aprovechar la capacidad de los sistemas multiprocesador para ejecutar tareas en paralelo, mejorando el rendimiento general de una aplicación.

Beneficios

Mejora del Rendimiento:

# Introducción

Permite manejar múltiples tareas simultáneamente, lo que puede mejorar la capacidad de respuesta y la experiencia del usuario en aplicaciones interactivas.

Beneficios

Mejora de la Capacidad de Respuesta:

# Introducción

Facilita la gestión eficiente de recursos al permitir que procesos concurrentes compartan y utilicen recursos de manera coordinada.

Beneficios

Eficiencia en el Uso de Recursos:

# Introducción

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: Programación concurrente.

Responde lo siguiente:

Actividad de aprendizaje

¿Cómo beneficia la programación concurrente a un sistema de reservas de aerolíneas en términos de eficiencia y capacidad de respuesta?
¿Cuáles son los desafíos asociados con la programación concurrente en el contexto de un sistema de reservas?
¿En qué situaciones reales se evidencian los beneficios de la programación concurrente en un sistema de reservas de aerolíneas?

Unidad 1

Conceptos de programación concurrente.

# Conceptos

Proceso:

Un proceso es una unidad de ejecución independiente que contiene su propio espacio de memoria y recursos. En un entorno concurrente, múltiples procesos pueden ejecutarse simultáneamente.

Hilo de Ejecución (Thread):

Un hilo es una unidad de ejecución más ligera que comparte el mismo espacio de direcciones que otros hilos dentro del mismo proceso. Los hilos permiten la ejecución concurrente dentro de un proceso.

# Conceptos

Sincronización:

La sincronización se refiere a la coordinación y control del acceso a recursos compartidos entre procesos o hilos para evitar problemas como condiciones de carrera y garantizar la consistencia de los datos.

Mutex (Mutual Exclusion):

Un mutex es un mecanismo de sincronización que se utiliza para garantizar la exclusión mutua, lo que significa que solo un hilo o proceso puede acceder a un recurso compartido a la vez.

# Conceptos

Semáforo:

Un semáforo es un objeto de sincronización que puede tener un valor entero y se utiliza para controlar el acceso concurrente a recursos. Puede actuar como un mecanismo de bloqueo o como un contador de permisos.

Condición de Carrera:

Una condición de carrera ocurre cuando dos o más procesos o hilos intentan realizar operaciones concurrentes en datos compartidos, y el resultado final depende del orden de ejecución.

# Conceptos

Deadlock:

Un deadlock es una situación en la que dos o más procesos o hilos quedan atrapados esperando que el otro libere un recurso, lo que resulta en la parálisis del sistema.

Programación Asíncrona:

La programación asíncrona permite que ciertas tareas se ejecuten de manera independiente, sin bloquear el hilo principal. Es especialmente útil para operaciones de entrada/salida y eventos no bloqueantes.

# Conceptos

Comunicación entre Procesos (IPC):

IPC se refiere a los mecanismos que permiten la comunicación y el intercambio de datos entre procesos. Ejemplos incluyen colas, tuberías y memoria compartida.

Manejo de Señales:

Las señales son eventos asíncronos generados por el sistema operativo o por otros procesos. El manejo de señales permite a un programa responder a eventos como interrupciones y errores.

# Conceptos

Pool de Hilos:

Un pool de hilos es un conjunto de hilos precreados y gestionados para ejecutar tareas concurrentes. Facilita la reutilización de hilos y mejora el rendimiento en aplicaciones que requieren ejecución concurrente.

Productor-Consumidor:

El problema del productor-consumidor es un escenario clásico de concurrencia en el que uno o más procesos producen datos y otros procesos los consumen. La sincronización es crucial para evitar problemas de acceso simultáneo a los datos compartidos.

# Conceptos

Una aplicación de procesamiento de imágenes que utiliza múltiples hilos para cargar, procesar y mostrar imágenes de manera simultánea.

Sistema de gestión de bases de datos donde varios hilos pueden realizar operaciones de lectura y escritura simultáneamente utilizando mutex para evitar condiciones de carrera.

Aplicaciones

# Conceptos

Sistema de almacenamiento y recuperación de datos donde varios productores pueden agregar datos y varios consumidores pueden recuperarlos utilizando semáforos para controlar el acceso.

Servidor web que utiliza el manejo de señales para responder a eventos como solicitudes de interrupción, lo que permite la gestión asincrónica de eventos.

Aplicaciones

# Conceptos

Servidor web que utiliza un pool de hilos para gestionar solicitudes concurrentes de clientes. Cada hilo en el pool maneja una conexión de cliente.

Aplicación distribuida donde varios procesos se comunican a través de colas de mensajes para intercambiar datos y coordinar actividades.

Aplicaciones

# Conceptos

Java

Soporte integrado para hilos con la API de concurrencia (java.util.concurrent).
Uso de synchronized para la sincronización.

Lenguajes

Python

Módulos como threading y multiprocessing para concurrencia.
GIL (Global Interpreter Lock) puede afectar la concurrencia real en hilos.

# Conceptos

C++

Soporte para hilos con la biblioteca estándar (std::thread).
Uso de mutex y semáforos para sincronización.

Lenguajes

Framework .NET con soporte para hilos y tareas.
Uso de palabras clave como async y await para programación asíncrona.

# Conceptos

Go (golan)

Goroutines para concurrencia ligera.
Canales para comunicación entre goroutines.

Lenguajes

Erlang

Diseñado para sistemas concurrentes y distribuidos.
Modelo de actores para la concurrencia.

Rust

Ownership y Borrowing para garantizar la seguridad concurrente.
Hilos y canales para la concurrencia.

# Conceptos

Ejemplo | Python

import threading
import time

def imprimir_mensaje(mensaje, retraso):
    for _ in range(5):
        time.sleep(retraso)
        print(mensaje)

# Crear dos hilos
hilo1 = threading.Thread(target=imprimir_mensaje, args=('Hilo 1: ¡Hola desde el hilo 1!', 1))
hilo2 = threading.Thread(target=imprimir_mensaje, args=('Hilo 2: ¡Hola desde el hilo 2!', 2))

# Iniciar los hilos
hilo1.start()
hilo2.start()

# Esperar a que ambos hilos terminen
hilo1.join()
hilo2.join()

print("Fin del programa")

# Conceptos

Ejemplo | Java

class ImprimirMensaje extends Thread {
    private String mensaje;
    private int retraso;

    public ImprimirMensaje(String mensaje, int retraso) {
        this.mensaje = mensaje;
        this.retraso = retraso;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(retraso);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(mensaje);
        }
    }
}

# Conceptos

Ejemplo | Java

public class ProgramaConcurrente {
    public static void main(String[] args) {
        // Crear dos instancias de la clase ImprimirMensaje
        ImprimirMensaje hilo1 = new ImprimirMensaje("Hilo 1: ¡Hola desde el hilo 1!", 1000);
        ImprimirMensaje hilo2 = new ImprimirMensaje("Hilo 2: ¡Hola desde el hilo 2!", 2000);

        // Iniciar los hilos
        hilo1.start();
        hilo2.start();

        try {
            // Esperar a que ambos hilos terminen
            hilo1.join();
            hilo2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Fin del programa");
    }
}

# Conceptos

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: Imágenes.

Responde lo siguiente:

Actividad de aprendizaje

¿Cómo utiliza el script la clase ThreadPoolExecutor del módulo concurrent.futures para lograr la concurrencia en el procesamiento de imágenes?
¿Cuál es la tarea principal que realiza la función procesar_imagen y cómo se aplica a cada imagen en la lista?
¿Qué sucede en el bloque principal (if __name__ == "__main__":) y cómo se realiza el procesamiento de las imágenes?

Unidad 1

Arquitecturas paralelas y distribuidas.

# Arq. Paralela y distribuida

Arq. Paralela

Utilizadas en la computación de alto rendimiento, supercomputadoras y en aplicaciones que requieren un procesamiento intensivo de datos.

El objetivo es mejorar el rendimiento de un sistema dividiendo las tareas en sub-tareas que se ejecutan simultáneamente.

Con múltiples procesadores / núcleos de procesamiento trabajando en paralelo para realizar operaciones de manera más eficiente.

Se clasificados como sistemas SIMD (Single Instruction, Multiple Data) o sistemas MIMD (Multiple Instruction, Multiple Data).

Es conjunto de procesadores ejecuta la misma instrucción en diferentes conjuntos de datos al mismo tiempo.

Cada procesador puede ejecutar instrucciones independientes en conjuntos de datos distintos.

# Arq. Paralela y distribuida

Arq. Distribuida

La distribución de tareas entre nodos puede mejorar el rendimiento y la disponibilidad del sistema. Sin embargo, la comunicación entre nodos introduce desafíos en términos de latencia y coordinación.

Implica la conexión de múltiples sistemas computacionales/nodos a través de una red para trabajar juntos como un solo sistema coherente.

Cada nodo tiene su propia memoria y procesador, y la comunicación entre nodos se realiza a través de la red.

Este enfoque permite la construcción de sistemas escalables y resilientes.

Sus aplicaciones son en entornos como la nube, donde los recursos estan distribuidos geográficamente, o en sistemas de bases de datos distribuidas para mejorar la escalabilidad y la redundancia.

# Arq. Paralela y distribuida

Diferencias y Combinaciones

La arquitectura paralela y distribuida a menudo se utilizan de manera conjunta en sistemas complejos. Un sistema distribuido puede tener nodos que, a su vez, utilizan arquitecturas paralelas para realizar tareas internas.

Las arquitecturas distribuidas son particularmente relevantes en la era de la computación en la nube, donde los recursos se distribuyen globalmente para satisfacer las demandas de aplicaciones y servicios en línea.

Buscan mejorar el rendimiento y la eficiencia de los sistemas, aunque lo hacen abordando diferentes aspectos de la computación.

# Arq. Paralela y distribuida

Rendimiento Mejorado:

Aspectos claves | Arq. paralela

busca mejorar el rendimiento de un sistema al ejecutar múltiples tareas simultáneamente, dividiendo el trabajo entre varios procesadores o núcleos.

Tipos de Paralelismo:

Puede implementarse en diferentes formas de paralelismo, como paralelismo de datos (SIMD), donde múltiples unidades ejecutan la misma operación en diferentes conjuntos de datos, o paralelismo de tarea (MIMD), donde diferentes tareas se ejecutan simultáneamente.

# Arq. Paralela y distribuida

Procesamiento Intensivo:

Aspectos claves | Arq. paralela

Suelen utilizarse en tareas que requieren un procesamiento intensivo de datos, como simulaciones científicas, renderización gráfica, y análisis de grandes conjuntos de datos.

# Arq. Paralela y distribuida

Conectividad a través de Redes:

Aspectos claves | Distribuida

Implica la conexión de sistemas separados a través de una red de comunicación. Los nodos pueden estar geográficamente dispersos.

Escalabilidad:

Permite la escalabilidad al agregar o quitar nodos según sea necesario. Es fundamental para entornos en los que se anticipan variaciones en la carga de trabajo.

# Arq. Paralela y distribuida

Redundancia y Tolerancia a Fallos:

Aspectos claves | Distribuida

La distribución de tareas y datos entre nodos puede mejorar la tolerancia a fallos y proporcionar redundancia, ya que la pérdida de un nodo no debería afectar significativamente al sistema.

Aplicaciones en la Nube:

Muy utilizada en entornos de computación en la nube, donde los recursos se distribuyen globalmente para atender las demandas de los usuarios.

# Arq. Paralela y distribuida

Coordinación y Comunicación:

Aspectos comunes

Tanto en arquitecturas paralelas como distribuidas, la coordinación y comunicación entre los componentes son críticos. En paralelo, se busca una ejecución sincronizada, mientras que en distribuido se abordan desafíos de latencia y coordinación entre nodos.

Escalabilidad:

Ambas arquitecturas buscan escalabilidad, aunque en contextos diferentes. La paralela escala al aumentar el número de procesadores, y la distribuida escala al agregar más nodos.

# Arq. Paralela y distribuida

Combinación:

Concideraciones

En muchos casos, sistemas modernos utilizan una combinación de arquitecturas paralelas y distribuidas para aprovechar las ventajas de ambas enfoques.

Desafíos de Comunicación

En sistemas distribuidos, la comunicación entre nodos puede ser un desafío debido a la latencia de red y la sincronización. En sistemas paralelos, la gestión de la memoria compartida y la sincronización entre núcleos también es crítica.

Mientras que la arquitectura paralela se centra en mejorar el rendimiento mediante la ejecución simultánea de tareas, la arquitectura distribuida se enfoca en la conectividad y la colaboración entre sistemas separados para lograr escalabilidad y redundancia.

# Arq. Paralela y distribuida

Ejemplo

from pyspark.sql import SparkSession

# Crear una sesión de Spark
spark = SparkSession.builder.appName("EjemploParaleloDistribuido").getOrCreate()

# Cargar datos de un archivo (puedes utilizar tu propio conjunto de datos)
data = spark.read.text("ruta/a/tu/archivo.txt")

# Dividir las líneas del archivo y realizar algún procesamiento (paralelismo a nivel de tarea)
palabras = data.selectExpr("explode(split(value, ' ')) as palabra")

# Contar la frecuencia de cada palabra (distribuido entre nodos)
conteo_palabras = palabras.groupBy("palabra").count()

# Mostrar los resultados
conteo_palabras.show()

# Detener la sesión de Spark
spark.stop()

# Arq. Paralela y distribuida

Actividad de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: Paralelo y distribuida.

Responde lo siguiente:

¿Cómo se maneja la variabilidad en la carga de eventos en una plataforma de redes sociales?
¿Cómo se logra proporcionar recomendaciones personalizadas en tiempo real a millones de usuarios activos?
¿Cómo garantiza la plataforma una experiencia del usuario fluida incluso en momentos de alta actividad?

Unidad 1

Algoritmos paralelos y distribuidos.

#Algoritmos paralelos y distribuidos

Algoritmos paralelos

Son diseñados para ejecutarse de manera eficiente en sistemas paralelos, donde múltiples procesadores trabajan simultáneamente en partes diferentes del problema

#Algoritmos paralelos y distribuidos

Algoritmos paralelos

Pueden dividir el problema en subproblemas más pequeños que pueden resolverse de manera independiente en diferentes procesadores.

Divide y Conquista Paralela

Dividen grandes conjuntos de datos en tareas más pequeñas, aplican una función de mapeo y luego combinan los resultados utilizando una función de reducción.

Algoritmos MapReduce

Los algoritmos que se adaptan al modelo de flujo de datos son eficientes para problemas donde los datos están disponibles continuamente. Cada tarea se ejecuta a medida que llegan los datos, permitiendo un procesamiento continuo.

Modelo de Flujo de Datos

#Algoritmos paralelos y distribuidos

Algoritmos distribuidos

Los algoritmos distribuidos están diseñados para ejecutarse en entornos distribuidos, donde múltiples nodos de procesamiento están interconectados.

#Algoritmos paralelos y distribuidos

Algoritmos distribuidos

Algoritmos de coordinación, como el algoritmo de Paxos, se utilizan para garantizar la consistencia en sistemas distribuidos.

Consistencia y Coordinación

Consenso de Byzantine Fault Tolerance (BFT), permiten que un grupo de nodos llegue a un acuerdo incluso si algunos de ellos son maliciosos o fallan.

Algoritmos de Consenso

los algoritmos de enrutamiento, como el algoritmo de enrutamiento de estado de enlace, son esenciales para determinar la ruta óptima entre nodos.

Algoritmos de Enrutamiento

#Algoritmos paralelos y distribuidos

Desafíos comunes

La comunicación entre nodos en sistemas distribuidos a menudo enfrenta latencia. Los algoritmos deben diseñarse para minimizar el tiempo de comunicación.

Comunicación y Latencia

Los algoritmos distribuidos deben ser resistentes a fallas, ya que los nodos pueden experimentar errores o salir de la red en cualquier momento.

Manejo de Fallas

La escalabilidad es un desafío importante en algoritmos distribuidos. A medida que se agregan más nodos al sistema, los algoritmos deben ser capaces de manejar la carga adicional de manera eficiente.

Escalabilidad

#Algoritmos paralelos y distribuidos

Algoritmos paralelos

Este algoritmo divide las matrices en bloques y asigna cada bloque a un procesador. La multiplicación de matrices se realiza de manera independiente en cada bloque, y los resultados parciales se suman al final.

Multiplicación de Matrices

Algoritmos como Merge Sort o Quick Sort pueden paralelizarse dividiendo la lista en subconjuntos y ordenándolos de manera independiente. Luego, los subconjuntos ordenados se combinan para obtener la lista ordenada completa.

Ordenamiento Paralelo

#Algoritmos paralelos y distribuidos

Algoritmos paralelos

En lugar de realizar una búsqueda binaria en un único conjunto de datos, este algoritmo divide el conjunto en secciones y ejecuta búsquedas binarias independientes en paralelo en cada sección.

Búsqueda Binaria Paralela

Este algoritmo agrupa datos en k grupos. En una implementación paralela, cada grupo puede calcular sus centroides de manera independiente, lo que acelera el proceso de convergencia.

Algoritmo K-Means

#Algoritmos paralelos y distribuidos

Algoritmos paralelos

Genera puntos aleatorios en un cuadrado y determina cuántos caen dentro de un círculo inscrito. La relación de puntos dentro del círculo con respecto al total estimará el valor de Pi.

Cálculo de Pi mediante Método Monte Carlo

Durante el entrenamiento de redes neuronales, los cálculos de propagación hacia adelante y hacia atrás se pueden realizar en paralelo para mejorar la velocidad de entrenamiento, especialmente en arquitecturas distribuidas.

Redes Neuronales

#Algoritmos paralelos y distribuidos

Algoritmos paralelos

En simulaciones Monte Carlo, se realizan experimentos mediante muestreo aleatorio. Estos experimentos pueden ejecutarse en paralelo para obtener resultados más rápidos, especialmente en problemas complejos.

Simulaciones Monte Carlo

Algoritmos como AES dividen los datos en bloques y cifran o descifran cada bloque de manera independiente. Esto permite que múltiples bloques se procesen simultáneamente.

Cifrado y Descifrado paralelo

#Algoritmos paralelos y distribuidos

El Método Monte Carlo es una técnica estadística que utiliza números aleatorios para realizar simulaciones y estimar resultados. En el contexto de cálculo de Pi, se puede utilizar el Método Monte Carlo para aproximar el área de un círculo inscrito en un cuadrado.

Simulaciones Monte Carlo

#Algoritmos paralelos y distribuidos

Simulaciones Monte Carlo

Imagina un cuadrado y un círculo inscrito dentro de él. Genera puntos aleatorios dentro del cuadrado.

Proceso

La probabilidad de que un punto al azar caiga dentro del círculo es proporcional al área del círculo en comparación con el área total del cuadrado. La relación es π/4, ya que el área del círculo es πr² y el área del cuadrado es (2r)² = 4r². Por lo tanto, si P es la cantidad de puntos dentro del círculo y T es el total de puntos generados, se tiene que π ≈ 4 * P / T.

Estimación de Pi

#Algoritmos paralelos y distribuidos

Simulaciones Monte Carlo

La implementación paralela del Método Monte Carlo implica dividir la generación de puntos entre múltiples procesadores o nodos. Cada procesador genera una cantidad determinada de puntos y cuenta cuántos caen dentro del círculo. Al final, los resultados parciales se suman para obtener una estimación global de π

Implementación Paralela

#Algoritmos paralelos y distribuidos

Simulaciones Monte Carlo

import random
import multiprocessing

def monte_carlo_simulation(points):
    inside_circle = 0

    for _ in range(points):
        x = random.uniform(-1, 1)
        y = random.uniform(-1, 1)
        
        distance = x**2 + y**2
        if distance <= 1:
            inside_circle += 1

    return inside_circle

def parallel_monte_carlo(num_points, num_processes):
    pool = multiprocessing.Pool(processes=num_processes)
    points_per_process = num_points // num_processes

    results = pool.map(monte_carlo_simulation, [points_per_process] * num_processes)

    total_inside_circle = sum(results)
    pi_estimate = 4 * total_inside_circle / num_points

    return pi_estimate

# Ejemplo de uso
num_points = 1000000
num_processes = 4
pi_estimate_parallel = parallel_monte_carlo(num_points, num_processes)
print("Estimación de Pi (paralelo):", pi_estimate_parallel)

#Algoritmos paralelos y distribuidos

Simulaciones Monte Carlo

Este es un ejemplo básico de cómo se podría implementar el Método Monte Carlo de manera paralela en Python utilizando la biblioteca multiprocessing. Cada proceso genera una cantidad de puntos y calcula cuántos están dentro del círculo, y luego los resultados se suman para obtener una estimación de π. La implementación real puede variar según el lenguaje de programación y la arquitectura del sistema.

#Algoritmos paralelos y distribuidos

Algoritmos distribuidos

Este algoritmo se utiliza para elegir un líder en un sistema distribuido. Los nodos compiten para ser líder y aquel con el identificador más alto gana.

Algoritmo de Elección de Líder - Algoritmo de Bully

Un algoritmo de consenso que garantiza la consistencia en sistemas distribuidos. Se utiliza para lograr acuerdos entre nodos incluso en presencia de fallos y asincronía.

Paxos

#Algoritmos paralelos y distribuidos

Algoritmos distribuidos

Introducido por Google, MapReduce es un modelo de programación y un sistema de procesamiento distribuido diseñado para procesar grandes conjuntos de datos en paralelo.

MapReduce

Este algoritmo se utiliza en redes distribuidas para determinar las rutas más cortas entre nodos. Cada nodo mantiene una tabla de distancia y la actualiza basándose en la información de sus vecinos.

Enrutamiento Distribuido de Distancia Vectorial

#Algoritmos paralelos y distribuidos

Algoritmos distribuidos

Algoritmos como Chord o Kademlia se utilizan para organizar datos de manera distribuida en un sistema peer-to-peer. Permiten buscar y recuperar datos de manera eficiente.

Búsqueda Distribuida de Hash (Distributed Hash Table - DHT)

Se utiliza para lograr la exclusión mutua en sistemas distribuidos. Cada nodo tiene un número y espera hasta que su número es el más bajo para acceder a la sección crítica.

Algoritmo de Exclusión Mutua - Algoritmo de Bakery

#Algoritmos paralelos y distribuidos

Algoritmos distribuidos

Un algoritmo de coordinación donde un token (marca de posición) circula entre los nodos en un anillo. Solo el nodo que posee el token tiene el derecho de realizar ciertas operaciones.

Token Ring

Utilizado para ordenar eventos en sistemas distribuidos. Cada nodo asigna un timestamp a sus eventos, permitiendo la sincronización parcial de eventos entre nodos.

Algoritmo de Lamport para Reloj Lógico

#Algoritmos paralelos y distribuidos

Algoritmos distribuidos

Algoritmos como el "Token Ring Stabilization" abordan la estabilización de sistemas distribuidos después de que ocurre un cambio, como la falla o recuperación de un nodo.

Algoritmo de Estabilización

Se utiliza para mantener la consistencia entre réplicas de datos distribuidas. Los nodos intercambian información periódicamente para corregir discrepancias.

Algoritmo de Anti-Entropy para Replicación de Datos

#Algoritmos paralelos y distribuidos

Paxos

Paxos es un algoritmo de consenso diseñado para sistemas distribuidos en los que los nodos pueden fallar y recuperarse. Fue propuesto por Leslie Lamport en 1989 y es ampliamente utilizado en sistemas distribuidos modernos. El objetivo de Paxos es lograr que un conjunto de nodos acuerde un valor único, incluso en presencia de fallos y retrasos en la comunicación.

#Algoritmos paralelos y distribuidos

Paxos

Son nodos responsables de proponer un valor en el sistema.

Proposers (Proponentes)

Son nodos que aceptan o rechazan propuestas de valores. Mantienen un registro de las propuestas aceptadas

Acceptors (Aceptadores)

Son nodos que aprenden el valor acordado una vez que ha sido aceptado por la mayoría de los aceptadores.

Learners (Aprendices)

#Algoritmos paralelos y distribuidos

Fases de Paxos

Un proposer elige un No. de propuesta único y lo envía a la mayoría de los aceptadores.
Si un aceptador recibe 1 propuesta con 1 No. >, no aceptará propuestas con No. <.

Fase de Preparación (Prepare Phase)

Si un aceptador no ha aceptado ninguna propuesta previa, aceptará la propuesta actual del proposer.
Si un aceptador ha aceptado una propuesta previa, solo aceptará la nueva propuesta si su número de propuesta es mayor.

Fase de Aceptación (Accept Phase)

1 valor ha sido aceptado por la mayoría de los aceptadores, se considera decidido.
Los aprendices pueden aprender el valor decidido y comunicarlo al resto del sistema.

Fase de Decisión (Decision Phase):

#Algoritmos paralelos y distribuidos

Implementando Paxos

Se tiene tres nodos: A, B y C. Aquí hay una ejecución simplificada de Paxos:

Suponga que:

A envía un mensaje de preparación con el No. de propuesta 1 a los aceptadores (B y C).

Proposer 1 (A) propone el valor "X"

B y C responden aceptando la propuesta de A.

Acceptores responden:

A envía un mensaje de aceptación con el valor "X" y el No. de propuesta 1 a los aceptadores.

Proposer 1 (A) propone el valor "X"

B y C responden aceptando la propuesta de A.

Acceptores responden

B y C responden aceptando la propuesta de A.

Acceptores responden:

Aprendices observan que aceptadores aceptan la propuesta de A con valor "X" y aprenden: "X" es el valor.

Aprendices aprenden valor "X"

#Algoritmos paralelos y distribuidos

Implementando Paxos

Implementar Paxos de manera completa puede ser un poco extenso y complejo, especialmente en un entorno real. Sin embargo, puedo proporcionarte un ejemplo simplificado en Python que ilustra la lógica básica del algoritmo. Ten en cuenta que esta implementación es muy básica y no maneja todos los casos de borde ni situaciones de concurrencia.

#Algoritmos paralelos y distribuidos

import threading
import time
import random

class PaxosNode:
    def __init__(self, node_id):
        self.node_id = node_id
        self.proposal_number = 0
        self.accepted_proposal_number = None
        self.accepted_value = None

    def prepare(self, proposal_number):
        if proposal_number > self.proposal_number:
            self.proposal_number = proposal_number
            return True
        return False

    def accept(self, proposal_number, value):
        if proposal_number >= self.proposal_number:
            self.proposal_number = proposal_number
            self.accepted_proposal_number = proposal_number
            self.accepted_value = value
            return True
        return False

#Algoritmos paralelos y distribuidos

def run_paxos(node, other_nodes):
    # Phase 1: Prepare
    proposal_number = random.randint(1, 100)
    prepare_message = (proposal_number, node.node_id)

    for other_node in other_nodes:
        if other_node.prepare(proposal_number):
            print(f"Node {node.node_id} sends prepare message to Node {other_node.node_id}")

    # Simulate network delay
    time.sleep(1)

    # Phase 2: Accept
    accepted_value = f"Value from Node {node.node_id}"
    accept_message = (proposal_number, accepted_value)

    for other_node in other_nodes:
        if other_node.accept(proposal_number, accepted_value):
            print(f"Node {node.node_id} sends accept message to Node {other_node.node_id}")

    print(f"Node {node.node_id} decides on value: {node.accepted_value}")

#Algoritmos paralelos y distribuidos

if __name__ == "__main__":
    # Crear nodos
    node1 = PaxosNode(1)
    node2 = PaxosNode(2)
    node3 = PaxosNode(3)

    # Iniciar proceso de Paxos en cada nodo en un hilo separado
    thread1 = threading.Thread(target=run_paxos, args=(node1, [node2, node3]))
    thread2 = threading.Thread(target=run_paxos, args=(node2, [node1, node3]))
    thread3 = threading.Thread(target=run_paxos, args=(node3, [node1, node2]))

    thread1.start()
    thread2.start()
    thread3.start()

    thread1.join()
    thread2.join()
    thread3.join()

#Algoritmos paralelos y distribuidos

El código anterior simula un sistema con tres nodos Paxos.
Cada nodo ejecuta el algoritmo Paxos en un hilo separado y se comunica con los otros nodos a través de mensajes de preparación y aceptación.
Ten en cuenta que esta implementación es bastante básica y no maneja casos más complejos de Paxos.
En entornos reales, se utilizarían estructuras de red, manejo de fallos, y una lógica más robusta para garantizar la corrección y la consistencia.

#Algoritmos paralelos y distribuidos

Actividad de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: Rendereizado.

Responde lo siguiente:

¿Cómo afectaría al rendimiento del sistema la introducción de un nuevo nodo de renderizado durante el proceso de renderizado de una escena?
¿Cómo se puede evaluar la escalabilidad del sistema en términos de rendimiento al agregar nuevos nodos de renderizado? ¿Existen límites prácticos para la escalabilidad, y cómo podrían abordarse?
¿Qué estrategias específicas podrían implementarse para garantizar la tolerancia a fallos en el sistema? ¿Cómo afectaría la recuperación de un nodo fallido al rendimiento general del proceso de renderizado?

2. Hilos.
2.2. Exclusión mutua, región crítica y sincronización.
2.3. Monitores.
2.4. Semáforos.
2.5. mpi.

Unidad 2

#Hilos

Un hilo (también conocido como subproceso o thread en inglés) es una secuencia más pequeña de instrucciones que puede ejecutarse simultáneamente con otras secuencias de instrucciones. Los hilos son unidades de ejecución más ligeras que los procesos y comparten recursos, como memoria y archivos, con otros hilos que pertenecen al mismo proceso.

#Hilos

Multitarea y Concurrente

Aspectos claves

La programación concurrente permite que varias tareas se ejecuten de manera aparentemente simultánea. Los hilos son una forma común de lograr la concurrencia.

Hilos vs. Procesos

A diferencia de los procesos, los hilos comparten el mismo espacio de direcciones de memoria y recursos con otros hilos dentro del mismo proceso. Los procesos, en cambio, tienen su propio espacio de direcciones y recursos independientes.

#Hilos

Hilos en Espacios de Usuario y Núcleo

Aspectos claves

Los hilos en espacio de usuario son gestionados por la aplicación sin intervención del sistema operativo. Por otro lado, los hilos en espacio de núcleo son gestionados por el sistema operativo y pueden aprovechar mejor la concurrencia en sistemas multiprocesador.

Ventajas de los Hilos

Respuesta Rápida: Los hilos permiten que una aplicación responda a eventos y realice tareas en segundo plano sin afectar la interfaz de usuario.
Uso Eficiente de Recursos: Comparten recursos, lo que puede reducir la sobrecarga en comparación con la creación de múltiples procesos.

#Hilos

Desafíos de los Hilos

Aspectos claves

Condición de Carrera: Problemas que pueden surgir cuando varios hilos acceden y modifican simultáneamente los mismos datos compartidos.
Exclusión Mutua: Necesidad de garantizar que solo un hilo acceda a ciertos recursos compartidos a la vez para evitar conflictos.

Creación y Gestión de Hilos

En muchos lenguajes de programación, como Java o Python, se proporcionan bibliotecas que facilitan la creación y gestión de hilos. Esto incluye funciones para la creación de hilos, sincronización y comunicación entre hilos.

#Hilos

Modelos de Programación Concurrente

Aspectos claves

Hilos Independientes: Cada hilo realiza una tarea independiente.
Hilos Cooperativos: Los hilos cooperan entre sí y se comunican para lograr una tarea común.
Productor-Consumidor: Unos hilos producen datos y otros los consumen.

Problemas Comunes

Deadlocks: Situación en la que varios hilos se bloquean mutuamente.
Starvation: Un hilo puede no obtener acceso a los recursos necesarios debido a la priorización de otros hilos.

#Hilos

Modelos de Programación Concurrente

Aspectos claves

Hilos Independientes: Cada hilo realiza una tarea independiente.
Hilos Cooperativos: Los hilos cooperan entre sí y se comunican para lograr una tarea común.
Productor-Consumidor: Unos hilos producen datos y otros los consumen.

Problemas Comunes

Deadlocks: Situación en la que varios hilos se bloquean mutuamente.
Starvation: Un hilo puede no obtener acceso a los recursos necesarios debido a la priorización de otros hilos.

#Hilos

import threading
import time

def tarea_1():
    for _ in range(5):
        print("Tarea 1 ejecutándose")
        time.sleep(1)

def tarea_2():
    for _ in range(5):
        print("Tarea 2 ejecutándose")
        time.sleep(1)

# Crear instancias de los hilos
hilo_1 = threading.Thread(target=tarea_1)
hilo_2 = threading.Thread(target=tarea_2)
# Iniciar los hilos
hilo_1.start()
hilo_2.start()
# Esperar a que ambos hilos terminen antes de continuar
hilo_1.join()
hilo_2.join()

print("Ambos hilos han terminado.")

#Hilos

Actividad de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: Hilos.

Responde lo siguiente:

¿Cómo garantiza el uso del cerrojo (mutex) en el código del "Contador Concurrente" que dos hilos pueden modificar la variable contador de manera segura y evitar condiciones de carrera?
En el código "Imprimir en Orden", ¿por qué se utiliza join() después de iniciar cada hilo? ¿Cuál sería el resultado si no se usara join() y se ejecutaran los hilos sin esperar a que terminen?
¿Cómo evita el uso de una cola (cola) en el código "Problema de Productor-Consumidor" problemas de concurrencia y asegura que los elementos se consuman en el orden correcto? ¿Qué sucede si la cola no tiene límite de tamaño (maxsize=5)?

Unidad 2

Exclusión mutua, región crítica y sincronización.

#Exclusión mutua, región crítica y sincronización

Exclusión Mutua

Definición

La exclusión mutua es un concepto que se refiere a la necesidad de asegurar que, en un momento dado, solo un hilo tenga acceso a un recurso compartido o a una sección crítica.

Importancia

Sin exclusión mutua, varios hilos podrían intentar modificar el mismo recurso simultáneamente, llevando a resultados impredecibles y errores de programación como condiciones de carrera.

Mecanismos de Implementación

La exclusión mutua puede lograrse mediante el uso de cerrojos, semáforos, variables de condición u otras estructuras de sincronización. Estos mecanismos garantizan que solo un hilo pueda ejecutar una sección crítica a la vez.

#Exclusión mutua, región crítica y sincronización

Región Crítica

Definición

Es una sección de código en un programa concurrente que accede y modifica variables compartidas. Solo un hilo a la vez debería ejecutar código dentro de la región crítica para evitar problemas de concurrencia.

Importancia

El objetivo de definir regiones críticas es garantizar que las operaciones críticas se realicen de manera atómica, evitando interferencias de otros hilos que podrían acceder a las mismas variables compartidas.

Mecanismos de Implementación

Se implementa la exclusión mutua alrededor de la región crítica utilizando mecanismos de sincronización. Esto asegura que un solo hilo pueda ejecutar la región crítica en un momento dado.

#Exclusión mutua, región crítica y sincronización

Sincronización

Definición

Se refiere a la coordinación adecuada entre los hilos para garantizar que ciertos eventos ocurran en un orden específico o que ciertos recursos se utilicen de manera segura y eficiente.

Importancia

En un entorno concurrente, la sincronización es crucial para evitar condiciones de carrera, bloqueos y otros problemas que pueden surgir cuando múltiples hilos interactúan con recursos compartidos.

Mecanismos de Implementación

Aparte de la exclusión mutua, se utilizan otros mecanismos de sincronización como semáforos, variables de condición, barreras, entre otros, para lograr una ejecución ordenada y predecible de los hilos.

#Exclusión mutua, región crítica y sincronización

Aspectos Claves | Exclusión mutua

Necesidad

La exclusión mutua es necesaria cuando múltiples hilos comparten recursos y existe la posibilidad de interferencia o conflictos si varios hilos intentan acceder o modificar los mismos datos simultáneamente.

Objetivo

Asegurar que, en cualquier momento, solo un hilo tenga acceso a una sección crítica o recurso compartido. Esto evita condiciones de carrera y garantiza la coherencia de los datos.

Utiliza mecanismos como cerrojos, semáforos o variables de condición para implementar la exclusión mutua y controlar el acceso a las secciones críticas.

Mecanismos

#Exclusión mutua, región crítica y sincronización

Aspectos Claves | Región Crítica

Definición

La región crítica es una sección de código donde se accede y modifica variables compartidas. Solo un hilo debe ejecutar esta sección a la vez para evitar inconsistencias y errores.

Atómico

Las operaciones dentro de la región crítica deben ejecutarse de manera atómica. Es decir, deben ser indivisibles para evitar resultados incorrectos debido a interferencias de otros hilos.

La región crítica implementa la exclusión mutua, asegurando que solo un hilo pueda ejecutar la sección crítica a la vez.

Exclusión Mutua

#Exclusión mutua, región crítica y sincronización

Aspectos Claves | Sincronización

Coordinación

La sincronización implica la coordinación entre hilos para lograr una ejecución ordenada y predecible. Se utiliza para asegurar que ciertos eventos ocurran en un orden específico.

Evitar Condiciones de Carrera

Un objetivo clave de la sincronización es evitar condiciones de carrera y otros problemas de concurrencia mediante la aplicación de mecanismos que controlen el acceso a recursos compartidos.

Utiliza mecanismos como semáforos, variables de condición, barreras, para lograr la sincronización entre hilos y garantizar un comportamiento predecible del programa.

Mecanismos de Sincronización

#Exclusión mutua, región crítica y sincronización

Aspectos Claves | Sincronización

Prevención de Deadlocks

Además de coordinar eventos, la sincronización también se utiliza para prevenir situaciones de deadlock, donde los hilos quedan atrapados esperando recursos que nunca se liberan.

#Exclusión mutua, región crítica y sincronización

Actividad de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: Exclusión.

Responde lo siguiente:

¿por qué es crucial el uso del cerrojo (mutex) alrededor de la operación de incremento (contador += 1)?
¿cómo asegura el uso del cerrojo (mutex) que la operación de agregar elementos a la lista (lista_compartida.append(elemento)) se realice de manera segura y consistente?
¿Qué sucedería si no se implementara la sincronización y ambos hilos imprimieran sin coordinación?

Monitores

Unidad 2

#Monitores

Un monitor es una estructura que encapsula un conjunto de procedimientos o métodos, así como variables de datos, permitiendo el acceso controlado y seguro a recursos compartidos.

Introducido por Per Brinch Hansen en 1972 como un mecanismo para coordinar la ejecución de hilos y proporcionar exclusión mutua.

Ofrecen una abstracción de alto nivel para la sincronización y exclusión mutua, facilitando el desarrollo de programas concurrentes más seguros y comprensibles.

#Monitores

Aspectos claves

Exclusión Mutua Automática

Los monitores garantizan la exclusión mutua automáticamente. Solo un hilo puede ejecutar una sección de código en el monitor en un momento dado. Esto simplifica la implementación y reduce la posibilidad de errores relacionados con la exclusión mutua.

Condición de Espera

Los monitores permiten la definición de variables de condición, que son esenciales para la sincronización entre hilos. Estas variables permiten a los hilos esperar (mediante wait) y ser notificados (mediante notify o notifyAll) sobre cambios en las condiciones compartidas.

#Monitores

Aspectos claves

Encapsulación

Los monitores encapsulan tanto los datos compartidos como los procedimientos que operan sobre esos datos. Esto favorece el principio de encapsulación y ocultación de información, mejorando la modularidad del código concurrente.

Simplicidad de Uso

Al ofrecer un nivel de abstracción más alto, los monitores simplifican el desarrollo de programas concurrentes al reducir la necesidad de gestionar directamente cerrojos y variables de condición, y al proporcionar un marco más intuitivo para la coordinación entre hilos.

#Monitores

Aspectos claves

Implementación en Lenguajes Específicos

Algunos lenguajes de programación, como Java, proporcionan soporte nativo para monitores. En Java, por ejemplo, los bloques sincronizados (synchronized) y los métodos sincronizados utilizan la idea de monitores para lograr exclusión mutua y sincronización.

Prevención de Inanición y Deadlock

Los monitores también pueden ayudar a prevenir problemas como la inanición y el deadlock al proporcionar mecanismos integrados para la planificación y la liberación de recursos.

#Monitores

Aspectos claves

Facilita la Comprensión del Código

Dado que los monitores encapsulan datos y operaciones relacionadas, el código que utiliza monitores suele ser más fácil de entender y mantener, ya que refleja de manera más clara las interacciones concurrentes.

#Monitores

Actividad de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: Monitor.

Responde lo siguiente:

¿Qué podría suceder si no se utilizara el cerrojo en estas operaciones?
¿Cuál es el papel del monitor en asegurar que estas acciones se realicen de manera coordinada y segura?
Al obtener el valor final del contador mediante el método obtener_valor del monitor, ¿cómo garantiza este acceso seguro a datos compartidos?

Unidad 2

Semáforo

#Semáforo

Son una herramienta crucial en programación concurrente para coordinar el acceso a recursos compartidos y sincronizar la ejecución de múltiples hilos o procesos.

Fueron introducidos por Edsger Dijkstra en 1965 como un mecanismo para controlar el acceso a secciones críticas y evitar problemas de concurrencia

#Semáforo

Aspectos claves

Un semáforo es una variable o estructura de datos que actúa como un indicador de estado.

Puede tener un valor entero no negativo y se utiliza para coordinar la ejecución de múltiples hilos o procesos.

Definicion

#Semáforo

Aspectos claves

wait: Reduce el valor del semáforo. Si el valor es cero, el hilo se bloquea hasta que otro hilo incremente el valor.

signal: Aumenta el valor del semáforo. Si hay hilos bloqueados en wait, uno de ellos se desbloquea.

Operaciones Básicas

Dos operaciones fundamentales sobre semáforos son wait (también conocida como P o down) y signal (también conocida como V o up).

#Semáforo

Aspectos claves

Los semáforos se utilizan para lograr exclusión mutua, permitiendo que solo un hilo acceda a una sección crítica en un momento dado. Esto se logra decrementando el semáforo antes de entrar en la sección crítica y aumentándolo después de salir.

Uso para Exclusión Mutua

#Semáforo

Aspectos claves

Se utilizan para sincronizar la ejecución de hilos. Un semáforo puede actuar como una barrera, permitiendo que múltiples hilos esperen hasta que se cumpla cierta condición antes de continuar.

Sincronización entre Hilos

Los semáforos pueden ser binarios (valores 0 o 1) o contadores (valores no negativos mayores que 1). Los semáforos binarios son útiles para la sincronización básica, mientras que los contadores permiten gestionar recursos compartidos limitados.

Semáforos Binarios y Contadores

#Semáforo

Aspectos claves

Los semáforos son eficaces para prevenir condiciones de carrera al proporcionar mecanismos para controlar el acceso a recursos compartidos y sincronizar la ejecución de hilos.

Prevención de Condiciones de Carrera

Aunque poderosos, los semáforos pueden contribuir a la aparición de deadlocks si no se utilizan correctamente. La planificación y la liberación adecuada de los recursos son esenciales para evitar este problema.

Prevención de Deadlocks

#Semáforo

Aspectos claves

Muchos lenguajes de programación y sistemas operativos ofrecen soporte nativo para semáforos. Por ejemplo, en Python, se pueden utilizar semáforos de la biblioteca estándar threading.

Implementación en Lenguajes

#Semáforo

Actividades de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: Semáforo.

Responde lo siguiente:

¿Qué sucedería si se eliminara la operación acquire (wait) antes de la sección crítica o la operación release (signal) después de la sección crítica?
Explique cómo estas operaciones son cruciales para garantizar un acceso seguro y coordinado a la variable compartida (contador).
¿Cómo garantiza el uso del semáforo (sem) en la función incrementar que solo un hilo puede ejecutar la sección crítica (incremento de contador) a la vez?

Unidad 2

mpi

#mpi

MPI (Message Passing Interface) es un estándar para la programación de sistemas distribuidos y paralelos.

Se utiliza comúnmente en el contexto de la programación concurrente para permitir la comunicación entre procesos en un clúster de computadoras.

#mpi

Modelo de programación de paso de mensajes, donde los procesos se comunican entre sí enviando y recibiendo mensajes. Cada proceso tiene su propio espacio de memoria y se ejecuta de manera independiente.

Aspectos claves

Modelo de Programación

MPI proporciona funciones para la comunicación punto a punto, lo que significa que un proceso puede enviar un mensaje directamente a otro proceso. Las funciones típicas son MPI_Send y MPI_Recv.

Comunicación Punto a Punto

#mpi

Además de la comunicación punto a punto, MPI también ofrece operaciones de comunicación colectiva que permiten la interacción entre un grupo de procesos. Algunas de estas operaciones incluyen la difusión, la recolección y la reducción.

Aspectos claves

Comunicación Colectiva

MPI permite la creación y gestión de grupos de procesos, lo que facilita la comunicación entre subconjuntos específicos de procesos en un clúster.

Creación y Gestión de Grupos

#mpi

MPI admite la especificación de topologías, lo que permite a los programadores organizar los procesos en una estructura lógica, como una malla o un anillo, facilitando las comunicaciones específicas en la topología definida.

Aspectos claves

Topologías

MPI permite el manejo de datos distribuidos, lo que es esencial en entornos paralelos donde los datos pueden estar distribuidos entre los nodos del clúster. Esto facilita la manipulación de grandes conjuntos de datos en paralelo.

Manejo de Datos Distribuidos

#mpi

Hay diversas implementaciones de MPI disponibles, siendo MPI-2 y MPI-3 versiones más recientes que han introducido mejoras y nuevas características. Algunas implementaciones populares incluyen Open MPI, MPICH y Intel MPI.

Aspectos claves

Implementaciones de MPI

MPI es ampliamente utilizado en aplicaciones de alto rendimiento, como simulaciones numéricas, modelos climáticos, análisis de datos grandes y otros cálculos intensivos, donde la capacidad de distribuir la carga de trabajo entre múltiples nodos es esencial.

Aplicaciones de Alto Rendimiento

#mpi

MPI se puede utilizar con varios lenguajes de programación, incluyendo C, C++, Fortran y Python, entre otros. Existen bibliotecas y bindings para facilitar su uso en diferentes entornos.

Aspectos claves

Lenguajes de Programación

MPI es una herramienta poderosa para la programación paralela y distribuida, permitiendo a los desarrolladores aprovechar al máximo los recursos de un clúster de computadoras par

Programación Paralela y Distribuida:

#mpi

Actividad de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: mpi.

Responde lo siguiente:

Explique cómo funciona la operación de suma colectiva (MPI_Allreduce) en el código. ¿Qué valores se están sumando y cómo se obtiene la suma global?
¿Cómo cambiaría el resultado del programa si se ejecutara con un número diferente de procesos?
¿Cómo afectaría el resultado si el código se ejecutara con solo un proceso?

Programación distribuida

Unidad 3

#Programación distribuida

Es un enfoque de desarrollo de software que se centra en la creación de aplicaciones que se ejecutan en múltiples nodos de un sistema distribuido, donde cada nodo puede ser una computadora independiente o un componente de hardware en una red.

En lugar de ejecutar un programa en una única máquina, la programación distribuida permite que las tareas se distribuyan entre varios nodos, a menudo para mejorar el rendimiento, la escalabilidad y la tolerancia a fallos.

#Programación distribuida

Conceptos claves

Se refiere a un conjunto de computadoras conectadas en red que trabajan juntas para lograr un objetivo común. Los sistemas distribuidos pueden abarcar desde aplicaciones empresariales hasta infraestructuras de nube.

Sistemas Distribuidos

Los procesos pueden intercambiar información a través de la red para coordinar tareas y compartir datos.

Comunicación entre Procesos

#Programación distribuida

Conceptos claves

estos términos se utilizan en conjunto, la programación distribuida puede lograr paralelismo y concurrencia. El paralelismo implica realizar varias tareas simultáneamente, mientras que la concurrencia se refiere a la gestión de múltiples tareas que pueden ejecutarse en períodos de tiempo superpuestos.

Paralelismo y Concurrencia

Se diseña para ser tolerante a fallos, lo que significa que la aplicación sigue siendo funcional incluso si uno o varios nodos fallan. Esto puede lograrse mediante la redundancia, la replicación de datos y otros mecanismos.

Tolerancia a Fallos

#Programación distribuida

Conceptos claves

La capacidad de escalar horizontalmente es una ventaja de la programación distribuida. Puedes agregar más nodos al sistema para aumentar la capacidad y manejar una mayor carga.

Escalabilidad

Los sistemas distribuidos a menudo involucran el desarrollo de aplicaciones distribuidas donde diferentes partes del sistema pueden ser desarrolladas y mantenidas de manera descentralizada.

Desarrollo Descentralizado

#Programación distribuida

Conceptos claves

Algunos ejemplos comunes de aplicaciones distribuidas incluyen sistemas de bases de datos distribuidas, sistemas de procesamiento de grandes volúmenes de datos, sistemas de comercio electrónico distribuido y aplicaciones en la nube.

Ejemplos de Aplicaciones

A menudo hace uso de middleware, que son capas de software que facilitan la comunicación y la gestión de recursos entre nodos.

Middleware

#Programación distribuida

Actividad de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: distribuida.

Responde lo siguiente:

En el ejemplo de sockets, ¿cómo se establece la comunicación entre el servidor y el cliente? Describe los pasos clave y menciona las funciones específicas de socket utilizadas para configurar la conexión.

En el ejemplo del servidor y el cliente, el cliente envía un mensaje al servidor. ¿Cómo se realiza el envío y la recepción de mensajes entre los procesos?

¿Qué formato se utiliza para codificar y decodificar los mensajes?

Unidad 4

CUDA

#CUDA

Arquitectura de cómputo paralelo desarrollada por NVIDIA.

La palabra "CUDA" es un acrónimo de "Compute Unified Device Architecture". CUDA permite a los desarrolladores utilizar unidades de procesamiento gráfico (GPU) de NVIDIA para realizar cómputo de propósito general en paralelo, no solo para gráficos.

Permite a los desarrolladores utilizar unidades de procesamiento gráfico (GPU) de NVIDIA para realizar cómputo de propósito general en paralelo, no solo para gráficos.

#CUDA

Aspectos claves

Programación Paralela

CUDA permite a los desarrolladores escribir programas en un lenguaje similar a C/C++ para ejecutarse en GPUs. Permite aprovechar la capacidad de procesamiento en paralelo de las GPUs para realizar tareas intensivas en cómputo de manera más eficiente.

Modelo de Programación

Introduce un modelo de programación paralela jerárquica que incluye hilos, bloques y la jerarquía de la cuadrícula. Esto permite organizar y gestionar eficientemente los recursos de la GPU.

#CUDA

Aspectos claves

Extensiones al Lenguaje C

CUDA extiende el lenguaje C con características específicas que permiten a los desarrolladores escribir código para ejecutar en la GPU. Esto incluye palabras clave y directivas específicas que indican al compilador cómo paralelizar el código.

Desarrollo de Aplicaciones de Propósito General

Mientras que las GPUs inicialmente se diseñaron para renderizar gráficos, CUDA posibilita el uso de estas unidades de procesamiento para una amplia gama de aplicaciones de cómputo de propósito general, como simulaciones científicas, aprendizaje profundo, procesamiento de imágenes y más.

#CUDA

Aspectos claves

Librerías y Herramientas

NVIDIA proporciona librerías y herramientas específicas para CUDA que facilitan el desarrollo de aplicaciones paralelas, como cuDNN (para redes neuronales), cuBLAS (para operaciones matriciales) y más.

#CUDA

Compatibilidad

Verifica la Marca y Modelo de tu GPU

Determina la marca y el modelo de tu tarjeta gráfica (GPU). CUDA es una tecnología desarrollada por NVIDIA, por lo que tu GPU debe ser de esta marca.

Consulta la Lista de GPUs Compatibles con CUDA

NVIDIA mantiene una lista de GPUs compatibles con CUDA en su sitio web. Puedes revisar la Lista de GPUs Compatibles con CUDA para verificar si tu GPU está incluida.

#CUDA

Compatibilidad

Descarga e Instala el Toolkit de CUDA

Puedes descargar e instalar el Toolkit de CUDA desde el sitio web de NVIDIA. Si tu GPU es compatible, podrás instalar y utilizar el toolkit para desarrollar y ejecutar aplicaciones CUDA en tu sistema.

Verifica la Instalación de los Controladores de NVIDIA

Asegúrate de tener instalados los controladores más recientes de NVIDIA para tu GPU. Puedes descargar los controladores desde el sitio web oficial de NVIDIA.

#CUDA

Compatibilidad

Revisa la Documentación de tu GPU

Consulta la documentación de tu GPU específica para obtener detalles adicionales sobre sus capacidades CUDA. Puedes encontrar manuales y especificaciones técnicas en el sitio web del fabricante.

Utiliza Herramientas de Diagnóstico

Algunas herramientas de diagnóstico de hardware pueden proporcionar información detallada sobre tu GPU y sus capacidades. Por ejemplo, GPU-Z es una herramienta popular que puede mostrar información detallada sobre tu tarjeta gráfica.

#CUDA

Lenguajes

Python

PyCUDA y Numba son bibliotecas de Python que permiten la programación en CUDA. Además, CuPy es una biblioteca que ofrece una interfaz similar a NumPy pero diseñada para ejecutarse en GPU.

OpenCL

OpenCL (Open Computing Language) es un estándar abierto y multiplataforma que permite el desarrollo de programas para ejecutarse en unidades de procesamiento paralelo, incluidas las GPUs. Se puede utilizar con varios lenguajes de programación, como C, C++, Python, Java, y otros.

#CUDA

Lenguajes

Java

Aparapi es una biblioteca de Java que permite ejecutar código en la GPU utilizando OpenCL. Aunque el soporte para GPU en Java no es tan común como en otros lenguajes, existen algunas opciones disponibles.

MATLAB

MATLAB Parallel Computing Toolbox permite la ejecución de código en paralelo, incluyendo soporte para GPUs. Puedes utilizar GPUArrays para realizar operaciones en GPU desde MATLAB.

#CUDA

Lenguajes

La biblioteca gputools en R proporciona funciones para ejecutar código en GPU. Además, el paquete gpuR permite ejecutar código R en GPU mediante OpenCL.

Fortran

Además de CUDA, Fortran también puede aprovechar GPUs mediante OpenACC, un estándar de programación para cómputo en paralelo que admite varios lenguajes, incluyendo Fortran.

DirectCompute (Microsoft)

DirectCompute es una tecnología de Microsoft que permite la programación en GPU. Puede utilizarse con lenguajes compatibles con DirectX, como HLSL (High-Level Shading Language).

#CUDA

Funcionamiento

Jerarquía de Paralelismo

CUDA organiza el cómputo en paralelo mediante una jerarquía que incluye hilos, bloques y cuadrículas. Los hilos son las unidades más pequeñas de cómputo, organizados en bloques, y múltiples bloques forman una cuadrícula.

Kernel CUDA

En CUDA, los programas que se ejecutan en la GPU se denominan "kernels". Un kernel es una función diseñada para ser ejecutada en paralelo por varios hilos. Estos kernels se escriben en lenguaje CUDA, una extensión de C/C++ con palabras clave específicas.

#CUDA

Funcionamiento

Lanzamiento de Kernels

Para ejecutar un kernel en la GPU, se lanza desde la CPU. El programador especifica la dimensión de la cuadrícula y el tamaño de los bloques al lanzar un kernel. Los hilos se organizan automáticamente en bloques y cuadrículas según la configuración proporcionada.

Ejecución Concurrente

La GPU ejecuta múltiples hilos simultáneamente mediante la ejecución concurrente de múltiples bloques. Esto permite aprovechar la capacidad masivamente paralela de la GPU para acelerar tareas computacionales intensivas.

#CUDA

Funcionamiento

Memoria Global y Compartida

CUDA proporciona diferentes tipos de memoria, incluida la memoria global (compartida entre todos los hilos), la memoria compartida (compartida entre hilos en el mismo bloque), y la memoria local (privada para cada hilo). La elección del tipo de memoria impacta en el rendimiento y la eficiencia del cómputo.

Optimización de Acceso a Memoria

La optimización del acceso a la memoria es fundamental en CUDA. Dado que la GPU y la CPU tienen memorias separadas, es crucial minimizar las transferencias entre ellas y maximizar la eficiencia del acceso a los datos en la memoria de la GPU.

#CUDA

Funcionamiento

Modelo de Programación Heterogéneo

CUDA sigue un modelo de programación heterogéneo, donde la CPU y la GPU trabajan juntas. La CPU maneja tareas de control y coordina el lanzamiento de kernels en la GPU, que se encarga de realizar los cálculos intensivos en paralelo.

Toolkit de Desarrollo

NVIDIA proporciona un Toolkit de CUDA que incluye el compilador CUDA, bibliotecas y herramientas para facilitar el desarrollo. El compilador traduce el código CUDA a instrucciones que la GPU puede ejecutar.

#CUDA

Actividad de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: CUDA.

Responde lo siguiente:

¿Qué biliotecas o librerias puede usarse para escribir en python un script en la arq. CUDA?

¿Qué consideraciones se deben de tener en cuenta en el ejemplo escrito en c?

¿Con que comando se instala la libreria pycuda?

CORBA

Unidad 5

#CORBA

CORBA, que significa "Common Object Request Broker Architecture" (Arquitectura Común de Buscador de Objetos), es un estándar de computación distribuida que permite la comunicación entre objetos en un entorno distribuido. Proporciona un marco para el desarrollo de sistemas distribuidos y concurrentes.

#CORBA

Aspectos claves

Modelo de Objetos Distribuidos

CORBA permite a los desarrolladores construir sistemas distribuidos basados en un modelo de objetos. Los objetos distribuidos pueden residir en diferentes máquinas y comunicarse entre sí de manera transparente.

Interoperabilidad de Plataformas

CORBA facilita la interoperabilidad entre diferentes plataformas y lenguajes de programación. Los objetos CORBA pueden ser implementados en diferentes lenguajes y ejecutarse en sistemas heterogéneos, lo que es esencial en entornos distribuidos y concurrentes.

#CORBA

Aspectos claves

Solicitud y Respuesta

CORBA utiliza un mecanismo de solicitud y respuesta para la comunicación entre objetos distribuidos. Un objeto invoca un método en otro objeto remoto mediante una solicitud, y el objeto remoto responde con el resultado.

Implementación de Interfaces

En CORBA, las interfaces definen las operaciones que pueden realizar los objetos remotos. Las implementaciones de estas interfaces pueden existir en diferentes máquinas, permitiendo la distribución de la lógica de la aplicación.

#CORBA

Aspectos claves

ORB (Object Request Broker)

El ORB actúa como un intermediario entre los objetos distribuidos en CORBA. Facilita la comunicación entre objetos y maneja aspectos como la localización de objetos remotos y la serialización de datos.

Asincronía y Concurrencia

Aunque CORBA no está directamente centrado en la concurrencia, puede admitir operaciones asíncronas y concurrencia. Los objetos distribuidos pueden manejar solicitudes simultáneas y procesarlas de manera concurrente, lo que es esencial en sistemas distribuidos de alto rendimiento.

#CORBA

Aspectos claves

Eventos y Notificaciones

CORBA incluye mecanismos para la propagación de eventos y notificaciones entre objetos. Esto puede ser útil en situaciones donde se necesita la notificación asíncrona de eventos en un entorno distribuido y concurrente.

Marco de Desarrollo (Framework)

Un marco de desarrollo es una estructura conceptual y tecnológica que proporciona funcionalidades genéricas para facilitar el desarrollo de aplicaciones. Es un conjunto de bibliotecas, herramientas y convenciones que permiten a los desarrolladores crear aplicaciones más fácilmente al proporcionar un esqueleto y una estructura predefinida.

#CORBA

Funcionamiento

Definición de Interfaces

El desarrollo en CORBA comienza con la definición de interfaces. Las interfaces describen los métodos que los objetos pueden invocar y cómo se comunicarán. Estas interfaces se definen en el lenguaje de especificación de interfaz de objeto (IDL, por sus siglas en inglés).

IDL (Interface Definition Language)

La IDL es un lenguaje neutro que se utiliza para describir las interfaces de los objetos en CORBA. Las interfaces definidas en IDL son independientes del lenguaje de programación y de la plataforma, permitiendo la interoperabilidad entre sistemas heterogéneos.

#CORBA

Funcionamiento

Generación de Stubs y Esqueletos

A partir de las definiciones de interfaz en IDL, se generan automáticamente "stubs" (en el lado del cliente) y "esqueletos" (en el lado del servidor). Estos componentes facilitan la comunicación entre objetos distribuidos.

Objeto Request Broker (ORB)

El ORB actúa como un intermediario entre los objetos distribuidos. Facilita la localización de objetos remotos, la invocación de métodos y la transferencia de datos entre los objetos en diferentes máquinas. El ORB maneja la complejidad de la comunicación distribuida.

#CORBA

Funcionamiento

Invocación de Métodos

Cuando un objeto desea invocar un método en otro objeto remoto, utiliza su stub correspondiente. El stub se comunica con el ORB, que se encarga de localizar el objeto remoto y enviar la solicitud. En el lado del servidor, el esqueleto recibe la solicitud, la dirige al objeto real y devuelve el resultado al stub del lado del cliente.

Protocolo de Comunicación

CORBA utiliza un protocolo de comunicación llamado IIOP (Internet Inter-ORB Protocol). IIOP permite la comunicación entre ORBs, incluso si están implementados en diferentes lenguajes de programación y se ejecutan en plataformas diferentes.

#CORBA

Funcionamiento

Servicios CORBA

CORBA también proporciona una serie de servicios estándar que pueden ser utilizados por aplicaciones distribuidas, como el servicio de nombres para localizar objetos por su nombre, el servicio de transacciones para gestionar operaciones atómicas, y otros servicios que mejoran la interoperabilidad y la gestión de recursos.

Implementación en Diferentes Lenguajes

Un beneficio clave de CORBA es su capacidad para admitir objetos escritos en diferentes lenguajes de programación, siempre que se definan las interfaces en IDL. Esto facilita la construcción de sistemas distribuidos heterogéneos.

#CORBA

Lenguajes recomendados

Java

Java es uno de los lenguajes más populares para trabajar con CORBA. La plataforma Java proporciona soporte incorporado para CORBA, y hay herramientas específicas, como el compilador IDL de Java (idlj), que facilitan la generación de stubs y esqueletos para objetos CORBA.

C++

C++ ha sido históricamente uno de los lenguajes más utilizados con CORBA. La especificación original de CORBA se creó con C++ en mente, y hay muchas bibliotecas y herramientas disponibles para facilitar la integración de CORBA con C++

#CORBA

Lenguajes recomendados

Python

Python cuenta con soporte para CORBA a través de bibliotecas como omniORB y PyORB. Estas bibliotecas permiten a los desarrolladores trabajar con CORBA de manera efectiva desde el entorno Python.

Para el ecosistema .NET, se ha desarrollado soporte para CORBA en lenguajes como C#. Se pueden utilizar bibliotecas específicas, como Object Request Broker for .NET (ORB.NET), para facilitar la integración de CORBA con aplicaciones en el entorno .NET.

#CORBA

Lenguajes recomendados

Ada

Ada es un lenguaje que ha sido históricamente utilizado en aplicaciones críticas y sistemas embebidos, y también tiene soporte para CORBA. El compilador de Ada puede generar stubs y esqueletos para objetos CORBA.

IDL (Interface Definition Language)

Aunque no es un lenguaje de programación en sí mismo, el IDL se utiliza para definir las interfaces en CORBA. El IDL es independiente del lenguaje, lo que permite a los desarrolladores describir interfaces de objetos de manera neutral y luego generar el código en el lenguaje deseado.

#CORBA

Actividad de aprendizaje

En la barra de búsqueda teclea la palabra: frexus.
Pulsa en la opción que dice: Generando valor agregado.
Haz clic sobre la opción academia. Luego en el nombre de la materia.
Lee el recurso: CORBA.

Responde lo siguiente:

¿Cómo se define la interfaz de un objeto en CORBA y por qué es importante en el contexto del ejemplo?

¿Cuál es el papel de los stubs y esqueletos generados automáticamente en el desarrollo de aplicaciones CORBA en Java?

Explique el flujo de ejecución en el lado del servidor cuando se inicia el programa MathServer.java. ¿Cómo se activa y gestiona el objeto servidor en este ejemplo?