PLASMA Overview

Introduction to PLASMA Fortran Framework

PLASMA (Parallel Linear Algebra for Scalable Multi-core Architectures) is a high-performance computing (HPC) framework that provides efficient implementations of linear algebra operations on multi-core architectures. It is specifically designed to exploit the parallelism and performance potential of modern multi-core processors.

In this tutorial, we will explore the history, features, and examples of the PLASMA Fortran framework. We will delve into the various features of PLASMA with code snippets and explain their output. Let's get started!

History of PLASMA

PLASMA was initially developed by researchers at the University of Tennessee, University of California, Berkeley, and the Oak Ridge National Laboratory. It was first released in 2009 and has since gained popularity in the HPC community.

The PLASMA project was motivated by the need for scalable and efficient linear algebra operations on modern multi-core architectures. Traditional sequential algorithms were not able to fully leverage the potential of these architectures, leading to suboptimal performance. PLASMA aimed to bridge this gap by providing a framework that allows efficient parallelization of linear algebra operations.

Features of PLASMA

PLASMA offers a range of features that enable efficient parallelization and execution of linear algebra operations. Some of its key features include:

Task-based Parallelism: PLASMA decomposes large linear algebra operations into smaller tasks that can be executed in parallel. This allows for efficient utilization of multi-core processors.
```
! Example: LU factorization using PLASMA
call plasma_dgetrf(n, n, A, lda, ipiv, info)
```
In the above code snippet, plasma_dgetrf is a PLASMA routine that performs LU factorization of matrix A. The operation is divided into smaller tasks that are executed in parallel, leading to improved performance.
Dynamic Scheduling: PLASMA dynamically schedules tasks based on the available computational resources. It takes into account the dependencies between tasks and ensures efficient utilization of the processor cores.
```
! Example: Cholesky factorization using PLASMA
call plasma_dpotrf(PlasmaUpper, n, A, lda, info)
```
The plasma_dpotrf routine performs Cholesky factorization of matrix A. PLASMA dynamically schedules the tasks involved in the factorization, considering the dependencies between them, to optimize the execution.
Parallel Data Distribution: PLASMA efficiently distributes the data across the processor cores, ensuring balanced workloads and minimizing data movement overhead.
```
! Example: Matrix multiplication using PLASMA
call plasma_dgemm(PlasmaNoTrans, PlasmaNoTrans, n, n, n, 1.0, A, lda, B, ldb, 0.0, C, ldc)
```
The plasma_dgemm routine performs matrix multiplication of matrices A and B and stores the result in matrix C. PLASMA automatically distributes the data across the cores, allowing for efficient parallel execution of the multiplication.
Support for Various Linear Algebra Operations: PLASMA provides a wide range of routines for common linear algebra operations such as matrix factorizations, matrix multiplications, eigenvalue problems, and least squares solutions.
```
! Example: Eigenvalue problem using PLASMA
call plasma_dsyev(PlasmaVec, PlasmaUpper, n, A, lda, w, work, lwork, info)
```
The plasma_dsyev routine computes the eigenvalues and eigenvectors of a symmetric matrix A. PLASMA efficiently parallelizes the computation, providing significant speedup for large matrices.
Compatibility with BLAS and LAPACK: PLASMA is designed to be compatible with the BLAS (Basic Linear Algebra Subprograms) and LAPACK (Linear Algebra Package) libraries. This allows users to seamlessly integrate PLASMA with existing codebases and leverage its parallel computing capabilities.

For more detailed information on PLASMA, you can visit the official website: PLASMA Fortran Framework

Examples of PLASMA Fortran Framework

Let's explore a few examples to understand how PLASMA can be used to perform common linear algebra operations efficiently.

Example 1: LU Factorization

program lu_factorization_example
  implicit none

  integer, parameter :: n = 1000
  integer :: info
  integer :: ipiv(n)
  real(kind=8) :: A(n, n)

  ! Initialize matrix A

  ! Perform LU factorization using PLASMA
  call plasma_dgetrf(n, n, A, n, ipiv, info)

  ! Check the value of info to ensure successful factorization

end program lu_factorization_example

In this example, we perform LU factorization of a square matrix A using the plasma_dgetrf routine. The result of the factorization is stored in matrix A itself, and the pivot indices are stored in the ipiv array. The info variable indicates the success or failure of the factorization.

Example 2: Matrix Multiplication

program matrix_multiplication_example
  implicit none

  integer, parameter :: n = 1000
  real(kind=8) :: A(n, n), B(n, n), C(n, n)

  ! Initialize matrices A and B

  ! Perform matrix multiplication using PLASMA
  call plasma_dgemm(PlasmaNoTrans, PlasmaNoTrans, n, n, n, 1.0, A, n, B, n, 0.0, C, n)

  ! Use the result matrix C

end program matrix_multiplication_example

In this example, we compute the matrix product of matrices A and B using the plasma_dgemm routine. The result is stored in matrix C. The PlasmaNoTrans arguments indicate that the matrices are used as-is without transposition.

Example 3: Eigenvalue Problem

program eigenvalue_problem_example
  implicit none

  integer, parameter :: n = 1000
  integer :: info
  real(kind=8) :: A(n, n), w(n), work(n*n)
  integer :: lwork = n*n

  ! Initialize symmetric matrix A

  ! Solve the eigenvalue problem using PLASMA
  call plasma_dsyev(PlasmaVec, PlasmaUpper, n, A, n, w, work, lwork, info)

  ! Use the eigenvalues and eigenvectors

end program eigenvalue_problem_example

In this example, we compute the eigenvalues and eigenvectors of a symmetric matrix A using the plasma_dsyev routine. The eigenvalues are stored in the w array, and the eigenvectors are stored in matrix A. The PlasmaVec and PlasmaUpper arguments indicate that both eigenvalues and eigenvectors are computed, and the upper triangular part of A is used.

These examples showcase only a fraction of the capabilities of the PLASMA Fortran framework. By leveraging its features, you can efficiently parallelize and execute various linear algebra operations, leading to significant performance improvements on multi-core architectures.

This concludes our tutorial on the PLASMA Fortran framework. We hope you found it informative and useful for your parallel computing needs. Happy coding!

Note: Please refer to the official PLASMA documentation for detailed information and additional examples: PLASMA Fortran Framework

History of PLASMA​

Features of PLASMA​

Examples of PLASMA Fortran Framework​

Example 1: LU Factorization​

Example 2: Matrix Multiplication​

Example 3: Eigenvalue Problem​