HPC2: Paralelismo de Memoria Compartida y Distribuida

https://github.com/mbrenesn/FisicaComputacional/tree/main/Tema_09

• 2 tipos
  • Memoria Compartida:
    • toda la memoria se la da a todos los procesos y la comparten
  • Memoria Distribuida
    • se parte la memoria y cada proceso tiene separada la memoria
• A nivel de cluster es si se puede trabajar en un nodo o varios

• Aspectos
  • seguridad no se toca informacion de otra memoria
  • Si es muy grande mejor distribuido para que se procese rapido
  • Limitantes de software que solo utilizan memoria compartida

• Distribuida
  • Debe tener una red de alta velocidad

• La memoria es el componente mas importante
• Cuando los procesos no se tienen que hablar entre ellos

Memoria Compartida

• Instrucciones
• Datos
• Files
• Estan compartidas
• Pero los registros y Stack cada hilo tiene uno
• Este es una API con librerias para manejo de memoria compartidad en foltran y C++

• A si se veria

• aqui es donde inicio o se activa el paralelimos
• Parece comentado pero no a si es
• ejemplo

• En esto podemos usar variables de ambiente POr ejemplo use x cantidad de hijos

ejemplo probar programa

nano hello.cpp

• Pegamos el código

#include <iostream>
#include <omp.h> // Biblioteca que contiene OpenMP!

int main(){

  omp_set_num_threads(4); // Incluimos el número de hilos mediante
                          // la directiva del API
  // El #pragma es la directiva de compilador que inicia la región en paralelo
  #pragma omp parallel
  {
    int my_proc = omp_get_thread_num(); // Ahora my_proc es una variable que identifica
                                        // al hilo
    std::cout << "Hello! From thread #: " << my_proc << std::endl;
  }

  return 0;
}

g++ hellop.cpp -o hello.x -fopenmp

• no hay procesos

squeue

• Correrlo

./hello.x

• Ejemplo de sumatoria de verctores
• https://github.com/mbrenesn/FisicaComputacional/blob/main/Tema_09/vector.cpp

#include <iostream>
#include <vector>
#include <sys/time.h>

#include <omp.h>

// Esta función se utiliza para calcular el tiempo que tarda
// la ejecución de ciertas funciones
// Está basada en el uso de una función primitiva que evalúa al tiempo
// transcurrido desde cierto valor de referencia
double seconds()
{
  struct timeval tmp;
  double sec;
  gettimeofday( &tmp, (struct timezone *)0 );
  sec = tmp.tv_sec + ((double)tmp.tv_usec)/1000000.0;
  
  return sec;
}

int main(){

  int n = 500000000;

  std::vector<double> a(n, 1.0);
  std::vector<double> b(n, 3.5);
  std::vector<double> c(n, 0.0);

  int num_procs;
  double time_1 = seconds();
  #pragma omp parallel
  {
    num_procs = omp_get_num_threads();
    #pragma omp for
    for(int i = 0; i < n; ++i){
      c[i] = a[i] + b[i];
    }
  }
  double time_2 = seconds();

  std::cout << "Number of Threads: " << num_procs << std::endl;
  std::cout << "Time to complete loop: " << time_2 - time_1 << std::endl;

  return 0;
}

• esto lo que hace que cada loops tenga un hilo asignado

NOTA:

Tenemos 2 colas

• shared: compartida no mas de 20 cores
• mpi= solo 20 cores por nodo

• mpi este numero no se cambia
• con este comando podemos ver la informacion

• Debug la cola
• tima el tiempo que se mantiene vivo
• pty terminal que quiero
• -l heredar

• Aqui se definen las particiones

nano /etc/

• para aplicar

• Ver info del usuario

manera oficial de corre

• Manera oficial de de correr

srun -n10 --time1:00:00 --pty /bin/bash -l

• n10
• a diferencia de hello que pasamos los therads aqui obtenemos lo que tenemos disponibles

• podemos consultar con esta variable

• lo podemos asignar

• con 10

• con 8

• cambiamos

lista de modulos

• Para salir asi

exit
squeue

• ver trabajo

• htop

Supervisar

http://10.10.132.5/ganglia/

https://sites.google.com/view/helix-hpc/home