Está en la página 1de 13

Procesamiento Paralelo

Presentado por

Howard Nicolas Solarte Mora

Gladys Angélica Garzón Espitia

Profesor

Alexis Rojas

Politécnico Gran colombiano.

Ingeniería de Sistemas.

Sistemas distribuidos

24/04/2020

Estado del Arte

5 Mayo 2020

Procesamiento paralelo
2
Lo que se entiende como procesamiento es la capacidad de atender solicitudes para su
validación, transformación, o análisis de la misma. Y entiendo por paralelo como la función
de realizar una instancia o ejecución al mismo tiempo de un proceso o tarea, esto con el fin
de obtener el mayor rendimiento posible a nivel de
procesamiento.

En cuanto a Rocks, es la plataforma la cual me da la


posibilidad de crear mi ambiente de gran capacidad de
procesamiento, lo cual me permite tener mi Cluster de
alto rendimiento de forma real o virtual.

Computación Paralela

La computación paralela viene para solventar el problema de poder procesar grana cantidad de
información en tiempos de respuesta rápido, esto aplicado en la vida real se implementa en
sistemas para analizar o predecir las condiciones meteorológicas , procesamiento de imágenes
para identificar enfermedades.

Para la computación paralela muchos cálculos son llevados de forma simultánea.

Estos procesos se pueden trabajar de dos maneras:

Cada procesador se encarga de una parte del problema.

O los procesadores se pueden intercambiar datos entre ellos. (Universidad Nacional -


Programación paralela. Pag.13)

Paralelismo y Concurrencia

¿Son lo mismo? ¿Son sinónimos ?

La concurrencia es la capacidad de poder operar procesar al mismo tiempo, el paralelismo son


las actividades siendo instanciadas o ejecutadas al mismo tiempo.
3

Década de los 80

Nace el proyecto Concurrent Computation, del instituto de Tecnología de california el cual logró
avances en cuanto al rendimiento usando microprocesadores surgen los clusters. (Universidad
Nacional - Programación paralela ).

Década de los 90

Surge el estándar MPI el cual es una biblioteca de paso de mensajes, de igual forma OpenMP.

Hardware multiprocesador.

Actualidad.
4
Actualmente las grandes compañías como Google, IBM, AMAZON, las cuales ofrecen
servicios de Cloud Computing, mantienen grandes granjas de Clusters para ofrecer dichos
servicios donde garantizan un alto rendimiento, reducir la brecha de los altos costos que
representa crear un ambiente de clusters a nivel empresarial .

En la siguiente imagen se muestra el esquema de Clusters que ofrece Google.

Tipos de Cargas de trabajo en Clusters

Según Google, existen dos tipos de cargas de trabajo Clusters:


5
Computación de alto rendimiento (High performance Computing HPC):

Son muchos nodos trabajadores que se vinculan para ejecutar una tarea en simultáneo,
además que se debe contar con una latencia de red baja, para un buen funcionamiento.

Computación de alta capacidad de procesamiento (High Throughput Computing):

Aquí los nodos trabajadores no se comunican entre ellos para procesar las tareas. Se puede
aplicar para la renderización de medios, para el procesamiento de fisica de particulas, o en
tareas donde se requiera procesar muchos archivos individuales.

Programación Paralela

De acuerdo con Dominguez Gimenez, del Depto de Sistemas de la Universidad de Murcia,


donde se vienen desarrollando proyectos de Introducción a la programación paralela de
distintos niveles, pero se encuentra con la dificultad de que la mayoría de docentes no son
especialistas en programación paralela, loc ual dificulta la introducción de proyectos aplicados
en Instituciones educativas.

Software Paralelo

Como se indica en la lectura fundamental Unidad 3 Escenario 6 , en las API´s más comunes, se
hace uso de la librería MPI para el envío y recepción de mensajes para sistemas de memoria
distribuida.

MPI define una biblioteca de funciones que se pueden llamar desde los programas Java,
Python, C, C ++ y Fortran. Y entre estos, los compiladores más utilizados para desarrollar
programación paralela son: C, C ++ y Fortran. ( Programación Paralela Aplicada Pag. 12)
6

/********************************Parte del Codigo*******************************/

* Entrada: Numero de trapecios

* Salida: Estimación de la integral de "a" a "b" de f(x)

* usando la regla trapezoidal y "n" trapezoides..

* Uso: mpirun -np <numero de procesos> ./mpi_trap <numero de


trapezoides>

* Algoritmo:

* 1. Cada proceso calcula "su" intervalo de integración.

* 2. Cada proceso estima la integral de f (x) durante su intervalo


utilizando la regla trapezoidal.

* 3.1. Cada proceso != 0 envía su integral a 0.

* 3.2. El proceso 0 suma los cálculos recibidos del individuo procesa e


imprime el resultado.

* Nota: f(x) = (0.2(x-4)^3)-(2x)+12

*/

#include <stdio.h>

#include <stdlib.h>
7
#include <string.h>

#include <mpi.h>

const double a = 0;

const double b = 10;

/* Declaraciones de funciones */

void Get_input(int argc, char* argv[], int my_rank, double* n_p);

double Trap(double left_endpt, double right_endpt, int trap_count, double


base_len);

double f(double x);

int main(int argc, char** argv) {

int my_rank, comm_sz, local_n;

double n, h, local_a, local_b;

double local_int, total_int;

double start, finish, loc_elapsed, elapsed;

MPI_Init(NULL, NULL);

MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);

MPI_Comm_size(MPI_COMM_WORLD, &comm_sz);

/*Imprime en consola el nucleo que ejecuto el proceso*/

printf("soy el core nro. %d de %d\n", my_rank, comm_sz);

Get_input(argc, argv, my_rank, &n); /*Leer la entrada del usuario*/


8

/*Nota: h y local_n son iguales para todos los procesos */

h = (b - a) / n; /* longitud de cada trapecio */

local_n = n / comm_sz; /* cantidad de trapecios por proceso */

/* Duración del intervalo de integración de cada proceso = local_n * h.


*/

local_a = a + my_rank * local_n * h;

local_b = local_a + local_n * h;

MPI_Barrier(MPI_COMM_WORLD);

start = MPI_Wtime();

/* Calcular la integral local de cada proceso utilizando puntos finales


locales*/

local_int = Trap(local_a, local_b, local_n, h);

finish = MPI_Wtime();

loc_elapsed = finish - start;

MPI_Reduce(&loc_elapsed, &elapsed, 1, MPI_DOUBLE, MPI_MAX, 0,


MPI_COMM_WORLD);

/* Suma las integrales calculadas por cada proceso */

MPI_Reduce(&local_int, &total_int, 1, MPI_DOUBLE, MPI_SUM, 0,


MPI_COMM_WORLD);

if (my_rank == 0) {
9
printf("Con n = %.0f trapezoides, el valor de la integral entre
%.0f a %.0f = %f \n", n, a, b, total_int);

printf("Tiempo transcurrido = %f millisegundos \n", elapsed *


1000);

/* Cerrar MPI */

MPI_Finalize();

return 0;

} /* main */

/*------------------------------------------------ ------------------

* Función: Get_input

* Propósito : obtener la entrada del usuario : el número de trapecios

**

* Args de entrada :

* 1. my_rank: rango de proceso en MPI_COMM_WORLD

* 2. comm_sz : número de procesos en MPI_COMM_WORLD

**

* Args de salida :

* 1. n_p: puntero al número de trapecios

*/

void Get_input(int argc, char* argv[], int my_rank, double* n_p) {

if (my_rank == 0) {

if (argc != 2) {
10
fprintf(stderr, "uso: mpirun -np <N> %s <numero de trapezoides>
\n", argv[0]);

fflush(stderr);

*n_p = -1;

else {

*n_p = atoi(argv[1]);

// Transmite el valor de n a cada proceso

MPI_Bcast(n_p, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);

// n negativo termina el programa

if (*n_p <= 0) {

MPI_Finalize();

exit(-1);

} /* Get_input */

/*------------------------------------------------ ------------------

* Función: Trap

* Propósito : función en serie para estimar una integral definida usando


la regla trapezoidal

**

* Args de entrada :

* -left_endpt
11
* -right_endpt

* -trap_count

* -base_len

**

* Valor de retorno : estimación de la regla trapezoidal de la integral de

* left_endpt a right_endpt usando trap_count trapecios

*/

double Trap(double left_endpt, double right_endpt, int trap_count, double


base_len) {

double estimate, x;

int i;

estimate = (f(left_endpt) + f(right_endpt)) / 2.0;

for (i = 1; i <= trap_count - 1; i++) {

x = left_endpt + i * base_len;

estimate += f(x);

estimate = estimate * base_len;

return estimate;

} /* Trap */

/*------------------------------------------------ ------------------

* Función: f

* Propósito : Calcular el valor de la función a integrar


12
* Args de entrada : x

*/

double f(double x) {

double x1;

double x2;

x1 = ((x-4.0)*(x-4.0)*(x-4.0));

x2 = 2.0*x;

return ((0.2*x1)-x2)+12.0;;

} /* f */

Cómo Compilar el Programa

MPICC Paralell -o Paralell

Cómo Ejecutar el Programa

MPIRUN -NP 5 Paralell 9

MPIRUN : Comando para ejecutar un programa compilado

NP ; Número de procesos para la tarea

Paralell : Nombre del programa

9 ; Parámetro de entrada para el algoritmo

Video:

Bibliografía

http://ferestrepoca.github.io/paradigmas-de-
programacion/paralela/paralela_teoria/presentacion_p.pdf
13

https://www.researchgate.net/publication/236541914_Parallel_processing_in_power_systems_c
omputation

https://www.ijirmps.org/research-paper.php?id=377

https://cloud.google.com/solutions/using-clusters-for-large-scale-technical-computing?hl=es

https://upcommons.upc.edu/bitstream/handle/2117/89854/03%20-%20%20Un%20curso%20pra
%cc%81ctico%20de%20Programacio%cc%81n%20Paralela%20basado%20en%20problemas
%20de%20Concurso%20Espan%cc%83ol%20de%20Programacio%cc%81n%20Paralela.pdf?
sequence=1&isAllowed=y