El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Programación Paralela con Coarrays

Siguiente ►
►

La programación paralela es una técnica que permite ejecutar múltiples operaciones simultáneamente, aprovechando al máximo los recursos de hardware disponibles. En Fortran, los coarrays son una extensión del lenguaje que facilita la programación paralela de manera eficiente y relativamente sencilla.

Introducción a los Coarrays

Los coarrays en Fortran permiten distribuir datos y tareas entre múltiples imágenes (procesos paralelos). Cada imagen puede ejecutar su propio código y acceder a sus propios datos, así como a los datos de otras imágenes.

Conceptos Clave

  • Imagen: Una instancia de un programa que se ejecuta en paralelo con otras instancias.
  • Coarray: Una variable que puede ser accedida por múltiples imágenes.
  • Sintaxis de Coarray: Se utiliza [] para especificar dimensiones de coarray.

Ejemplo Básico

program hello_coarray
  implicit none
  integer :: me, num_images

  ! Obtener el número de imágenes y el índice de la imagen actual
  num_images = num_images()
  me = this_image()

  print *, 'Hello from image ', me, ' of ', num_images
end program hello_coarray

En este ejemplo, cada imagen imprime su propio número y el total de imágenes.

Declaración y Uso de Coarrays

Declaración de Coarrays

Para declarar un coarray, se utiliza la siguiente sintaxis:

real :: array[*]  ! Coarray de una dimensión
real :: matrix(10, 10)[*]  ! Coarray bidimensional

Acceso a Coarrays

Para acceder a los elementos de un coarray en una imagen específica, se utiliza la notación array[imagen].

program coarray_example
  implicit none
  integer :: me, num_images
  real :: data[*]

  num_images = num_images()
  me = this_image()

  ! Asignar un valor a data en cada imagen
  data = me

  ! Sincronizar todas las imágenes
  sync all

  ! Imprimir el valor de data en la imagen 1
  if (me == 1) then
    print *, 'Data in image 1: ', data[1]
    print *, 'Data in image 2: ', data[2]
  end if
end program coarray_example

Sincronización

La sincronización es crucial en la programación paralela para asegurar que todas las imágenes estén en el mismo punto de ejecución antes de proceder.

Sentencias de Sincronización

  • sync all: Sincroniza todas las imágenes.
  • sync images: Sincroniza un subconjunto específico de imágenes.
sync all  ! Sincroniza todas las imágenes
sync images(2, 3)  ! Sincroniza solo las imágenes 2 y 3

Ejercicio Práctico

Ejercicio 1: Suma Paralela

Escribe un programa en Fortran que utilice coarrays para calcular la suma de un arreglo distribuido entre múltiples imágenes.

Solución

program parallel_sum
  implicit none
  integer, parameter :: n = 100
  integer :: i, me, num_images
  real :: local_sum, total_sum
  real, dimension(n) :: array
  real, dimension(n/num_images) :: local_array[*]

  num_images = num_images()
  me = this_image()

  ! Inicializar el arreglo en la imagen 1
  if (me == 1) then
    array = (/ (i, i = 1, n) /)
  end if

  ! Distribuir el arreglo entre las imágenes
  call distribute_array(array, local_array)

  ! Calcular la suma local
  local_sum = sum(local_array)

  ! Sincronizar y sumar los resultados locales
  sync all
  total_sum = sum(local_sum[:])

  ! Imprimir el resultado en la imagen 1
  if (me == 1) then
    print *, 'Total sum: ', total_sum
  end if
end program parallel_sum

subroutine distribute_array(array, local_array)
  real, dimension(:), intent(in) :: array
  real, dimension(:), intent(out) :: local_array
  integer :: i, me, num_images, local_size

  num_images = num_images()
  me = this_image()
  local_size = size(local_array)

  ! Distribuir el arreglo
  do i = 1, local_size
    local_array(i) = array((me-1)*local_size + i)
  end do
end subroutine distribute_array

Retroalimentación y Consejos

  • Error Común: No sincronizar las imágenes antes de acceder a los datos de otras imágenes puede llevar a resultados incorrectos.
  • Consejo: Utiliza sync all o sync images para asegurar que todas las imágenes estén en el mismo punto de ejecución antes de proceder.

Conclusión

En esta sección, hemos aprendido los conceptos básicos de la programación paralela con coarrays en Fortran. Hemos visto cómo declarar y utilizar coarrays, cómo sincronizar imágenes y cómo aplicar estos conceptos en un ejercicio práctico. La programación paralela puede mejorar significativamente el rendimiento de tus programas, especialmente en sistemas con múltiples núcleos o procesadores. En el próximo módulo, exploraremos más técnicas avanzadas y mejores prácticas para optimizar tu código Fortran.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados