Unexpected long time to multiply a buffer by a value.

[ErikH]

Hi,

For a project I encountered an unexpected long time to multiply a buffer by a value in the form of:

d++ = *s++ * f;

The problem is that it takes 50 times longer to finish when d and s are the same. If I replace the multiplication by an addition that difference disappears. If I add the result to the multiplication the difference also disappears.

I've tested this using both gcc and clang with the same result. Testing it on another CPU architecture doesn't show this behavior.

The test code can be found here:

https://www.adalin.com/downloads/t.c

I'm lost on what could cause this other than maybe a CPU firmware bug?

Erik

[Steven_Intel]

Hello ErikH,

Thank you for posting on the Intel® communities.

In order to better assist you, could you please confirm the model of the Intel processor where you found this behavior?

Best regards,

Steven G.

Intel Customer Support Technician.

[ErikH]

Hi Steven,

I first encountered it on a Core i7-4790K but got it confirmed on a Core i3-370M

I hope that helps.

Erik

[ErikH]

And a friend of mine tested it on a Core i5-8350U with the same results.

Erik

[Steven_Intel]

Thank you for your response.

I will research about this. As soon as I have an update, I will let you know.

Best regards,

Steven G.

Intel Customer Support Technician.

[ErikH]

Thanks.

Erik

[Steven_Intel]

Hello ErikH,

After researching about this, our best recommendation is to go to our Developer Zone to find documentation and further support for this. You may also create a new community post there.

Developer Zone: https://www.intel.com/content/www/us/en/developer/overview.html#gs.fqciyu

Developer Forums: https://community.intel.com/t5/Developer-Software-Forums/ct-p/developer-software-forums

Please keep in mind that this thread will no longer be monitored by Intel. Thank you for your understanding.  

Best regards,

Steven G.

Intel Customer Support Technician.

[ErikH]

Could you explain to me how calling the exact same function, once with both pointers pointing to the same buffer and ones with both pointers pointing to different buffers, having a different result is a compiler problem and not a hardware problem? Especially as this is a cross-compiler issue and ARM does not suffer the same issue. Unfortunately I don't have an AMD at hand but I bet it does not show the problem either.

Erik

[ErikH]

I got a bit further, the problem goes away when running gcc with the -ffast-math option.

For clang this does not make any difference.

This log file shows the results and the diff between the two assembler outputs (which is minimal).

 https://www.adalin.com/downloads/t.log

The difference is not really obvious to me, but is looks like it's only using different registers?

Here are the individual assembler outputs:

https://www.adalin.com/downloads/t-O3.asm

https://www.adalin.com/downloads/t-O3fast.asm

Erik

[ErikH]

I finally found the solution to this problem:

https://www.intel.com/content/www/us/en/docs/cpp-compiler/developer-guide-reference/2021-8/set-the-ftz-and-daz-flags.html