{"id":24801,"date":"2019-08-08T18:34:23","date_gmt":"2019-08-08T18:34:23","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/cppblog\/?p=24801"},"modified":"2019-08-08T18:34:23","modified_gmt":"2019-08-08T18:34:23","slug":"game-performance-improvements-in-visual-studio-2019-version-16-2","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/game-performance-improvements-in-visual-studio-2019-version-16-2\/","title":{"rendered":"Game performance improvements in Visual Studio 2019 version 16.2"},"content":{"rendered":"

This spring Gratian Lup described in his blog post the improvements for C++ game development in Visual Studio 2019<\/a>. From Visual Studio 2019 version 16.0 to Visual Studio 2019 version 16.2 we\u2019ve made some more improvements. On the Infiltrator Demo<\/a> we\u2019ve got 2\u20133% performance wins for the most CPU-intensive parts of the game.<\/p>\n

Throughput<\/h2>\n

A huge throughput improvement was done in the linker! Check our recent blogpost on Improved Linker Fundamentals in Visual Studio 2019<\/a>.<\/p>\n

New Optimizations<\/h2>\n

A comprehensive list of new and improved C++ compiler optimizations can be found in a recent blogpost on MSVC Backend Updates in Visual Studio 2019 version 16.2<\/a>. I\u2019ll talk in a bit more detail about some of them.<\/p>\n

All samples below are compiled for x64 with these switches: \/arch:AVX2 \/O2 \/fp:fast \/c \/Fa.<\/p>\n

Vectorizing tiny perfect reduction loops on AVX<\/h2>\n

This is a common pattern for making sure that two vectors didn\u2019t diverge too much:<\/p>\n

#include <xmmintrin.h>\r\n#include <DirectXMath.h>\r\nuint32_t TestVectorsEqual(float* Vec0, float* Vec1, float Tolerance = 1e7f)\r\n{\r\n    float sum = 0.f;\r\n    for (int32_t Component = 0; Component < 4; Component++)\r\n    {\r\n        float Diff = Vec0[Component] - Vec1[Component];\r\n        sum += (Diff >= 0.0f) ? Diff : -Diff;\r\n    }\r\n    return (sum <= Tolerance) ? 1 : 0;\r\n}<\/pre>\n
For version 16.2 we tweaked the vectorization heuristics for the AVX architecture to better utilize the hardware capabilities. The disassembly is for x64, AVX2, old code on the left, new on the right:<\/p>\n
\"Comparison<\/p>\n
Visual Studio 2019 version 16.0 recognized the loop as a reduction loop, didn\u2019t vectorize it, but unrolled it completely. Version 16.2 also recognized the loop as a reduction loop, vectorized it (due to the heuristics change), and used horizontal add instructions to get the sum. As a result the code is much shorter and faster now.<\/p>\n
Recognition of intrinsics working on a single vector element<\/h2>\n
The compiler now does a better job at optimizing vector intrinsics working on the lowest single element (those with ss\/sd suffix).<\/p>\n
A good example for the improved code is the inverse square root. This function is taken from the Unreal Engine math library (with comments removed for brevity). It\u2019s used all over the games based on Unreal Engine for rendering objects:<\/p>\n
#include <xmmintrin.h>\r\n#include <DirectXMath.h>\r\nfloat InvSqrt(float F)\r\n{\r\n    const __m128 fOneHalf = _mm_set_ss(0.5f);\r\n    __m128 Y0, X0, X1, X2, FOver2;\r\n    float temp;\r\n    Y0 = _mm_set_ss(F);\r\n    X0 = _mm_rsqrt_ss(Y0);\r\n    FOver2 = _mm_mul_ss(Y0, fOneHalf);\r\n    X1 = _mm_mul_ss(X0, X0);\r\n    X1 = _mm_sub_ss(fOneHalf, _mm_mul_ss(FOver2, X1));\r\n    X1 = _mm_add_ss(X0, _mm_mul_ss(X0, X1));\r\n    X2 = _mm_mul_ss(X1, X1);\r\n    X2 = _mm_sub_ss(fOneHalf, _mm_mul_ss(FOver2, X2));\r\n    X2 = _mm_add_ss(X1, _mm_mul_ss(X1, X2));\r\n    _mm_store_ss(&temp, X2);\r\n    return temp;\r\n}<\/pre>\n
Again, x64, AVX2, old code on the left, new on the right:<\/p>\n
\"Comparison<\/p>\n
Visual Studio 2019 version 16.0 generated code for all intrinsics one by one. Version 16.2 now understands the meaning of the intrinsics better and is able to combine multiply\/add intrinsics into FMA instructions. There are still improvements to be made in this area and some are targeted for version 16.3\/16.4.<\/p>\n
Even now, if given a const argument, this code will be completely constant-folded:<\/p>\n
float ReturnInvSqrt()\r\n{\r\n    return InvSqrt(4.0);\r\n}<\/pre>\n
\"Comparison<\/p>\n
Again, Visual Studio 2019 version 16.0 here generated code for all intrinsics, one by one. Version 16.2 was able to calculate the value at compile time. (This is done with \/fp:fast switch only).<\/p>\n
More FMA patterns<\/h2>\n
The compiler now generates FMA in more cases:<\/p>\n
(fma a, b, (c * d)) + x -> fma a, b, (fma c, d, x)\nx + (fma a, b, (c * d)) -> fma a, b, (fma c, d, x)<\/p>\n
(a+1) * b -> fma a, b, b\n(a+ (-1)) * b -> fma a, b, (-b)\n(a – 1) * b -> fma a, b, (-b)\n(a – (-1)) * b -> fma a, b, b\n(1 – a) * b -> fma (-a), b, b\n(-1 – a) * b -> fma (-a), b, -b<\/p>\n
It also does more FMA simplifications:<\/p>\n
fma a, c1, (a * c2) -> fmul a * (c1+c2)\nfma (a * c1), c2, b -> fma a, c1*c2, b\nfma a, 1, b -> a + b\nfma a, -1, b -> (-a) + b -> b – a\nfma -a, c, b -> fma a, -c, b\nfma a, c, a -> a * (c+1)\nfma a, c, (-a) -> a * (c-1)<\/p>\n
Previously FMA generation worked only with local vectors. It was improved to work on globals too.<\/p>\n
Here is an example of the optimization at work:<\/p>\n
#include <xmmintrin.h>\r\n__m128 Sample(__m128 A, __m128 B)\r\n{\r\n    const __m128 fMinusOne = _mm_set_ps1(-1.0f);\r\n    __m128 X;\r\n    X = _mm_sub_ps(A, fMinusOne);\r\n    X = _mm_mul_ps(X, B);\r\n    return X;\r\n}<\/pre>\n
Old code on the left, new on the right:<\/p>\n
\"Comparison<\/p>\n
FMA is shorter and faster, and the constant is completely gone and will not occupy space.<\/p>\n
Another sample:<\/p>\n
#include <xmmintrin.h>\r\n__m128 Sample2(__m128 A, __m128 B)\r\n{\r\n    __m128 C1 = _mm_set_ps(3.0, 3.0, 2.0, 1.0);\r\n    __m128 C2 = _mm_set_ps(4.0, 4.0, 3.0, 2.0);\r\n    __m128 X = _mm_mul_ps(A, C1);\r\n    X = _mm_fmadd_ps(X, C2, B);\r\n    return X;\r\n}<\/pre>\n
Old code on the left, new on the right:<\/p>\n
\"Comparison<\/p>\n
Version 16.2 is doing this simplification:<\/p>\n
fma (a * c1), c2, b -> fma a, c1*c2, b<\/p>\n
Constants are now extracted and multiplied at compile time.<\/p>\n
Memset and initialization<\/h2>\n
Memset code generation was improved by calling the faster CRT version where appropriate instead of expanding its definition inline. Loops that store a constant value that is formed of the same byte (e.g. 0xABABABAB) now also use the CRT version of memset.\u00a0Compared with na\u00efve code generation, calling memset is at least 2x faster on SSE2, and even faster on AVX2.<\/p>\n
Inlining<\/h2>\n
We\u2019ve done more tweaks to the inlining heuristics. They were modified to do more aggressive inlining of small functions containing control flow.<\/p>\n
Improvements in Unreal Engine \u2013 Infiltrator Demo<\/h2>\n
The new optimizations pay off.<\/p>\n
We ran the Infiltrator Demo<\/a> again (see the blogpost about C++ game development in Visual Studio 2019<\/a> for a description of the demo and testing methodology). Short reminder: Infiltrator Demo is based on Unreal Engine and is a nice approximation of a real game. Game performance is measured here by frame time: the smaller, the better (opposite metric would be frames per second). Testing was done similarly to the previous test run, the only difference is the new hardware: this time we ran it on AMD Zen 2 newest processor.<\/p>\n
Test PC configuration:<\/p>\n