{"id":25350,"date":"2020-01-07T15:36:04","date_gmt":"2020-01-07T15:36:04","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/cppblog\/?p=25350"},"modified":"2020-01-07T15:36:04","modified_gmt":"2020-01-07T15:36:04","slug":"c-inliner-improvements-the-zipliner","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/c-inliner-improvements-the-zipliner\/","title":{"rendered":"C++ Inliner Improvements: The Zipliner"},"content":{"rendered":"

Visual Studio 2019<\/span> versions 16.3 and 16.4<\/span><\/a> include improvements to the C++ <\/span>inliner<\/span>. Among these is the ability to inline some routines after they have been optimized, referred to as the \u201c<\/span>Zipliner.\u201d<\/span> Depending on your application, you may see some minor code quality improvements and\/or major build-time (compiler throughput) improvements.<\/span>\u00a0<\/span><\/p>\n

C2 Inliner<\/h2>\n

Terry Mahaffey has provided an overview of <\/span>Visual Studio\u2019s inlining decisions<\/span><\/a>.<\/span> This details some of the <\/span>inliner\u2019s<\/span> constraints and areas for improvement, a few of which are particularly relevant here:<\/span>\u00a0<\/span><\/p>\n

    \n
  1. The <\/span>inliner<\/span> is recursive and may often re-do work it has already done. Inline decisions are context sensitive and it is not always profitable to replay its decision-making for the same function.<\/span>\u00a0<\/span><\/li>\n
  2. The<\/span> inliner<\/span> is very <\/span>budget conscious<\/span>. It has the difficult job of balancing executable size with runtime performance.<\/span>\u00a0<\/span><\/li>\n
  3. The <\/span><\/span>inliner\u2019s<\/span><\/span> view of the world is always \u201cpre-optimize<\/span><\/span>d.\u201d <\/span><\/span>It has very limited knowledge of copy propagation and dead control paths for example.<\/span><\/span><\/li>\n<\/ol>\n

    Modern C++<\/h2>\n

    Unfortunately, many of the coding patterns and idioms common to heavy generic programming bump into those constraints. Consider the following routine in the <\/span>Eigen library<\/span><\/a>:<\/span><\/p>\n

    Eigen::Matrix<float,-1,1,0,-1,1>::outerStride(void)<\/pre>\n
    which calls innerSize:<\/p>\n
    template<typename Derived> class DenseBase \r\n... \r\nIndex innerSize() const \r\n{ \r\n    return IsVectorAtCompileTime ? this->size() \r\n         : int(IsRowMajor) ? this->cols() : this->rows(); \r\n}<\/pre>\n
    That instantiation of <\/span><\/span>outerStride<\/span><\/span> does nothing but return one of its members. Therefore, it is an excellent candidate for full inline expansion. To realize this win though the compiler must fully evaluate and expand <\/span><\/span>outerStride<\/span><\/span>\u2019s<\/span><\/span> 18 total <\/span><\/span>callees<\/span><\/span>, for every <\/span><\/span>callsite<\/span><\/span> of<\/span><\/span> outerStride<\/span><\/span> in the module. This eats into both the optimizer throughput as well as the <\/span><\/span>inliner\u2019s<\/span><\/span> code-size budget. It also bears mentioning that calls to \u2018rows\u2019 and \u2018cols\u2019 are <\/span><\/span>inline-expanded<\/span><\/span> as well, even though those are on a statically dead path.<\/span><\/span><\/p>\n
    It would be much better<\/span><\/span> if the optimizer just <\/span>inlined<\/span> the two-line member return<\/span><\/span>:<\/span><\/span><\/p>\n
    ?outerStride@?$Matrix@N$0?0$0?0$0A@$0?0$0?0@Eigen@@QEBA_JXZ PROC ; Eigen::Matrix<double,-1,-1,0,-1,-1>::outerStride, COMDAT \r\nmov\t\r\n    rax, QWORD PTR [rcx+8] \r\n    ret 0<\/pre>\n
    Inlining Optimized IR<\/h2>\n
    For a subset of <\/span>routines<\/span> the inliner will now expand the <\/span>already-optimized <\/span>IR of a routine, bypassing the process of <\/span>fetching IR, and re-expanding<\/span> callees.<\/span> This has the dual purpose of expanding <\/span>callsites<\/span> much faster, as well as letting the inliner measure its budget more accurately.<\/span>\u00a0<\/span><\/p>\n
    First, t<\/span>he<\/span> optimizer <\/span>will summarize<\/span> that <\/span>outerStride is a candidate for this faster expansion when it is <\/span>originally<\/span> compiled<\/span> (Remember <\/span>that c2.dll tries to<\/span> compile routines before their callers)<\/span>. <\/span>Then, t<\/span>he <\/span>inliner <\/span>may<\/span> replace calls to that <\/span>outerStride instantiation with <\/span>the field access.<\/span>\u00a0<\/span><\/p>\n
    T<\/span>he candidates for this faster inline expansion are leaf functions <\/span>with no locals<\/span>, which refer to at most two different arguments, <\/span>globa<\/span>l<\/span>s<\/span>, or constants. In practice <\/span>this targets<\/span> most simple getters and setters.<\/span><\/p>\n
    Benefits<\/h2>\n
    There are many examples like <\/span>outerStride<\/span> in the Eigen library where a large call tree expands into just one or two instructions. Modules that make heavy use of Eigen may see a significant throughput improvement; we measured the optimizer taking up to 25-50% less time for such repros.<\/span>\u00a0<\/span><\/p>\n
    The new Zipliner will also enable the inliner to measure its budget more accurately. <\/span>Eigen developers have long been aware that MSVC does not inline to their specifications (see EIGEN_STRONG_INLINE). Zipliner should help to alleviate some of this concern, as a ziplined routine is now considered a virtually \u201cfree\u201d inline.<\/span><\/p>\n
    Give the feature a try<\/h2>\n
    This is enabled by default in Visual Studio 2019<\/span> 16.3<\/span>, along with some improvements in 16.4. Please <\/span>download Visual Studio 2019<\/span><\/a> and give the new improvements a try. We can be reached via the comments below or via email (visualcpp@microsoft.com). If you encounter problems with Visual Studio or MSVC, or have a suggestion for us, please let us know through Help > Send Feedback > Report A Problem \/ Provide a Suggestion in the product, or via <\/span>Developer Community<\/span><\/a>. You can also find us on Twitter (<\/span>@<\/span>VisualC<\/span><\/a>).<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
    Visual Studio 2019 versions 16.3 and 16.4 include improvements to the C++ inliner. Among these is the ability to inline some routines after they have been optimized, referred to as the \u201cZipliner.\u201d Depending on your application, you may see some minor code quality improvements and\/or major build-time (compiler throughput) improvements.\u00a0 C2 Inliner Terry Mahaffey has […]<\/p>\n","protected":false},"author":15688,"featured_media":35994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[270],"tags":[],"class_list":["post-25350","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-announcement"],"acf":[],"blog_post_summary":"
    Visual Studio 2019 versions 16.3 and 16.4 include improvements to the C++ inliner. Among these is the ability to inline some routines after they have been optimized, referred to as the \u201cZipliner.\u201d Depending on your application, you may see some minor code quality improvements and\/or major build-time (compiler throughput) improvements.\u00a0 C2 Inliner Terry Mahaffey has […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/25350","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\/15688"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=25350"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/25350\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/35994"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=25350"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=25350"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=25350"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}