{"id":25462,"date":"2020-02-04T18:10:26","date_gmt":"2020-02-04T18:10:26","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/cppblog\/?p=25462"},"modified":"2020-02-04T18:10:26","modified_gmt":"2020-02-04T18:10:26","slug":"jcc-erratum-mitigation-in-msvc","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/jcc-erratum-mitigation-in-msvc\/","title":{"rendered":"JCC Erratum Mitigation in MSVC"},"content":{"rendered":"

The content of this blog was provided by Gautham Beeraka from Intel Corporation.<\/i><\/p>\n

Intel recently announced Jump Conditional Code (JCC) Erratum<\/a> which can occur in some of its processors. The MSVC team has been working with Intel to provide a software fix in the compiler to mitigate the performance impact of the microcode update that prevents the erratum.<\/p>\n

Introduction<\/h2>\n

There are three things one should know about JCC erratum:<\/p>\n

    \n
  1. What the erratum is, if and how it affects you.<\/li>\n
  2. Microcode update which prevents the erratum, if you have it and its side effects.<\/li>\n
  3. MSVC compiler support to mitigate the side effects of the microcode update.<\/li>\n<\/ol>\n

    Each of these topics are explained below.<\/p>\n

    JCC Erratum<\/h3>\n

    The processors listed in Intel\u2019s white paper referenced above have an erratum which can occur under certain conditions that involve jump instructions overlaying a cache-line boundary. This erratum can result in unpredictable behavior for the software running on these processors. If your software runs on these processors, you are affected by this erratum.<\/p>\n

    Microcode Update<\/h3>\n

    Applying a microcode update (MCU) can prevent JCC erratum. The MCU works by preventing the jump instructions that overlay or end on 32-byte boundary as shown in the figure below from being cached in the decoded uop cache. The MCU affects conditional jumps, macro-fused conditional jumps, direct unconditional jump, indirect jump, direct\/indirect call and return.<\/p>\n

    \"Examples<\/p>\n

    The MCU will be distributed through Windows Update. We will update this blog once we have more information on the Windows Update. Note that the MCU is not specific to Windows and applies to other operating systems also.<\/p>\n

    Applying the MCU can regress performance of software running on the patched machines. Based on our measurements, we see an impact between 0-3%. The impact was higher on a few outlier microbenchmarks.<\/p>\n

    Software Mitigation in MSVC compiler<\/h3>\n

    To mitigate the performance impact, developers can build their code with the software fix enabled by \/QIntel-jcc-erratum<\/em><\/strong> switch in MSVC compiler. We observed that the performance regressions become negligible after rebuilding with this fix. The switch can increase code size which was about 3% based on our measurements.<\/p>\n

    How to enable the software mitigation?<\/h2>\n

    Starting from Visual Studio 2019 version 16.5 Preview 2, developers can apply the software mitigation for the performance impact of the MCU. To enable software mitigation for JCC erratum for your code, simply select \u201cYes\u201d under the \u201cCode Generation\u201d section of the project Property Pages:<\/p>\n

    \"Screenshot<\/p>\n

    A few undocumented compiler flags are also available to restrict the scope of the software mitigation as shown below. These flags can be useful to experiment with, but we are not committed to service them in future releases.<\/p>\n

      \n
    1. \/d2QIntel-jcc-erratum-partial<\/em><\/strong> – This applies the mitigation only inside loops in a function.<\/li>\n
    2. \/d2QIntel-jcc-erratum:<file.txt><\/em><\/strong> – This applies the mitigation only to functions specified within file.txt.<\/li>\n
    3. \/d2QIntel-jcc-erratum-partial:<file.txt><\/em><\/strong> – This applies the mitigation only to loops in the functions specified within file.txt.<\/li>\n<\/ol>\n

      The function names given in <file.txt> are the decorated function names as used by the compiler.<\/p>\n

      To enable these flags, add them to the \u201cAdditional Options\u201d under the \u201cCommand Line\u201d section of the project Property Pages:<\/p>\n

      \"Screenshot<\/p>\n

      All these switches work only in release builds and are incompatible with \/clr<\/a> switches. In the event multiple \/d2QIntel-jcc-erratum*<\/em> switches have been given, full processing (all branches) is favored over partial (loop branches only) processing. If any of the switches specifies a functions file, the processing is limited to just those functions.<\/p>\n

      What does the software mitigation do?<\/h2>\n

      The software mitigation in the compiler detects all affected jumps in the code (the jumps that overlay or end at 32-byte boundary) and aligns them to start at this boundary. This is done by adding benign segment override prefixes to the instructions before the jump. The size of the resultant instructions increases but is less than 15 bytes. In situations where prefixes cannot be added, NOPs are used. The example below shows how the compiler generates code when the mitigation is on and off.<\/p>\n

      Sample C++ code:<\/p>\n

      for (int i = 0; i < length; i++) {\r\n\t\tsum += arr[i] + c;\r\n}\r\n<\/pre>\n\n\n\n\n
      \n
      Code without \/QIntel-jcc-erratum<\/p>\n
      (\/O2 \/FAsc)<\/p>\n<\/td>\n
      		\n
      Code with \/QIntel-jcc-erratum<\/p>\n
      (\/O2 \/FAsc \/QIntel-jcc-erratum)<\/p>\n<\/td>\n<\/tr>\n
      $LL8@test1:<\/span><\/p>\n
      00010 44 8b 0c 91 \u00a0\u00a0 mov r9d, DWORD PTR [rcx+rdx*4]<\/span><\/p>\n
      00014 48 ff c2 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 inc rdx<\/span><\/p>\n
      00017 45 03 c8 \u00a0 \u00a0 \u00a0 \u00a0 add r9d, r8d<\/span><\/p>\n
      0001a 41 03 c1 \u00a0 \u00a0 \u00a0 \u00a0 add eax, r9d<\/span><\/p>\n
      0001d<\/span> 49 3b d2 \u00a0 \u00a0 \u00a0 \u00a0 cmp rdx, r10<\/span><\/p>\n
      00020<\/span> 7c ee \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0 jl SHORT $LL8@test1<\/span><\/td>\n
      		$LL8@test1:<\/span><\/p>\n
       00010 3e 3e 3e<\/span> 44 8b 0c 91 \u00a0\u00a0 mov\u00a0 r9d, DWORD PTR [rcx+rdx*4]<\/span><\/p>\n
       00017 48 ff c2 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0 inc\u00a0 rdx<\/span><\/p>\n
       0001a 45 03 c8 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0 add\u00a0 r9d, r8d<\/span><\/p>\n
       0001d 41 03 c1 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0 add\u00a0 eax, r9d<\/span><\/p>\n
       00020<\/span> 49 3b d2 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0 cmp\u00a0 rdx, r10<\/span><\/p>\n
       00023<\/span> 7c eb \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 jl\u00a0\u00a0 SHORT $LL8@test1<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
       <\/p>\n
      In the example above, the CMP and JL instructions are macro-fused and overlay a 32-byte boundary. The mitigation pads the first instruction in the block, the MOV instruction with 0x3E prefix to align the CMP instruction to begin on a 32-byte boundary.<\/p>\n
      What is the performance story?<\/h2>\n
      We did evaluate the performance impact of the MCU and fix in the MSVC compiler. The numbers stated below use the following test PC configuration.<\/p>\n
      Processor<\/strong> \u2013 Intel\u00ae Core\u2122 i9 9900K @ 3.60GHz<\/p>\n
      Operating System<\/strong> \u2013 Private build of Windows with the MCU applicable to this processor.<\/p>\n
      Benchmark suite<\/strong> \u2013 SPEC CPU\u00ae 2017<\/p>\n
      Based on our measurements, we see regressions ranging from 0-3% after applying the MCU. We also saw regressions going up to 10% on some outlier microbenchmarks.<\/p>\n
      Applying the software mitigation through the \/QIntel-jcc-erratum<\/em> switch in MSVC compiler makes the regressions negligible. This switch applies the mitigation globally to all modules built with it and increases code size. We measured an average of 3% code size bloat.<\/p>\n
      We measured that applying the mitigation only in loops through the \/d2QIntel-jcc-erratum-partial <\/em>switch also makes the performance regressions negligible but with lesser code size increase. We measured an average of 1.5% code size bloat with the partial mitigation. You can further reduce the code size impact and get most of the performance back by applying the mitigations only to hot functions through the \/d2QIntel-jcc-erratum:<file.txt> <\/em>and \/d2QIntel-jcc-erratum-partial:<file.txt> <\/em>switches.<\/p>\n
      We also measured that the performance impact of \/QIntel-jcc-erratum<\/em> switch on processors that are not affected by the erratum is negligible. However, as codebases vary greatly, we advise developers to evaluate the impact of \/QIntel-jcc-erratum<\/em> in the context of their applications and workloads.<\/p>\n
      Closing Notes<\/h2>\n
      If your software can run on the machines with processors affected by the JCC erratum and versions of Windows with the MCU, we encourage you to profile your code and check for performance regressions. You can use Windows Performance Toolkit<\/a> or Intel\u00ae VTune \u2122 Profiler<\/a> to profile your code. You can detect if the MCU is affecting performance by following steps in Intel\u2019s white paper. If you are affected, recompile with \/QIntel-jcc-erratum <\/em>or other switches listed above to mitigate the effects.<\/p>\n
      Your feedback is key to deliver the best experience. If you have any questions, please feel free to ask us below. You can also send us your comments through e-mail<\/a>. If you encounter problems with the experience or have suggestions for improvement, please\u00a0Report A Problem<\/a>\u00a0or reach out via\u00a0Developer Community<\/a>. You can also find us on Twitter\u00a0@VisualC<\/a>.<\/p>\n
       <\/p>\n","protected":false},"excerpt":{"rendered":"
      The content of this blog was provided by Gautham Beeraka from Intel Corporation. Intel recently announced Jump Conditional Code (JCC) Erratum which can occur in some of its processors. The MSVC team has been working with Intel to provide a software fix in the compiler to mitigate the performance impact of the microcode update that […]<\/p>\n","protected":false},"author":14432,"featured_media":25463,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[270,218],"tags":[],"class_list":["post-25462","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-announcement","category-performance"],"acf":[],"blog_post_summary":"
      The content of this blog was provided by Gautham Beeraka from Intel Corporation. Intel recently announced Jump Conditional Code (JCC) Erratum which can occur in some of its processors. The MSVC team has been working with Intel to provide a software fix in the compiler to mitigate the performance impact of the microcode update that […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/25462","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/14432"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=25462"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/25462\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/25463"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=25462"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=25462"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=25462"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}