{"id":32720,"date":"2023-11-17T17:06:32","date_gmt":"2023-11-17T17:06:32","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/cppblog\/?p=32720"},"modified":"2023-11-17T17:06:32","modified_gmt":"2023-11-17T17:06:32","slug":"functions-view-for-build-insights-in-visual-studio-2022-17-8","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/functions-view-for-build-insights-in-visual-studio-2022-17-8\/","title":{"rendered":"Functions View for Build Insights in Visual Studio 2022 17.8"},"content":{"rendered":"

Introduction<\/strong><\/h3>\n

We are excited to unveil a new feature in Build Insights for Visual Studio: Functions View! This feature is available in Visual Studio 2022 version 17.8. Functions View offers essential insights into functions and forceinlines within your codebases.<\/p>\n

Download Visual Studio 2022 17.8<\/a><\/p>\n

We extend our sincere thanks thanks to the developer community, especially our game studio partners, for actively providing feedback. Your contributions are invaluable in shaping this new feature.<\/p>\n

For more details about Build Insights and to explore other features like Included Files and Include Tree Views, please visit our initial announcement blogpost<\/a>.<\/p>\n

Code Generation Insights with Functions View<\/strong><\/h3>\n

Functions View is a powerful tool that displays the impact of each function on the total build time by analyzing code generation times and forceinlines. Forceinlines, commonly used to boost runtime efficiency, can also influence build times.<\/p>\n

The following sample code is based on a public code sample by Aras Pranckevi\u010dius<\/a>. We will use it to show you how you can optimize your builds with <\/span>Functions View. To setup your project, create a C++ Console application and copy the following sample code:<\/span><\/p>\n

#include <emmintrin.h>\r\n\r\n\r\nstruct float4\r\n{\r\n    __m128 val;\r\n    float4() { val = _mm_setzero_ps(); }\r\n    float4(float x) { val = _mm_set1_ps(x); }\r\n    float4(float x, float y) { val = _mm_set_ps(y, x, y, x); }\r\n    float4(float x, float y, float z) { val = _mm_set_ps(0.f, z, y, x); }\r\n    float4(float x, float y, float z, float w) { val = _mm_set_ps(w, z, y, x); }\r\n    float4(__m128 v) { val = v; }\r\n};\r\n\r\n\r\nstatic __forceinline float4 operator+(const float4& a, const float4& b) { return float4(_mm_add_ps(a.val, b.val)); }\r\nstatic __forceinline float4 operator-(const float4& a, const float4& b) { return float4(_mm_sub_ps(a.val, b.val)); }\r\nstatic __forceinline float4 operator*(const float4& a, const float4& b) { return float4(_mm_mul_ps(a.val, b.val)); }\r\nstatic __forceinline float4 operator\/(const float4& a, const float4& b) { return float4(_mm_div_ps(a.val, b.val)); }\r\nstatic __forceinline float4 csum(const float4& p)\r\n{\r\n    __m128 r = _mm_add_ps(p.val, _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(p.val), _MM_SHUFFLE(0, 3, 2, 1))));\r\n    return _mm_add_ps(r, _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(r), _MM_SHUFFLE(1, 0, 3, 2))));\r\n}\r\nstatic __forceinline float4 dot(const float4& p0, const float4& p1) { return csum(p0 * p1); }\r\nstatic __forceinline float4 dot(const float4& p) { return dot(p, p); }\r\nstatic __forceinline float4 rsqrt(const float4& x)\r\n{\r\n#define C0  9.999998e-01f\r\n#define C1  3.0000002e+00f\r\n#define C2  .5f\r\n#define C3  340282346638528859811704183484516925440.f\r\n    __m128 e = _mm_mul_ps(_mm_rsqrt_ps((__m128) x.val), _mm_set_ps(C0, C0, C0, C0));\r\n    e = _mm_min_ps(e, _mm_set_ps(C3, C3, C3, C3));\r\n    return _mm_mul_ps(_mm_mul_ps(e, _mm_set_ps(C2, C2, C2, C2)), _mm_sub_ps(_mm_set_ps(C1, C1, C1, C1), _mm_mul_ps(_mm_mul_ps(x.val, e), e)));\r\n}\r\nstatic __forceinline float4 normalize(const float4& v)\r\n{\r\n    return v * rsqrt(dot(v));\r\n}\r\n\r\nstatic __forceinline float4 ident() { return float4(0.f, 0.f, 0.f, 1.f); }\r\nstatic __forceinline float4 sampleFun1(const float4& x, const float4& y)\r\n{\r\n    return csum(x) \/ x + y;\r\n}\r\nstatic __forceinline float4 sampleFun2(const float4& q1, const float4& q2)\r\n{\r\n    return sampleFun1(q1 * q2, q2 - q1) * (q1 + q2);\r\n}\r\nstatic float4 sampleFun3(const float4& pq, const float4& mask)\r\n{\r\n    const float c8 = 0.923879532511287f;\r\n    const float s8 = 0.38268343236509f;\r\n    const float g = 5.82842712474619f;\r\n\r\n\r\n    float4 ch = float4(2) * (normalize(pq) - normalize(mask));\r\n    float4 sh = pq * normalize(ch);\r\n    float4 r = ((g * sh * sh - ch * ch) + sh \/ float4(s8, s8, s8, c8)) * mask;\r\n    return normalize(r);\r\n}\r\nstruct matrix\r\n{\r\n    float4 m0, m1, m2;\r\n};\r\nstatic __forceinline float4 sampleFunIteration(matrix& s, int count = 5)\r\n{\r\n    matrix qm;\r\n    float4 q, v = ident();\r\n    for (int iter = 0; iter < count; iter++)\r\n    {\r\n        q = sampleFun3(s.m0, float4(0, 0, 1, 1));\r\n        v = sampleFun2(v, q);\r\n        v = normalize(v);\r\n        q = sampleFun3(s.m1, float4(1, 0, 0, 1));\r\n        v = sampleFun2(v, q);\r\n        v = normalize(v);\r\n        q = sampleFun3(s.m2, float4(0, 1, 0, 1));\r\n        v = sampleFun2(v, q);\r\n        v = normalize(v);\r\n    }\r\n    return v;\r\n}\r\n\r\n\r\nstatic __forceinline float4 sampleFunDecomposition(const matrix& a, const float4& u, const float4& v)\r\n{\r\n    float4 r;\r\n    matrix s = a;\r\n    s.m0 = normalize(s.m0) + u;\r\n    s.m1 = normalize(s.m1) * v;\r\n    s.m2 = normalize(s.m2);\r\n    r = sampleFunIteration(s);\r\n    r = normalize(v) * u + (normalize(u) \/ v);\r\n    s.m0 = s.m0 + r;\r\n    s.m1 = s.m1 + r;\r\n    s.m2 = s.m2 + r;\r\n    r = sampleFunIteration(s);\r\n    s.m0 = s.m0 \/ normalize(r);\r\n    s.m1 = s.m1 \/ normalize(v + r);\r\n    s.m2 = s.m2 \/ normalize(v * r);\r\n    r = sampleFunIteration(s);\r\n    s.m0 = s.m0 * s.m1;\r\n    s.m1 = s.m1 * s.m2 - r;\r\n    s.m2 = s.m2 * s.m0 + r;\r\n    r = sampleFunIteration(s);\r\n\r\n\r\n    return r;\r\n}\r\n\r\n\r\nint main(int argc, const char** argv)\r\n{\r\n    matrix a;\r\n    a.m0 = (float)argv[0][0];\r\n    a.m1 = (float)argc;\r\n    a.m2 = (float)(argv[0][0] - argc);\r\n\r\n\r\n    float4 u = a.m0;\r\n    float4 v = a.m1;\r\n    float4 e = sampleFunDecomposition(a, a.m0, a.m1);\r\n    e = e + sampleFunDecomposition(a, a.m2, normalize(a.m1));\r\n    e = e + sampleFunDecomposition(a, normalize(a.m2), e);\r\n    e = e + sampleFunDecomposition(a, e, e);\r\n    e = e + sampleFunDecomposition(a, normalize(e), normalize(e));\r\n    e = e * sampleFunDecomposition(a, e, e);\r\n    e = e - sampleFunDecomposition(a, e, e);\r\n    e = e * sampleFunDecomposition(a, e, e);\r\n    e = e + sampleFunDecomposition(a, e, e);\r\n    float4 r = normalize(e);\r\n\r\n\r\n    return (int)_mm_cvtss_f32(r.val);\r\n}<\/code><\/pre>\n
<\/code><\/h3>\n
 <\/p>\n
Before running the sample code, ensure the functions will be forceinlined:<\/p>\n
    \n
  1. Right-click on the project in the solution explorer to open the context menu.<\/li>\n
  2. Select project properties.<\/li>\n
  3. In the Project Property Pages, navigate to C\/C++ > Optimization.<\/li>\n
  4. Under Optimization, select “Maximum Optimization (Favor Speed) (\/Ox)”<\/li>\n
  5. Click OK, then choose Release as the configuration.<\/li>\n<\/ol>\n
    Finally, under the Build Menu, select Run Build Insights on Solution > Build<\/strong>. The following is the report generated by Build Insights:<\/p>\n
    \"Functions<\/a><\/p>\n
     <\/p>\n
    The total build time is 7.342 seconds. The main function includes 8 instances of the forceinlinedsampleFunDecomposition()<\/code>\u00a0function, significantly contributing to the main function’s size.<\/p>\n
    To mitigate the build time impact, remove the __forceinline<\/code> from the sampleFunDecomposition()<\/code>\u00a0function and observe the effect on build time.<\/p>\n
    static float4 sampleFunDecomposition(const matrix& a, const float4& u, const float4& v)\r\n{\r\n    float4 r;\r\n    matrix s = a;\r\n    s.m0 = normalize(s.m0) + u;\r\n    s.m1 = normalize(s.m1) * v;\r\n    s.m2 = normalize(s.m2);\r\n    r = sampleFunIteration(s);\r\n    r = normalize(v) * u + (normalize(u) \/ v);\r\n    s.m0 = s.m0 + r;\r\n    s.m1 = s.m1 + r;\r\n    s.m2 = s.m2 + r;\r\n    r = sampleFunIteration(s);\r\n    s.m0 = s.m0 \/ normalize(r);\r\n    s.m1 = s.m1 \/ normalize(v + r);\r\n    s.m2 = s.m2 \/ normalize(v * r);\r\n    r = sampleFunIteration(s);\r\n    s.m0 = s.m0 * s.m1;\r\n    s.m1 = s.m1 * s.m2 - r;\r\n    s.m2 = s.m2 * s.m0 + r;\r\n    r = sampleFunIteration(s);\r\n\r\n\r\n    return r;\r\n}<\/code><\/pre>\n
    Then, run Build Insights again. The following are the results we got:<\/p>\n
    \"Build<\/a><\/p>\n
    By merely removing the __forceinline<\/code> from sampleFunDecomposition()<\/code>, the build time went from 7.342 seconds to 0.251 seconds, which is a 97% reduction from the original!<\/p>\n
    Upcoming Updates<\/strong><\/h3>\n
    We are rapidly iterating to deliver more value to you. Anticipate the following in our next release:<\/p>\n