Skip to main content

OpenCoarrays Overview

Introduction to OpenCoarrays Fortran Framework

OpenCoarrays is an open-source software framework for parallel computing in Fortran. It provides a simple and efficient way to write parallel programs using coarray Fortran extensions. Coarray Fortran is an extension of Fortran that enables the development of parallel programs by allowing the programmer to directly specify the distribution of data and the communication between parallel instances of the program.

In this tutorial, we will explore the history, features, and examples of the OpenCoarrays Fortran framework.

History​

OpenCoarrays was originally developed by a team of researchers at Rice University and the University of Houston. The project started in 2009 and has since grown into a widely-used framework for parallel programming in Fortran. The development of OpenCoarrays has been driven by the need for a simple and efficient way to write parallel programs in Fortran.

Features​

1. Coarray Syntax​

OpenCoarrays extends the Fortran language with coarray syntax, which allows the programmer to specify the distribution of data and the communication between parallel instances of the program. Coarrays are declared with the coarray keyword and can be used like regular arrays, with additional syntax for specifying the source and destination of communication operations.

Here is an example that demonstrates the use of coarrays in OpenCoarrays:

program parallel_sum
  implicit none
  integer, dimension(:), allocatable, codimension[:,:] :: a
  integer :: i, sum

  allocate(a[*][*])

  ! Initialize coarray data
  a(:,:) = 1

  ! Compute the sum in parallel
  sum = 0
  do i = 1, size(a)
    sum = sum + a(i, this_image())
  end do

  ! Print the result
  if (this_image() == 1) then
    print *, "Sum:", sum
  end if

  ! Synchronize all images before exiting
  sync all
end program parallel_sum

In this example, each image (parallel instance of the program) has a distributed array a that is initialized with the value 1. The sum of the elements of a is computed in parallel using a loop, with each image contributing a portion of the sum. The result is then printed only by the first image.

2. Collective Operations​

OpenCoarrays provides a set of collective operations that allow for efficient parallel communication and synchronization. These operations include sync, lock, unlock, sum, min, max, broadcast, and reduce.

Here is an example that demonstrates the use of collective operations in OpenCoarrays:

program parallel_max
  implicit none
  integer :: value, max_value

  ! Initialize value on each image
  value = this_image()

  ! Find the maximum value across all images
  max_value = max(value)

  ! Print the maximum value on each image
  print *, "Image", this_image(), "Max Value:", max_value

  ! Synchronize all images before exiting
  sync all
end program parallel_max

In this example, each image initializes a local variable value with its image number. The max collective operation is used to find the maximum value across all images. The result is then printed by each image, showing the maximum value found.

3. Interoperability with MPI​

OpenCoarrays provides interoperability with the Message Passing Interface (MPI), a widely-used standard for parallel computing. This allows OpenCoarrays programs to easily integrate with existing MPI codes and libraries.

To use MPI with OpenCoarrays, simply link the program with the OpenCoarrays library and the MPI library, and use the mpi_coarray module to access MPI functionality.

Here is an example that demonstrates the use of MPI with OpenCoarrays:

program mpi_parallel_sum
  use mpi_coarray
  implicit none
  integer :: ierr, rank, size, sum

  ! Initialize MPI
  call MPI_Init(ierr)
  call MPI_Comm_rank(MPI_COMM_WORLD, rank, ierr)
  call MPI_Comm_size(MPI_COMM_WORLD, size, ierr)

  ! Compute the sum in parallel
  sum = (rank + 1) * size

  ! Print the result
  print *, "Rank", rank, "Sum:", sum

  ! Synchronize all images before exiting
  sync all

  ! Finalize MPI
  call MPI_Finalize(ierr)
end program mpi_parallel_sum

In this example, MPI functions are used to initialize and finalize MPI, get the rank and size of the MPI communicator, and perform parallel communication. The result is then printed by each image, showing the computed sum.

Examples​

Here are a few more examples that showcase the features of the OpenCoarrays Fortran framework:

  • Hello World: A simple example that demonstrates the use of coarrays to print "Hello, World!" from multiple images.
  • Matrix Multiplication: A parallel implementation of matrix multiplication using coarrays.
  • Parallel Monte Carlo Pi: A parallel implementation of the Monte Carlo method to estimate the value of Pi using coarrays and collective operations.

Conclusion​

In this tutorial, we have explored the OpenCoarrays Fortran framework, its history, features, and examples. OpenCoarrays provides a simple and efficient way to write parallel programs in Fortran, with support for coarray syntax, collective operations, and interoperability with MPI. It is a powerful tool for high-performance scientific computing and parallel programming. For more information, you can visit the official OpenCoarrays website.