Aprende MCP - Modelo de Computación Paralela

¿Qué aprenderás?

Conceptos básicos

Entiende los fundamentos de la computación paralela y sus modelos teóricos.

Ejemplos prácticos

Implementa algoritmos paralelos con ejemplos en diferentes lenguajes.

Optimización

Aprende técnicas para mejorar el rendimiento de tus aplicaciones.

Ejemplos de MCP

Suma de vectores paralela

Este ejemplo muestra cómo realizar la suma de dos vectores utilizando múltiples hilos para acelerar el proceso.

// Suma de vectores paralela en JavaScript
const vectorSumParallel = (vec1, vec2, threads = 4) => {
    const result = new Array(vec1.length);
    const chunkSize = Math.ceil(vec1.length / threads);
    
    const promises = [];
    
    for (let i = 0; i < threads; i++) {
        promises.push(new Promise(resolve => {
            setTimeout(() => {
                const start = i * chunkSize;
                const end = Math.min(start + chunkSize, vec1.length);
                
                for (let j = start; j < end; j++) {
                    result[j] = vec1[j] + vec2[j];
                }
                resolve();
            }, 0);
        }));
    }
    
    return Promise.all(promises).then(() => result);
};

// Uso:
const vec1 = [1, 2, 3, 4, 5, 6, 7, 8];
const vec2 = [8, 7, 6, 5, 4, 3, 2, 1];

vectorSumParallel(vec1, vec2, 4)
    .then(result => console.log(result));
// Resultado: [9, 9, 9, 9, 9, 9, 9, 9]

Búsqueda paralela

Implementación de búsqueda en un array utilizando múltiples hilos para dividir el trabajo.

// Búsqueda paralela en JavaScript
const parallelSearch = (array, target, threads = 4) => {
    const chunkSize = Math.ceil(array.length / threads);
    const promises = [];
    let foundIndex = -1;
    
    for (let i = 0; i < threads; i++) {
        promises.push(new Promise(resolve => {
            setTimeout(() => {
                const start = i * chunkSize;
                const end = Math.min(start + chunkSize, array.length);
                
                for (let j = start; j < end && foundIndex === -1; j++) {
                    if (array[j] === target) {
                        foundIndex = j;
                        break;
                    }
                }
                resolve();
            }, 0);
        }));
    }
    
    return Promise.all(promises).then(() => foundIndex);
};

// Uso:
const data = [3, 7, 2, 9, 5, 1, 8, 4, 6];
const target = 5;

parallelSearch(data, target, 4)
    .then(index => {
        if (index !== -1) {
            console.log(`Elemento encontrado en posición ${index}`);
        } else {
            console.log('Elemento no encontrado');
        }
    });

MapReduce simple

Implementación básica del modelo MapReduce para procesamiento paralelo de datos.

// Implementación simple de MapReduce en JavaScript
class SimpleMapReduce {
    constructor(data, mapper, reducer, threads = 4) {
        this.data = data;
        this.mapper = mapper;
        this.reducer = reducer;
        this.threads = threads;
    }
    
    async execute() {
        // Fase Map
        const mapResults = await this.parallelMap();
        
        // Fase Shuffle (agrupar por clave)
        const shuffleResults = {};
        mapResults.forEach(result => {
            result.forEach(([key, value]) => {
                if (!shuffleResults[key]) {
                    shuffleResults[key] = [];
                }
                shuffleResults[key].push(value);
            });
        });
        
        // Fase Reduce
        const reduceResults = await this.parallelReduce(shuffleResults);
        
        return reduceResults;
    }
    
    async parallelMap() {
        const chunkSize = Math.ceil(this.data.length / this.threads);
        const promises = [];
        
        for (let i = 0; i < this.threads; i++) {
            promises.push(new Promise(resolve => {
                setTimeout(() => {
                    const start = i * chunkSize;
                    const end = Math.min(start + chunkSize, this.data.length);
                    const chunk = this.data.slice(start, end);
                    const mapped = chunk.map(this.mapper);
                    resolve(mapped);
                }, 0);
            }));
        }
        
        return Promise.all(promises);
    }
    
    async parallelReduce(shuffledData) {
        const keys = Object.keys(shuffledData);
        const chunkSize = Math.ceil(keys.length / this.threads);
        const promises = [];
        const results = {};
        
        for (let i = 0; i < this.threads; i++) {
            promises.push(new Promise(resolve => {
                setTimeout(() => {
                    const start = i * chunkSize;
                    const end = Math.min(start + chunkSize, keys.length);
                    
                    for (let j = start; j < end; j++) {
                        const key = keys[j];
                        results[key] = this.reducer(key, shuffledData[key]);
                    }
                    resolve();
                }, 0);
            }));
        }
        
        await Promise.all(promises);
        return results;
    }
}

// Uso:
const data = ['hola', 'mundo', 'computación', 'paralela', 'javascript', 'ejemplo'];
const mapper = word => [[word.length, 1]];
const reducer = (key, values) => values.reduce((a, b) => a + b, 0);

const mapReduce = new SimpleMapReduce(data, mapper, reducer, 4);
mapReduce.execute().then(result => console.log(result));
// Resultado: {4: 2, 5: 1, 12: 1, 8: 1, 7: 1}

Conceptos clave de MCP

Modelos de paralelismo

Existen varios modelos para implementar computación paralela:

Modelo PRAM (Parallel Random Access Machine)
Modelo de memoria compartida
Modelo de paso de mensajes
Modelo MapReduce
Modelo BSP (Bulk Synchronous Parallel)

Métricas de rendimiento

Para evaluar el rendimiento de algoritmos paralelos:

Speedup: Tiempo secuencial / Tiempo paralelo
Eficiencia: Speedup / Número de procesadores
Escalabilidad: Cómo mejora el rendimiento al añadir recursos
Overhead: Tiempo adicional por comunicación y sincronización