3.4.1. Purpose and Benefits of Function Vectorization#

Function vectorization is particularly useful when you have a function that performs computations on individual elements of an array or on scalar values. By creating a SIMD version of the function, you can process multiple elements simultaneously, taking advantage of the SIMD instructions available on the target processor.

The benefits of function vectorization include:

1. Improved Performance: Function vectorization allows you to exploit the SIMD capabilities of the processor, enabling faster execution of the function on multiple data elements concurrently.

2. Code Reusability: With function vectorization, you can create a SIMD version of a function once and reuse it in multiple SIMD loops or contexts, promoting code reusability and maintainability.

3. Abstraction: Function vectorization provides an abstraction layer, allowing you to focus on the algorithmic aspects of the function while the compiler takes care of generating efficient SIMD code.

3.4.2. Using the declare simd Directive#

To enable function vectorization in OpenMP, you can use the declare simd directive. The declare simd directive is placed before the function declaration or definition to indicate that the function should be compiled for SIMD execution.

Here’s an example of using the declare simd directive in C/C++:

#pragma omp declare simd
float compute(float a, float b) {
    return a * b + a;
}

void vectorized_computation(float *a, float *b, float *c, int n) {
    #pragma omp simd
    for (int i = 0; i < n; i++) {
        c[i] = compute(a[i], b[i]);
    }
}

In this example, the compute function is declared with the declare simd directive, indicating that it should be compiled for SIMD execution. The vectorized_computation function contains a SIMD loop that calls the compute function for each iteration. The compiler generates a SIMD version of the compute function, allowing multiple elements to be processed concurrently.

Here’s the equivalent example in Fortran:

interface
    function compute(a, b) result(res)
        !$omp declare simd(compute)
        real, intent(in) :: a, b
        real :: res
    end function compute
end interface

subroutine vectorized_computation(a, b, c, n)
    real, dimension(:), intent(in) :: a, b
    real, dimension(:), intent(out) :: c
    integer, intent(in) :: n
    integer :: i

    !$omp simd
    do i = 1, n
        c(i) = compute(a(i), b(i))
    end do
    !$omp end simd
end subroutine vectorized_computation

3.4.3. Example: SIMD-enabled Math Functions#

Function vectorization is particularly useful for implementing SIMD-enabled versions of common math functions. By creating SIMD versions of math functions, you can achieve significant performance improvements in numerical computations.

Here’s an example that demonstrates the creation and usage of SIMD-enabled math functions in C/C++:

#include <math.h>

#pragma omp declare simd
float simd_sqrt(float x) {
    return sqrt(x);
}

#pragma omp declare simd
float simd_exp(float x) {
    return exp(x);
}

void compute_values(float *a, float *b, int n) {
    #pragma omp simd
    for (int i = 0; i < n; i++) {
        a[i] = simd_sqrt(a[i]);
        b[i] = simd_exp(b[i]);
    }
}

In this example, the simd_sqrt and simd_exp functions are declared with the declare simd directive, indicating that they should be compiled for SIMD execution. These functions are SIMD-enabled versions of the standard sqrt and exp functions from the math.h library.

The compute_values function contains a SIMD loop that calls the simd_sqrt and simd_exp functions for each iteration. The compiler generates SIMD versions of these functions, allowing multiple elements to be processed concurrently.

By leveraging function vectorization, you can create SIMD-enabled versions of frequently used functions and achieve better performance in SIMD loops that utilize these functions.

3.4.4. Conclusion#

Function vectorization using the declare simd directive is a powerful tool for creating SIMD-enabled versions of functions in OpenMP. By vectorizing functions, you can take advantage of the SIMD capabilities of the processor and achieve significant performance improvements in computationally intensive tasks.

When combined with loop vectorization using the simd directive, function vectorization allows you to write efficient and high-performing SIMD code in OpenMP.

In the next section, we will discuss data alignment and the aligned and linear clauses, which are important for optimal SIMD performance.