Ytukyg

I have a following code inside a for loop

    dataInt = _mm_loadu_si128((__m128i *) (&x[i]));

    __m256i val_unpacked = _mm256_cvtepi16_epi32(dataInt);

    __m256 converted = _mm256_cvtepi32_ps(val_unpacked);



    converted = _mm256_div_ps(converted, _mm256_set1_ps(max_val));



    _mm256_storeu_ps(&y[i], converted);

    _mm256_zeroupper();

It basically just converts vector of int16 to floats in range [-1,1] (max_val is const variable and equal to numeric_limit::max).

I'm using mingw compiler with posix thread version 7.2

When I compile the program without optimisation, it runs just fine, but when I turn on optimisation (I do not have control over the individual optimisations, it is inside a project I am working on, but it should be using lvl of optimisation -O3 ), I start to get wrong results.

The problem is in the zeroupper instruction. When I remove it in mode with optimisations, it again gives correct results.

Seemingly the optimisation does not respect the placement of the zeroupper instruction and calls it somewhere in the middle of the loop and not at the very end, thus discarding useful data. Is something like that possible? I could not find any discussion regarding this topic on the internet.

EDIT: I extracted the code. It looks like this:

#include <iostream>

#include <limits>

#include <immintrin.h>

#include <xmmintrin.h>  

 int  __attribute__ ((__target__ ("avx2,sse4.2"))) main(){



/*volatile*/ float max_val = static_cast<float> (std::numeric_limits<int16_t>::max());



__m128i dataInt;

int runs = 32;

int16_t source[32];

float target[32];

int i = 0;

for (; i < 32; ++i) {

    source[i] = std::numeric_limits<int16_t>::min()+i;

}



i=0;

for (; i < runs; i += 8) {

    // _mm256_zeroupper();



     dataInt = _mm_loadu_si128((__m128i *) (&source[i]));



      __m256i val_unpacked =_mm256_cvtepi16_epi32(dataInt);

    __m256 converted =  _mm256_cvtepi32_ps(val_unpacked);



    __m256 maxVinFloat = _mm256_set1_ps(max_val);

    converted = _mm256_div_ps(converted, maxVinFloat);



    _mm256_storeu_ps(&target[i], converted);

    _mm256_zeroupper();

}

i = 0;

for (; i < 32; ++i) {

    std::cout << target [ i ] <<"  ";

}}

However when compiled on online compilers, the output is fine, even when using lvl 3 optimisation. But my Clion using compiler described in my original post outputs several infinities, because the register maxVinFloat with max values is composed of zeroes in one half of the register. So,it seems the register is optimised to be initialised only once and other iterations of the cycle output infinities.

EDIT2: My mistake, it does output infinities on online compilers, but I forgot to remove the volatile part (that fixes the problem) when testing it, just run that code
here https://www.tutorialspoint.com/compile_cpp_online.php with -O2 optimisation