{"id":33970,"date":"2024-04-15T16:36:16","date_gmt":"2024-04-15T16:36:16","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/cppblog\/?p=33970"},"modified":"2024-04-15T11:37:39","modified_gmt":"2024-04-15T11:37:39","slug":"templates-view-for-build-insights-in-visual-studio-2","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/templates-view-for-build-insights-in-visual-studio-2\/","title":{"rendered":"Templates View for Build Insights in Visual Studio\u00a0"},"content":{"rendered":"

Introduction<\/span><\/h3>\n

Introducing the new Templates View feature of Build Insights! Templates View now allows you to capture data about how templates in your codebase are contributing to your build time. This feature is available in Visual Studio 2022 17.10 and later.\u00a0<\/span>\u00a0<\/span><\/p>\n

Download Visual Studio 2022<\/span><\/a>\u00a0<\/span><\/p>\n

Getting Started with Templates View<\/span>\u00a0<\/span><\/h3>\n

To use Build Insights in Visual Studio you will need to ensure you\u2019ve installed the \u201cC++ Build Insights\u201d component. This is installed by default if you\u2019ve installed either the \u201cDesktop development with C++\u201d or \u201cGame development with C++\u201d workloads.<\/span>\u00a0<\/span><\/p>\n

By default, Templates View is turned off; To turn on Templates View navigate to the <\/span>Tools <\/span><\/b>menu and select <\/span>Options…\u00a0<\/span><\/b>\u00a0<\/span><\/p>\n

\"Image<\/a><\/span><\/p>\n

Select <\/span>Build Insights<\/span><\/b> in the list of options and click <\/span>Trace Collection<\/span><\/b>. This will show the available settings for Build Insights.<\/span>\u00a0<\/span><\/p>\n

\"Image<\/a><\/span><\/p>\n

In the popup options menu, select the checkbox for <\/span>Template Instantiation Collection<\/span><\/b>; this will turn on Templates View.<\/span>\u00a0<\/span><\/p>\n

\"Image<\/a><\/span><\/p>\n

With the checkbox selected, you can run Build Insights on your project. This action will collect the template data and display it. If you have a trace file from a previous run where the template data was collected, you can open this trace file to view the “Templates View” in the report.<\/span>\u00a0<\/span><\/p>\n

Please note that if you have a trace file that was run without this checkbox turned on, the template data was not collected in that trace file and thus no data will appear in the Templates View. You will need to rerun Build Insights with Templates View turned on if you\u2019d like to see the template data for that project.\u00a0<\/span>\u00a0<\/span><\/p>\n

Using Templates View\u00a0<\/span><\/h3>\n

Templates View highlights the impact of the template instantiations that take the most time in your build. The view only shows instantiations whose contribution exceeds a certain threshold. If you see nothing in the Templates View, it means your build time is not dominated by template instantiations.<\/span>\u00a0<\/span><\/p>\n

Let\u2019s walk through an example together of how to use Templates View. In a new C++ Console Application project, add a header file called Templates.h<\/code> with the following code snippet:<\/span>\u00a0<\/span><\/p>\n

#pragma once\u00a0\r\n#include <utility>\u00a0\u00a0\r\n#include <vector>\u00a0\u00a0\r\n\r\ntemplate<size_t> struct S1 {};\u00a0\r\ntemplate<int n> using type = std::vector<S1<n>>;\u00a0\r\n\r\ntemplate<size_t...> struct S2 {};\u00a0\r\n\r\ntemplate<typename> struct S3 {};\u00a0\r\ntemplate<size_t... n>\u00a0\r\nstruct S3<std::index_sequence<n...>> {\u00a0\r\n    using type = S2<sizeof(type<n>)...>;\u00a0\r\n};\u00a0\r\n\r\ninline size_t LargeValue() {\u00a0\r\n    return sizeof(S3<std::make_index_sequence<1000>>);\u00a0\r\n};\u00a0\r\n\r\ninline size_t SmallValue() {\u00a0\r\n    return sizeof(S1<5>);\u00a0\r\n} <\/code><\/pre>\n
Then create a source file called LargeValue.cpp<\/code> with the following code:<\/span>\u00a0<\/span><\/p>\n
#include \"Templates.h\"\u00a0\r\nsize_t GetLargeValue() {\u00a0\r\n    return LargeValue();\u00a0\r\n} <\/code><\/pre>\n
Lastly, create a second source file called SmallValue.cpp<\/code> with the below code:<\/span>\u00a0<\/span><\/p>\n
#include \"Templates.h\"\u00a0\r\nsize_t GetSmallValue() {\u00a0\r\n\u00a0 \u00a0 return SmallValue();\u00a0\r\n}<\/code><\/pre>\n
We\u2019ll now run Build Insights on a rebuild of our project to get information about our build time.<\/span>\u00a0<\/span>\"Image<\/a><\/p>\n
From the Templates View of Build Insights, we can see that two template instantiations of S3<\/code> are taking 83% of the entire build time. The \u201cTranslation Unit\u201d column shows that both SmallValue.cpp<\/code> and LargeValue.cpp<\/code> are causing this template instantiation to be included in the build. The \u201cInstantiation File Path\u201d shows us where the template instantiation happens. We can derive that there\u2019s one expensive template instantiation affecting both of our source files, because the \u201cInstantiation File Path\u201d and the \u201cSpecialization Name\u201d are the same. This also explains why the time of each of the two template instantiations are about equal. Essentially, by including Templates.h<\/code> in both of our source files, we are causing one template instantiation to add almost 6 seconds to our build time.<\/span>\u00a0<\/span><\/p>\n
Let\u2019s investigate further to find where this template instantiation is located. We know that the instantiation is created in Templates.h<\/code> and we can use the \u201cSpecialization Name\u201d column to determine that the below code is the culprit:<\/span>\u00a0<\/span><\/p>\n
inline size_t LargeValue() {\u00a0\r\n    return sizeof(S3<std::make_index_sequence<1000>>);\u00a0\r\n}; <\/code><\/pre>\n
There are three main ways to decrease the cost of template instantiations. The first way is to review the template in question and determine if it\u2019s being used or not. If it\u2019s not being used, then the easiest solution is to remove the function. In our program,LargeValue()<\/code>is being used by LargeValue.cpp<\/code>, so we cannot remove it. We can also consider removing the include directive(s) that is bringing in this template instantiation. It\u2019s easy to forget to remove header files when you\u2019re no longer using them, and this is a great demonstration of how an include directive can cause a huge impact on build time. However, both of our source files are dependent on Templates.h<\/code> so this will not help us.<\/span>\u00a0<\/span><\/p>\n
\"\"<\/a>Read<\/strong>\u00a0#include cleanup in Visual Studio – C++ Team Blog (microsoft.com)<\/a> for more information on decreasing template instantiation cost by removing include directives.\u00a0<\/span><\/p>\n
The second way is to look at the template instantiation and determine if there is a way to optimize the code. The only optimization possible here is decreasing the size of the index sequence. As a fun exercise, try replacing 1000 with various numbers and see how that impacts the build time. <\/span>\u00a0<\/span><\/p>\n
\"\"<\/a>Read<\/strong>\u00a0Build Throughput Series: More Efficient Template Metaprogramming – C++ Team Blog (microsoft.com)<\/a> for more practice reducing the cost of template metaprogramming. <\/span><\/p>\n
For our purposes, let\u2019s assume that we need an index sequence of 1000. We now need to rely on the third way to decrease template instantiation cost: moving the definition of LargeValue()<\/code> to a source file.\u00a0<\/span>\u00a0<\/span><\/p>\n
\"\"<\/a>Tip: <\/b>If for some reason you need to keep the function in a header file, then you can move the definition to a .inl file. If you move the definition to a .inl file, then ensure the source files which use that function include both the header file and the .inl file.\u00a0<\/span><\/p>\n
LargeValue.cpp<\/code> is the only source file that calls LargeValue()<\/code>, so we can move the definition to LargeValue.cpp<\/code>. To do this, remove the current definition of LargeValue()<\/code> from Templates.h<\/code> and replace it with the following declaration:<\/span>\u00a0<\/span><\/p>\n
inline size_t LargeValue();\u00a0\r\n\r\n<\/code><\/pre>\n
Then, inside LargeValue.cpp add the following code snippet:\u00a0<\/span><\/p>\n
inline size_t LargeValue() {\u00a0\r\n    return sizeof(S3<std::make_index_sequence<1000>>);\u00a0\r\n} <\/code><\/pre>\n
If we rerun Build Insights on a rebuild of the project we can now see the below Templates View:<\/span>\u00a0<\/span>\"Image<\/a><\/p>\n
The build time has significantly decreased. While the template instantiation of S3<\/code> is still contributing 76% of the build time, we\u2019ve been able to about half the total time, by only including necessary template instantiations (you can see the count of S3<\/code> is now 1).<\/span>\u00a0<\/span><\/p>\n
The techniques used in this example can be applied to larger projects. If multiple files included Templates.h<\/code>, each of those files would have added the instantiation time of LargeValue()<\/code> to the total build time. By moving the definition of LargeValue()<\/code> to a dedicated source file, we can minimize our build time. <\/span><\/p>\n
\"\"<\/a>Try For Yourself:<\/b> Create two more source files in the same C++ console application project we\u2019ve been using above (you should now have four source files in your project). Have all files include the original Templates.h<\/code> (before our optimizations). Run build insights on the project. Now apply the optimizations from the previous example above and ensure only LargeValue.cpp<\/code> has the definition of LargeValue()<\/code>. You should see the build time is decreased by 75%.\u00a0\u00a0<\/span><\/p>\n
Costs Associated with Templates View\u00a0<\/span><\/h3>\n
To collect the template instantiation information from your build, Build Insights utilizes a higher level of data collection than necessary for the other views in Build Insights. It also must perform additional post processing on the data collected. These two factors increase how long it takes Build Insights to generate a report; larger C++ projects will notice this difference more than smaller projects. Due to this increase in time, Templates View is turned off by default.<\/span>\u00a0<\/span><\/p>\n
Thank You!\u00a0<\/span><\/h3>\n
Thank you to Xiang Fan for adding ETW events to the MSVC compiler so we can track template data. Thank you to Kevin Cadieux for integrating the template ETW events into the Build Insights trace collection. Thank you to Nelson Troncoso for leading the development and design of Build Insights in Visual Studio. Thank you to our former C++ intern and my mentee Hanah Chandley, for her help on adding the Templates View into Visual Studio. Thank you to our developer community, especially our game studio partners, for their suggestions. We are constantly striving to improve Build Insights for Visual Studio and your comments and suggestions help us to do this. If you\u2019d like to share your ideas or experience with us you can comment below, find us on Twitter (<\/span>@VisualC<\/span><\/a>) <\/span>or email us at<\/span> visualcpp@microsoft.com<\/span><\/a>. To open a bug, please see<\/span> Visual Studio Feedback<\/span><\/a>.<\/span>\u00a0<\/span><\/p>\n
Check out our previous blog posts about Build Insights for Visual Studio:\u00a0<\/span>\u00a0<\/span><\/p>\n
Build Insights Now Available in Visual Studio 2022 – C++ Team Blog (microsoft.com)<\/span><\/a>\u00a0<\/span><\/p>\n
Functions View for Build Insights in Visual Studio 2022 17.8 – C++ Team Blog (microsoft.com)<\/span><\/a>\u00a0<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
Introduction Introducing the new Templates View feature of Build Insights! Templates View now allows you to capture data about how templates in your codebase are contributing to your build time. This feature is available in Visual Studio 2022 17.10 and later.\u00a0\u00a0 Download Visual Studio 2022\u00a0 Getting Started with Templates View\u00a0 To use Build Insights in […]<\/p>\n","protected":false},"author":155365,"featured_media":33977,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[270,1],"tags":[],"class_list":["post-33970","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-announcement","category-cplusplus"],"acf":[],"blog_post_summary":"
Introduction Introducing the new Templates View feature of Build Insights! Templates View now allows you to capture data about how templates in your codebase are contributing to your build time. This feature is available in Visual Studio 2022 17.10 and later.\u00a0\u00a0 Download Visual Studio 2022\u00a0 Getting Started with Templates View\u00a0 To use Build Insights in […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/33970","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\/155365"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=33970"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/33970\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/33977"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=33970"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=33970"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=33970"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}