Nrthugu

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 ?

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.8en", x[i], y[i]);

    return 0;

}