How to generate simd code for math function "exp" using openmp?

Question

I am having a simple c code as follows

void calculate_exp(float *out, float *in, int size) {
    for(int i = 0; i < size; i++) {
        out[i] = exp(in[i]);
    }
}

I wanted to optimize it using open-mp simd. I am new to open-mp and used few pragma's like 'omp simd', 'omp simd safelen' etc. But I am unable to generate the simd code. Can anybody help ?

Answer 1

You can use one of the following four alternatives to vectorize the exp function. Note that I have used expf (float) instead of exp, which is a double function. This Godbolt link shows that these functions are vectorized: Search for call _ZGVdN8v___expf_finite in the compiler generated code.

#include<math.h>

int exp_vect_a(float* x, float* y, int N) {
    /* Inform the compiler that N is a multiple of 8, this leads to shorter code */
    N = N & 0xFFFFFFF8;    
    x = (float*)__builtin_assume_aligned(x, 32); /* gcc 8.2 doesn't need aligned x and y  to generate `nice` code */
    y = (float*)__builtin_assume_aligned(y, 32); /* with gcc 7.3 it improves the generated code                   */
    #pragma omp simd             
    for(int i=0; i<N; i++) y[i] = expf(x[i]);
    return 0; 
}


int exp_vect_b(float* restrict x, float* restrict y, int N) {
    N = N & 0xFFFFFFF8;
    x = (float*)__builtin_assume_aligned(x, 32); /* gcc 8.2 doesn't need aligned x and y  to generate `nice` code */
    y = (float*)__builtin_assume_aligned(y, 32); /* with gcc 7.3 it improves the generated code                   */
    for(int i=0; i<N; i++) y[i] = expf(x[i]);
    return 0; 
}

/* This also vectorizes, but it doesn't lead to `nice` code */
int exp_vect_c(float* restrict x, float* restrict y, int N) {
    for(int i=0; i<N; i++) y[i] = expf(x[i]);
    return 0; 
}

/* This also vectorizes, but it doesn't lead to `nice` code */
int exp_vect_d(float* x, float* y, int N) {
    #pragma omp simd             
    for(int i=0; i<N; i++) y[i] = expf(x[i]);
    return 0; 
}

Note that Peter Cordes' comment is very relevant here: Function _ZGVdN8v___expf_finite might give slightly different results than expf because its focus is on speed, and not on special cases such as inputs which are infinite, subnormal, or not a number. Moreover, the accuracy is 4-ulp maximum relative error, which is probably slightly less accurate than the standard expf function. Therefore you need optimization level -Ofast (which allows less accurate code) instead of -O3 to get the code vectorized with gcc.

See this libmvec page for futher details.

The following test code compiles and runs successfully with gcc 7.3:

#include <math.h>
#include <stdio.h>
/* gcc expv.c -m64 -Ofast -std=c99 -march=skylake -fopenmp -lm */

int exp_vect_d(float* x, float* y, int N) {
    #pragma omp simd             
    for(int i=0; i<N; i++) y[i] = expf(x[i]);
    return 0; 
}

int main(){
    float x[32];
    float y[32];
    int i;
    int N = 32;

    for(i = 0; i < N; i++) x[i] = i/100.0f;
    x[10]=-89.0f;            /* exp(-89.0f)=2.227e-39 which is a subnormal number */
    x[11]=-1000.0f;          /* output: 0.0                                   */
    x[12]=1000.0f;           /* output: Inf.                                  */
    x[13]=0.0f/0.0f;         /* input: NaN: Not a number                      */
    x[14]=1e20f*1e20f;       /* input: Infinity                               */
    x[15]=-1e20f*1e20f;      /* input: -Infinity                              */
    x[16]=2.3025850929940f;  /* exp(2.3025850929940f)=10.0...                 */
    exp_vect_d(x, y, N);
    for(i = 0; i < N; i++) printf("x=%11.8e,  y=%11.8e\n", x[i], y[i]);
    return 0;
}