Parallel NetCDF Overview

Introduction to Parallel NetCDF Fortran Framework

Parallel NetCDF is a parallel I/O library that provides high-performance access to distributed scientific data stored in the NetCDF format. It allows multiple processes to read from and write to a NetCDF file simultaneously, enabling efficient parallel I/O operations. In this tutorial, we will explore the history, features, and examples of the Parallel NetCDF Fortran framework.

History

Parallel NetCDF was originally developed at Argonne National Laboratory in collaboration with Northwestern University and The University of Chicago. The goal was to address the need for efficient parallel I/O in scientific applications that use NetCDF files. Over the years, the framework has evolved and gained popularity among the scientific community for its performance and ease of use.

Features

Parallel I/O Operations

Parallel NetCDF allows multiple processes to perform parallel I/O operations on a NetCDF file simultaneously. It utilizes collective I/O operations to improve performance by reducing communication overhead. This feature is particularly useful in applications that require concurrent read and write access to a large amount of data.

To illustrate this feature, let's consider an example where multiple processes are reading data from a NetCDF file in parallel:

program parallel_read
  use parallel_netcdf
  integer :: ncid, varid, status
  integer, parameter :: num_procs = 4
  integer, parameter :: num_elements = 100
  real :: data(num_elements)
  
  ! Initialize Parallel NetCDF
  call ncmpi_open(MPI_COMM_WORLD, "data.nc", NC_NOWRITE, ncid, status)
  
  ! Each process reads a portion of the data
  call ncmpi_inq_varid(ncid, "temperature", varid, status)
  call ncmpi_get_vara_float(ncid, varid, [1, my_rank * num_elements + 1], [1, num_elements], data, status)
  
  ! Process-specific computations using the data
  
  ! Finalize Parallel NetCDF
  call ncmpi_close(ncid, status)
end program parallel_read

In this example, each process reads a portion of the "temperature" variable from the NetCDF file. The ncmpi_get_vara_float function is used to retrieve the data, and the process-specific computations can then be performed using the retrieved data.

Data Partitioning

Parallel NetCDF provides support for data partitioning techniques such as block-cyclic distribution and contiguous distribution. These techniques allow the data to be efficiently divided among the processes, minimizing communication overhead and load balancing issues.

To demonstrate data partitioning, let's consider an example where a 2D array is distributed among multiple processes using block-cyclic distribution:

program data_partitioning
  use parallel_netcdf
  integer :: ncid, varid, status
  integer, parameter :: num_procs = 4
  integer, parameter :: num_rows = 100, num_cols = 100
  real :: data(num_rows/num_procs, num_cols)
  
  ! Initialize Parallel NetCDF
  call ncmpi_open(MPI_COMM_WORLD, "data.nc", NC_NOWRITE, ncid, status)
  
  ! Each process reads a portion of the data
  call ncmpi_inq_varid(ncid, "pressure", varid, status)
  call ncmpi_get_vara_float(ncid, varid, [my_rank * num_rows/num_procs + 1, 1], [num_rows/num_procs, num_cols], data, status)
  
  ! Process-specific computations using the data
  
  ! Finalize Parallel NetCDF
  call ncmpi_close(ncid, status)
end program data_partitioning

In this example, the 2D array is divided among the processes using block-cyclic distribution. Each process reads a portion of the "pressure" variable from the NetCDF file and performs process-specific computations on the retrieved data.

Support for NetCDF-4 Format

Parallel NetCDF supports the NetCDF-4 format, which provides additional features such as compression, chunking, and parallel I/O capabilities. The NetCDF-4 format allows for more efficient storage and access of scientific data, especially in large-scale parallel applications.

To enable the use of the NetCDF-4 format in Parallel NetCDF, the NetCDF-4 library must be installed and linked during the compilation of the Fortran program.

Examples

Here are a few examples that demonstrate the usage of Parallel NetCDF Fortran framework:

Parallel Write Example

program parallel_write
  use parallel_netcdf
  integer :: ncid, varid, status
  integer, parameter :: num_procs = 4
  integer, parameter :: num_elements = 100
  real :: data(num_elements)
  
  ! Initialize Parallel NetCDF
  call ncmpi_create(MPI_COMM_WORLD, "data.nc", NC_CLOBBER, ncid, status)
  
  ! Define dimensions and variables
  call ncmpi_def_dim(ncid, "elements", num_procs * num_elements, dimid, status)
  call ncmpi_def_var(ncid, "temperature", NC_FLOAT, dimid, varid, status)
  
  ! Each process writes a portion of the data
  call ncmpi_put_vara_float(ncid, varid, [1, my_rank * num_elements + 1], [1, num_elements], data, status)
  
  ! Finalize Parallel NetCDF
  call ncmpi_close(ncid, status)
end program parallel_write

This example demonstrates how to write data to a NetCDF file in parallel. Each process writes a portion of the "temperature" variable using the ncmpi_put_vara_float function.

Parallel Collective Write Example

program parallel_collective_write
  use parallel_netcdf
  integer :: ncid, varid, status
  integer, parameter :: num_procs = 4
  integer, parameter :: num_elements = 100
  real :: data(num_elements)
  
  ! Initialize Parallel NetCDF
  call ncmpi_create(MPI_COMM_WORLD, "data.nc", NC_CLOBBER, ncid, status)
  
  ! Define dimensions and variables
  call ncmpi_def_dim(ncid, "elements", num_procs * num_elements, dimid, status)
  call ncmpi_def_var(ncid, "temperature", NC_FLOAT, dimid, varid, status)
  
  ! Each process writes a portion of the data collectively
  call ncmpi_begin_indep_data(ncid, status)
  call ncmpi_put_vara_float_all(ncid, varid, [1, my_rank * num_elements + 1], [1, num_elements], data, status)
  call ncmpi_end_indep_data(ncid, status)
  
  ! Finalize Parallel NetCDF
  call ncmpi_close(ncid, status)
end program parallel_collective_write

This example demonstrates how to perform a collective write operation using the ncmpi_put_vara_float_all function. The ncmpi_begin_indep_data and ncmpi_end_indep_data functions are used to enclose the independent write operation within the collective operation.

Parallel Read-Write Example

program parallel_read_write
  use parallel_netcdf
  integer :: ncid, varid, status
  integer, parameter :: num_procs = 4
  integer, parameter :: num_elements = 100
  real :: read_data(num_elements), write_data(num_elements)
  
  ! Initialize Parallel NetCDF
  call ncmpi_open(MPI_COMM_WORLD, "data.nc", NC_RDWR, ncid, status)
  
  ! Each process reads a portion of the data
  call ncmpi_inq_varid(ncid, "temperature", varid, status)
  call ncmpi_get_vara_float(ncid, varid, [1, my_rank * num_elements + 1], [1, num_elements], read_data, status)
  
  ! Each process performs computations on the read data
  write_data = read_data * 2.0
  
  ! Each process writes the computed data back to the file
  call ncmpi_put_vara_float(ncid, varid, [1, my_rank * num_elements + 1], [1, num_elements], write_data, status)
  
  ! Finalize Parallel NetCDF
  call ncmpi_close(ncid, status)
end program parallel_read_write

This example demonstrates how to perform both read and write operations in parallel. Each process reads a portion of the "temperature" variable, performs computations on the read data, and writes the computed data back to the NetCDF file.

Official Documentation

For further information and detailed documentation on the Parallel NetCDF Fortran framework, you can visit the official website: https://trac.mcs.anl.gov/projects/parallel-netcdf

Parallel NetCDF provides a powerful and efficient solution for parallel I/O operations on NetCDF files. Its support for parallel I/O, data partitioning techniques, and compatibility with the NetCDF-4 format make it an excellent choice for scientific applications requiring high-performance access to distributed data.

History​

Features​

Parallel I/O Operations​

Data Partitioning​

Support for NetCDF-4 Format​

Examples​

Official Documentation​