[MemProf] Add hot allocation type

[kanwu]

Summary

Add "Hot" AllocationType (in addition to existing cold, notcold).

Use lifetime access density as metric to identify hot allocations.
Treat hot as notcold for MemProfContextDisambiguation for now
before the disambiguation for "hot" is done.

[tejohnson]

Looks great, thanks! Just a few minor comments.

llvm/include/llvm/IR/ModuleSummaryIndex.h

340

Update comment

616

I'm seeing some whitespace differences on otherwise unchanged lines in this patch. Did you run some kind of automatic formatting on the whole file? We'll want to avoid unrelated formatting changes in the patch, even if this used clang-format with the LLVM style (https://clang.llvm.org/docs/ClangFormatStyleOptions.html)

llvm/lib/Analysis/MemoryProfileInfo.cpp

36

nit: other places here use lifetime as one word, maybe switch to that for consistency.

llvm/lib/Transforms/IPO/MemProfContextDisambiguation.cpp

46

Is this change needed?

2064

s/or/Or/ in the func name.

[kanwu]

update according to comments.

[kanwu]

thanks Teresa. made changes according to your comments.

[tejohnson]

lgtm

[dyung]

@kanwu, this change seems to break on a Windows build bot, can you take a look and revert if you need time to investigate? (I'm not sure why you were not listed in the changes for this build on buildbot)
https://lab.llvm.org/buildbot/#/builders/216/builds/20923

FAILED: unittests/Analysis/CMakeFiles/AnalysisTests.dir/MemoryProfileInfoTest.cpp.obj 
C:\bin\ccache.exe C:\PROGRA~2\MICROS~1\2019\BUILDT~1\VC\Tools\MSVC\1429~1.301\bin\HostX64\x64\cl.exe  /nologo /TP -DGTEST_HAS_RTTI=0 -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_GLIBCXX_ASSERTIONS -D_HAS_EXCEPTIONS=0 -D_LIBCPP_ENABLE_ASSERTIONS -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Iunittests\Analysis -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis -Iinclude -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\include -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googletest\include -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googlemock\include /DWIN32 /D_WINDOWS   /Zc:inline /Zc:preprocessor /Zc:__cplusplus /Oi /bigobj /permissive- /W4 -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd5105 -wd4324 -w14062 -we4238 /Gw /MD /O2 /Ob2  /EHs-c- /GR- -UNDEBUG -std:c++17 /showIncludes /Founittests\Analysis\CMakeFiles\AnalysisTests.dir\MemoryProfileInfoTest.cpp.obj /Fdunittests\Analysis\CMakeFiles\AnalysisTests.dir\ /FS -c Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(632): error C2065: 'uint': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(632): error C2146: syntax error: missing ';' before identifier 'Idx'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(632): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(637): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(637): error C2660: 'testing::internal::EqHelper::Compare': function does not take 3 arguments
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googletest\include\gtest/gtest.h(1562): note: see declaration of 'testing::internal::EqHelper::Compare'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(637): error C2737: 'gtest_ar': const object must be initialized
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(642): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(645): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(652): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(666): error C2065: 'uint': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(666): error C2146: syntax error: missing ';' before identifier 'Idx'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(666): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(673): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(676): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(683): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(689): error C2065: 'uint': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(689): error C2146: syntax error: missing ';' before identifier 'Idx'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(689): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(693): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(693): error C2660: 'testing::internal::EqHelper::Compare': function does not take 3 arguments
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googletest\include\gtest/gtest.h(1562): note: see declaration of 'testing::internal::EqHelper::Compare'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(693): error C2737: 'gtest_ar': const object must be initialized
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(697): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(700): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(707): error C2065: 'Idx': undeclared identifier

[tejohnson]

In D149932#4327378, @dyung wrote:

@kanwu, this change seems to break on a Windows build bot, can you take a look and revert if you need time to investigate? (I'm not sure why you were not listed in the changes for this build on buildbot)
https://lab.llvm.org/buildbot/#/builders/216/builds/20923

I committed it for Kan, odd that the buildbots don't seem to be including this change specifically. Looks like some platforms don't recognize "uint". I will commit a fix in a few mins to use "unsigned" instead.

FAILED: unittests/Analysis/CMakeFiles/AnalysisTests.dir/MemoryProfileInfoTest.cpp.obj 
C:\bin\ccache.exe C:\PROGRA~2\MICROS~1\2019\BUILDT~1\VC\Tools\MSVC\1429~1.301\bin\HostX64\x64\cl.exe  /nologo /TP -DGTEST_HAS_RTTI=0 -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_GLIBCXX_ASSERTIONS -D_HAS_EXCEPTIONS=0 -D_LIBCPP_ENABLE_ASSERTIONS -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Iunittests\Analysis -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis -Iinclude -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\include -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googletest\include -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googlemock\include /DWIN32 /D_WINDOWS   /Zc:inline /Zc:preprocessor /Zc:__cplusplus /Oi /bigobj /permissive- /W4 -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd5105 -wd4324 -w14062 -we4238 /Gw /MD /O2 /Ob2  /EHs-c- /GR- -UNDEBUG -std:c++17 /showIncludes /Founittests\Analysis\CMakeFiles\AnalysisTests.dir\MemoryProfileInfoTest.cpp.obj /Fdunittests\Analysis\CMakeFiles\AnalysisTests.dir\ /FS -c Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(632): error C2065: 'uint': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(632): error C2146: syntax error: missing ';' before identifier 'Idx'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(632): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(637): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(637): error C2660: 'testing::internal::EqHelper::Compare': function does not take 3 arguments
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googletest\include\gtest/gtest.h(1562): note: see declaration of 'testing::internal::EqHelper::Compare'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(637): error C2737: 'gtest_ar': const object must be initialized
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(642): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(645): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(652): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(666): error C2065: 'uint': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(666): error C2146: syntax error: missing ';' before identifier 'Idx'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(666): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(673): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(676): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(683): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(689): error C2065: 'uint': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(689): error C2146: syntax error: missing ';' before identifier 'Idx'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(689): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(693): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(693): error C2660: 'testing::internal::EqHelper::Compare': function does not take 3 arguments
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googletest\include\gtest/gtest.h(1562): note: see declaration of 'testing::internal::EqHelper::Compare'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(693): error C2737: 'gtest_ar': const object must be initialized
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(697): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(700): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(707): error C2065: 'Idx': undeclared identifier

[tejohnson]

In D149932#4327394, @tejohnson wrote:

In D149932#4327378, @dyung wrote:

@kanwu, this change seems to break on a Windows build bot, can you take a look and revert if you need time to investigate? (I'm not sure why you were not listed in the changes for this build on buildbot)
https://lab.llvm.org/buildbot/#/builders/216/builds/20923

I committed it for Kan, odd that the buildbots don't seem to be including this change specifically. Looks like some platforms don't recognize "uint". I will commit a fix in a few mins to use "unsigned" instead.

Should be fixed by 57d71cba0a84ee90356f460b381c1ba5aee5822b

FAILED: unittests/Analysis/CMakeFiles/AnalysisTests.dir/MemoryProfileInfoTest.cpp.obj 
C:\bin\ccache.exe C:\PROGRA~2\MICROS~1\2019\BUILDT~1\VC\Tools\MSVC\1429~1.301\bin\HostX64\x64\cl.exe  /nologo /TP -DGTEST_HAS_RTTI=0 -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_GLIBCXX_ASSERTIONS -D_HAS_EXCEPTIONS=0 -D_LIBCPP_ENABLE_ASSERTIONS -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Iunittests\Analysis -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis -Iinclude -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\include -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googletest\include -IZ:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googlemock\include /DWIN32 /D_WINDOWS   /Zc:inline /Zc:preprocessor /Zc:__cplusplus /Oi /bigobj /permissive- /W4 -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd5105 -wd4324 -w14062 -we4238 /Gw /MD /O2 /Ob2  /EHs-c- /GR- -UNDEBUG -std:c++17 /showIncludes /Founittests\Analysis\CMakeFiles\AnalysisTests.dir\MemoryProfileInfoTest.cpp.obj /Fdunittests\Analysis\CMakeFiles\AnalysisTests.dir\ /FS -c Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(632): error C2065: 'uint': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(632): error C2146: syntax error: missing ';' before identifier 'Idx'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(632): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(637): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(637): error C2660: 'testing::internal::EqHelper::Compare': function does not take 3 arguments
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googletest\include\gtest/gtest.h(1562): note: see declaration of 'testing::internal::EqHelper::Compare'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(637): error C2737: 'gtest_ar': const object must be initialized
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(642): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(645): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(652): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(666): error C2065: 'uint': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(666): error C2146: syntax error: missing ';' before identifier 'Idx'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(666): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(673): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(676): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(683): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(689): error C2065: 'uint': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(689): error C2146: syntax error: missing ';' before identifier 'Idx'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(689): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(693): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(693): error C2660: 'testing::internal::EqHelper::Compare': function does not take 3 arguments
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\third-party\unittest\googletest\include\gtest/gtest.h(1562): note: see declaration of 'testing::internal::EqHelper::Compare'
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(693): error C2737: 'gtest_ar': const object must be initialized
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(697): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(700): error C2065: 'Idx': undeclared identifier
Z:\b\llvm-clang-x86_64-sie-win\llvm-project\llvm\unittests\Analysis\MemoryProfileInfoTest.cpp(707): error C2065: 'Idx': undeclared identifier

[shchenz]

This comment was removed by shchenz.

[shchenz]

empty hot-alloctype.patch is still there, the file looks like a typo?

[tejohnson]

In D149932#4334051, @shchenz wrote:

empty hot-alloctype.patch is still there, the file looks like a typo?

Yes, it looks like that was accidentally added into the patch and got committed. I will remove that.

[tejohnson]

In D149932#4334052, @tejohnson wrote:

In D149932#4334051, @shchenz wrote:

empty hot-alloctype.patch is still there, the file looks like a typo?

Yes, it looks like that was accidentally added into the patch and got committed. I will remove that.

Removed in 657dbb4c394daec626bccfcaddc5341b8b9fc14e. Thanks for pointing that out!

llvm/include/llvm/IR/ModuleSummaryIndex.h

if (!First)
       OS << ", ";
     First = false;
     OS << Id;
   }
   return OS;
 }
 
 // Allocation type assigned to an allocation reached by a given context.
-// More can be added but initially this is just noncold and cold.
+// More can be added, now this is cold, notcold and hot.
 // Values should be powers of two so that they can be ORed, in particular to
 // track allocations that have different behavior with different calling
 // contexts.
 enum class AllocationType : uint8_t {
   None = 0,
   NotCold = 1,
   Cold = 2,
-  All = 3 // This should always be set to the OR of all values.
+  Hot = 4,
+  All = 7 // This should always be set to the OR of all values.
 };
 
 /// Summary of a single MIB in a memprof metadata on allocations.
 struct MIBInfo {
   // The allocation type for this profiled context.
   AllocationType AllocType;
 
   // Represents stack ids in this context, recorded as indices into the
public:
 
   const GlobalValueSummary &getAliasee() const {
     assert(AliaseeSummary && "Unexpected missing aliasee summary");
     return *AliaseeSummary;
   }
 
   GlobalValueSummary &getAliasee() {
     return const_cast<GlobalValueSummary &>(
                          static_cast<const AliasSummary *>(this)->getAliasee());
   }
   ValueInfo getAliaseeVI() const {
     assert(AliaseeValueInfo && "Unexpected missing aliasee");
     return AliaseeValueInfo;
   }
   GlobalValue::GUID getAliaseeGUID() const {
     assert(AliaseeValueInfo && "Unexpected missing aliasee");
     return AliaseeValueInfo.getGUID();

llvm/lib/Analysis/MemoryProfileInfo.cpp

 
 // Lower bound on lifetime to mark an allocation cold (in addition to accesses
 // per byte per sec above). This is to avoid pessimizing short lived objects.
 cl::opt<unsigned> MemProfAveLifetimeColdThreshold(
     "memprof-ave-lifetime-cold-threshold", cl::init(200), cl::Hidden,
     cl::desc("The average lifetime (s) for an allocation to be considered "
              "cold"));
 
+// Lower bound on average lifetime accesses density (total life time access
+// density / alloc count) for marking an allocation hot.
+cl::opt<unsigned> MemProfMinAveLifetimeAccessDensityHotThreshold(
+    "memprof-min-ave-lifetime-access-density-hot-threshold", cl::init(1000),
+    cl::Hidden,
+    cl::desc("The minimum TotalLifetimeAccessDensity / AllocCount for an "
+             "allocation to be considered hot"));
+
 AllocationType llvm::memprof::getAllocType(uint64_t TotalLifetimeAccessDensity,
                                            uint64_t AllocCount,
                                            uint64_t TotalLifetime) {
   // The access densities are multiplied by 100 to hold 2 decimal places of
   // precision, so need to divide by 100.
   if (((float)TotalLifetimeAccessDensity) / AllocCount / 100 <
           MemProfLifetimeAccessDensityColdThreshold
       // Lifetime is expected to be in ms, so convert the threshold to ms.
       && ((float)TotalLifetime) / AllocCount >=
              MemProfAveLifetimeColdThreshold * 1000)
     return AllocationType::Cold;
+
+  // The access densities are multiplied by 100 to hold 2 decimal places of
+  // precision, so need to divide by 100.
+  if (((float)TotalLifetimeAccessDensity) / AllocCount / 100 >
+      MemProfMinAveLifetimeAccessDensityHotThreshold)
+    return AllocationType::Hot;
+
   return AllocationType::NotCold;
 }
 
 MDNode *llvm::memprof::buildCallstackMetadata(ArrayRef<uint64_t> CallStack,
                                               LLVMContext &Ctx) {
   std::vector<Metadata *> StackVals;
   for (auto Id : CallStack) {
     auto *StackValMD =

 
 AllocationType llvm::memprof::getMIBAllocType(const MDNode *MIB) {
   assert(MIB->getNumOperands() == 2);
   // The allocation type is currently the second operand of each memprof
   // MIB metadata. This will need to change as we add additional allocation
   // types that can be applied based on the allocation profile data.
   auto *MDS = dyn_cast<MDString>(MIB->getOperand(1));
   assert(MDS);
-  if (MDS->getString().equals("cold"))
+  if (MDS->getString().equals("cold")) {
     return AllocationType::Cold;
+  } else if (MDS->getString().equals("hot")) {
+    return AllocationType::Hot;
+  }
   return AllocationType::NotCold;
 }
 
 std::string llvm::memprof::getAllocTypeAttributeString(AllocationType Type) {
   switch (Type) {
   case AllocationType::NotCold:
     return "notcold";
     break;
   case AllocationType::Cold:
     return "cold";
     break;
+  case AllocationType::Hot:
+    return "hot";
+    break;
   default:
     assert(false && "Unexpected alloc type");
   }
   llvm_unreachable("invalid alloc type");
 }
 
 static void addAllocTypeAttribute(LLVMContext &Ctx, CallBase *CI,
                                   AllocationType AllocType) {

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseMemProfs(std::vector<MIBInfo> &MIBs) {
 
   if (parseToken(lltok::rparen, "expected ')' in memprof"))
     return true;
 
   return false;
 }
 
 /// AllocType
-///   := ('none'|'notcold'|'cold')
+///   := ('none'|'notcold'|'cold'|'hot')
 bool LLParser::parseAllocType(uint8_t &AllocType) {
   switch (Lex.getKind()) {
   case lltok::kw_none:
     AllocType = (uint8_t)AllocationType::None;
     break;
   case lltok::kw_notcold:
     AllocType = (uint8_t)AllocationType::NotCold;
     break;
   case lltok::kw_cold:
     AllocType = (uint8_t)AllocationType::Cold;
     break;
+  case lltok::kw_hot:
+    AllocType = (uint8_t)AllocationType::Hot;
+    break;
   default:
     return error(Lex.getLoc(), "invalid alloc type");
   }
   Lex.Lex();
   return false;
 }
 
 /// OptionalCallsites

llvm/lib/IR/AsmWriter.cpp

void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {
   auto AllocTypeName = [](uint8_t Type) -> const char * {
     switch (Type) {
     case (uint8_t)AllocationType::None:
       return "none";
     case (uint8_t)AllocationType::NotCold:
       return "notcold";
     case (uint8_t)AllocationType::Cold:
       return "cold";
+    case (uint8_t)AllocationType::Hot:
+      return "hot";
     }
     llvm_unreachable("Unexpected alloc type");
   };
 
   if (!FS->allocs().empty()) {
     Out << ", allocs: (";
     FieldSeparator AFS;
     for (auto &AI : FS->allocs()) {

llvm/lib/Transforms/IPO/MemProfContextDisambiguation.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include <sstream>
 #include <vector>
 using namespace llvm;
 using namespace llvm::memprof;
 
 #define DEBUG_TYPE "memprof-context-disambiguation"
 
 STATISTIC(FunctionClonesAnalysis,
CallsiteContextGraph<DerivedCCG, FuncTy, CallTy>::addAllocNode(
   return AllocNode;
 }
 
 template <typename DerivedCCG, typename FuncTy, typename CallTy>
 template <class NodeT, class IteratorT>
 void CallsiteContextGraph<DerivedCCG, FuncTy, CallTy>::addStackNodesForMIB(
     ContextNode *AllocNode, CallStack<NodeT, IteratorT> &StackContext,
     CallStack<NodeT, IteratorT> &CallsiteContext, AllocationType AllocType) {
+  // Treating the hot alloc type as NotCold before the disambiguation for "hot"
+  // is done.
+  if (AllocType == AllocationType::Hot)
+    AllocType = AllocationType::NotCold;
+
   ContextIdToAllocationType[++LastContextId] = AllocType;
 
   // Update alloc type and context ids for this MIB.
   AllocNode->AllocTypes |= (uint8_t)AllocType;
   AllocNode->ContextIds.insert(LastContextId);
 
   // Now add or update nodes for each stack id in alloc's context.
   // Later when processing the stack ids on non-alloc callsites we will adjust

 
 template <typename DerivedCCG, typename FuncTy, typename CallTy>
 void CallsiteContextGraph<DerivedCCG, FuncTy, CallTy>::identifyClones() {
   DenseSet<const ContextNode *> Visited;
   for (auto &Entry : AllocationCallToContextNodeMap)
     identifyClones(Entry.second, Visited);
 }
 
+// helper function to check an AllocType is cold or notcold or both.
+bool checkColdOrNotCold(uint8_t AllocType) {
+  return (AllocType == (uint8_t)AllocationType::Cold) ||
+         (AllocType == (uint8_t)AllocationType::NotCold) ||
+         (AllocType ==
+          ((uint8_t)AllocationType::Cold | (uint8_t)AllocationType::NotCold));
+}
+
 template <typename DerivedCCG, typename FuncTy, typename CallTy>
 void CallsiteContextGraph<DerivedCCG, FuncTy, CallTy>::identifyClones(
     ContextNode *Node, DenseSet<const ContextNode *> &Visited) {
   if (VerifyNodes)
     checkNode<DerivedCCG, FuncTy, CallTy>(Node);
   assert(!Node->CloneOf);
 
   // If Node as a null call, then either it wasn't found in the module (regular
#endif
   // code clones greedily until it finds all remaining edges have the same type
   // and leaves the remaining ones on the original Node).
   //
   // We shouldn't actually have any None type edges, so the sorting priority for
   // that is arbitrary, and we assert in that case below.
   const unsigned AllocTypeCloningPriority[] = {/*None*/ 3, /*NotCold*/ 4,
                                                /*Cold*/ 1,
                                                /*NotColdCold*/ 2};
-  assert(std::size(AllocTypeCloningPriority) ==
-         (std::size_t)AllocationType::All + 1);
   std::stable_sort(Node->CallerEdges.begin(), Node->CallerEdges.end(),
                    [&](const std::shared_ptr<ContextEdge> &A,
                        const std::shared_ptr<ContextEdge> &B) {
-                     assert(A->AllocTypes != (uint8_t)AllocationType::None &&
-                            B->AllocTypes != (uint8_t)AllocationType::None);
+                     assert(checkColdOrNotCold(A->AllocTypes) &&
+                            checkColdOrNotCold(B->AllocTypes));
+
                      if (A->AllocTypes == B->AllocTypes)
                        // Use the first context id for each edge as a
                        // tie-breaker.
                        return *A->ContextIds.begin() < *B->ContextIds.begin();
                      return AllocTypeCloningPriority[A->AllocTypes] <
                             AllocTypeCloningPriority[B->AllocTypes];
                    });
 

llvm/test/Assembler/thinlto-memprof-summary.ll

 ;; Test memprof summary parsing (tests all types/fields in various combinations).
 ; RUN: llvm-as %s -o - | llvm-dis -o - | FileCheck %s
 
 ; ModuleID = 'thinlto-memprof-summary.thinlto.bc'
 
 ^0 = module: (path: "thinlto-memprof-summary.o", hash: (1369602428, 2747878711, 259090915, 2507395659, 1141468049))
 ;; Function with single alloc, multiple memprof MIBs, no versioning
-^1 = gv: (guid: 23, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 2, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), allocs: ((versions: (none), memProf: ((type: notcold, stackIds: (8632435727821051414)), (type: cold, stackIds: (15025054523792398438, 12345678))))))))
+^1 = gv: (guid: 23, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 2, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), allocs: ((versions: (none), memProf: ((type: notcold, stackIds: (8632435727821051414)), (type: cold, stackIds: (15025054523792398438, 12345678)), (type: hot, stackIds: (987654321))))))))
 ;; Function with callsite stack ids calling above function, no versioning
 ^2 = gv: (guid: 25, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 22, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), calls: ((callee: ^1)), callsites: ((callee: ^1, clones: (0), stackIds: (8632435727821051414)), (callee: ^1, clones: (0), stackIds: (15025054523792398438, 12345678)), (callee: ^1, clones: (0), stackIds: (23456789))))))
 ;; Function with multiple allocs, multiple memprof MIBs, multiple versions
 ^3 = gv: (guid: 26, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 2, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), allocs: ((versions: (cold, notcold), memProf: ((type: notcold, stackIds: (3456789)), (type: cold, stackIds: (456789)))), (versions: (notcold, cold), memProf: ((type: cold, stackIds: (3456789)), (type: notcold, stackIds: (456789))))))))
 ;; Function with callsite stack ids calling above function, multiple versions
 ^4 = gv: (guid: 27, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 22, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), calls: ((callee: ^3)), callsites: ((callee: ^3, clones: (0, 1), stackIds: (3456789)), (callee: ^3, clones: (1, 1), stackIds: (456789))))))
 ;; Function with null callsite stack id (can happen in distributed indexes if callsite not imported)
 ^5 = gv: (guid: 28, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 22, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), callsites: ((callee: null, clones: (0), stackIds: (8632435727821051414))))))
 
 ; Make sure we get back from llvm-dis what we put in via llvm-as.
 ; CHECK: ^0 = module: (path: "thinlto-memprof-summary.o", hash: (1369602428, 2747878711, 259090915, 2507395659, 1141468049))
-; CHECK: ^1 = gv: (guid: 23, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 2, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), allocs: ((versions: (none), memProf: ((type: notcold, stackIds: (8632435727821051414)), (type: cold, stackIds: (15025054523792398438, 12345678))))))))
+; CHECK: ^1 = gv: (guid: 23, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 2, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), allocs: ((versions: (none), memProf: ((type: notcold, stackIds: (8632435727821051414)), (type: cold, stackIds: (15025054523792398438, 12345678)), (type: hot, stackIds: (987654321))))))))
 ; CHECK: ^2 = gv: (guid: 25, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 22, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), calls: ((callee: ^1)), callsites: ((callee: ^1, clones: (0), stackIds: (8632435727821051414)), (callee: ^1, clones: (0), stackIds: (15025054523792398438, 12345678)), (callee: ^1, clones: (0), stackIds: (23456789))))))
 ; CHECK: ^3 = gv: (guid: 26, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 2, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), allocs: ((versions: (cold, notcold), memProf: ((type: notcold, stackIds: (3456789)), (type: cold, stackIds: (456789)))), (versions: (notcold, cold), memProf: ((type: cold, stackIds: (3456789)), (type: notcold, stackIds: (456789))))))))
 ; CHECK: ^4 = gv: (guid: 27, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 22, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), calls: ((callee: ^3)), callsites: ((callee: ^3, clones: (0, 1), stackIds: (3456789)), (callee: ^3, clones: (1, 1), stackIds: (456789))))))
 ; CHECK: ^5 = gv: (guid: 28, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 22, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), callsites: ((callee: null, clones: (0), stackIds: (8632435727821051414))))))

llvm/unittests/Analysis/MemoryProfileInfoTest.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/SourceMgr.h"
 #include "gtest/gtest.h"
 #include <cstring>
+#include <sys/types.h>
 
 using namespace llvm;
 using namespace llvm::memprof;
 
 extern cl::opt<float> MemProfLifetimeAccessDensityColdThreshold;
 extern cl::opt<unsigned> MemProfAveLifetimeColdThreshold;
+extern cl::opt<unsigned> MemProfMinAveLifetimeAccessDensityHotThreshold;
 
 namespace {
 
 class MemoryProfileInfoTest : public testing::Test {
 protected:
   std::unique_ptr<Module> makeLLVMModule(LLVMContext &C, const char *IR) {
     SMDiagnostic Err;
     std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);

 // Test getAllocType helper.
 // Basic checks on the allocation type for values just above and below
 // the thresholds.
 TEST_F(MemoryProfileInfoTest, GetAllocType) {
   const uint64_t AllocCount = 2;
   // To be cold we require that
   // ((float)TotalLifetimeAccessDensity) / AllocCount / 100 <
   //    MemProfLifetimeAccessDensityColdThreshold
-  // so compute the TotalLifetimeAccessDensity right at the threshold.
-  const uint64_t TotalLifetimeAccessDensityThreshold =
+  // so compute the ColdTotalLifetimeAccessDensityThreshold at the threshold.
+  const uint64_t ColdTotalLifetimeAccessDensityThreshold =
       (uint64_t)(MemProfLifetimeAccessDensityColdThreshold * AllocCount * 100);
   // To be cold we require that
   // ((float)TotalLifetime) / AllocCount >=
   //    MemProfAveLifetimeColdThreshold * 1000
   // so compute the TotalLifetime right at the threshold.
-  const uint64_t TotalLifetimeThreshold =
+  const uint64_t ColdTotalLifetimeThreshold =
       MemProfAveLifetimeColdThreshold * AllocCount * 1000;
+  // To be hot we require that
+  // ((float)TotalLifetimeAccessDensity) / AllocCount / 100 >
+  //    MemProfMinAveLifetimeAccessDensityHotThreshold
+  // so compute the HotTotalLifetimeAccessDensityThreshold  at the threshold.
+  const uint64_t HotTotalLifetimeAccessDensityThreshold =
+      (uint64_t)(MemProfMinAveLifetimeAccessDensityHotThreshold * AllocCount * 100);  
+   
+  
+  // Test Hot
+  // More accesses per byte per sec than hot threshold is hot.
+  EXPECT_EQ(getAllocType(HotTotalLifetimeAccessDensityThreshold + 1, AllocCount,
+                         ColdTotalLifetimeThreshold + 1),
+            AllocationType::Hot);  
+
+  // Test Cold
+  // Long lived with less accesses per byte per sec than cold threshold is cold.
+  EXPECT_EQ(getAllocType(ColdTotalLifetimeAccessDensityThreshold - 1, AllocCount,
+                         ColdTotalLifetimeThreshold + 1),
+            AllocationType::Cold);
   
-  // Long lived with more accesses per byte per sec than threshold is not cold.
-  EXPECT_EQ(getAllocType(TotalLifetimeAccessDensityThreshold + 1, AllocCount,
-                         TotalLifetimeThreshold + 1),
-            AllocationType::NotCold);
-  // Long lived with less accesses per byte per sec than threshold is cold.
-  EXPECT_EQ(getAllocType(TotalLifetimeAccessDensityThreshold - 1, AllocCount,
-                         TotalLifetimeThreshold + 1),
-            AllocationType::Cold);
-  // Short lived with more accesses per byte per sec than threshold is not cold.
-  EXPECT_EQ(getAllocType(TotalLifetimeAccessDensityThreshold + 1, AllocCount,
-                         TotalLifetimeThreshold - 1),
+  // Test NotCold
+  // Long lived with more accesses per byte per sec than cold threshold is not cold.
+  EXPECT_EQ(getAllocType(ColdTotalLifetimeAccessDensityThreshold + 1, AllocCount,
+                         ColdTotalLifetimeThreshold + 1),
+            AllocationType::NotCold);  
+  // Short lived with more accesses per byte per sec than cold threshold is not cold.
+  EXPECT_EQ(getAllocType(ColdTotalLifetimeAccessDensityThreshold + 1, AllocCount,
+                         ColdTotalLifetimeThreshold - 1),
             AllocationType::NotCold);
-  // Short lived with less accesses per byte per sec than threshold is not cold.
-  EXPECT_EQ(getAllocType(TotalLifetimeAccessDensityThreshold - 1, AllocCount,
-                         TotalLifetimeThreshold - 1),
+  // Short lived with less accesses per byte per sec than cold threshold is not cold.
+  EXPECT_EQ(getAllocType(ColdTotalLifetimeAccessDensityThreshold - 1, AllocCount,
+                         ColdTotalLifetimeThreshold - 1),
             AllocationType::NotCold);
 }
 
 // Test the hasSingleAllocType helper.
 TEST_F(MemoryProfileInfoTest, SingleAllocType) {
   uint8_t NotCold = (uint8_t)AllocationType::NotCold;
   uint8_t Cold = (uint8_t)AllocationType::Cold;
+  uint8_t Hot = (uint8_t)AllocationType::Hot;
   EXPECT_TRUE(hasSingleAllocType(NotCold));
   EXPECT_TRUE(hasSingleAllocType(Cold));
+  EXPECT_TRUE(hasSingleAllocType(Hot));
   EXPECT_FALSE(hasSingleAllocType(NotCold | Cold));
+  EXPECT_FALSE(hasSingleAllocType(NotCold | Hot));
+  EXPECT_FALSE(hasSingleAllocType(Cold | Hot));
+  EXPECT_FALSE(hasSingleAllocType(NotCold | Cold | Hot));
 }
 
 // Test buildCallstackMetadata helper.
 TEST_F(MemoryProfileInfoTest, BuildCallStackMD) {
   LLVMContext C;
   MDNode *CallStack = buildCallstackMetadata({1, 2, 3}, C);
   ASSERT_EQ(CallStack->getNumOperands(), 3u);
   unsigned ExpectedId = 1;

 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 define i32* @test() {
 entry:
   %call1 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40)
   %0 = bitcast i8* %call1 to i32*
   %call2 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40)
   %1 = bitcast i8* %call2 to i32*
+  %call3 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40)
+  %2 = bitcast i8* %call3 to i32*  
   ret i32* %1
 }
 declare dso_local noalias noundef i8* @malloc(i64 noundef)
 )IR");
 
   Function *Func = M->getFunction("test");
 
   // First call has all cold contexts.
)IR");
   Trie2.addCallStack(AllocationType::NotCold, {5, 6});
   Trie2.addCallStack(AllocationType::NotCold, {5, 7, 8});
   CallBase *Call2 = findCall(*Func, "call2");
   Trie2.buildAndAttachMIBMetadata(Call2);
 
   EXPECT_FALSE(Call2->hasMetadata(LLVMContext::MD_memprof));
   EXPECT_TRUE(Call2->hasFnAttr("memprof"));
   EXPECT_EQ(Call2->getFnAttr("memprof").getValueAsString(), "notcold");
+
+  // Third call has all hot contexts.
+  CallStackTrie Trie3;
+  Trie3.addCallStack(AllocationType::Hot, {9, 10});
+  Trie3.addCallStack(AllocationType::Hot, {9, 11, 12});
+  CallBase *Call3 = findCall(*Func, "call3");
+  Trie3.buildAndAttachMIBMetadata(Call3);
+
+  EXPECT_FALSE(Call3->hasMetadata(LLVMContext::MD_memprof));
+  EXPECT_TRUE(Call3->hasFnAttr("memprof"));
+  EXPECT_EQ(Call3->getFnAttr("memprof").getValueAsString(), "hot");
 }
 
 // Test CallStackTrie::addCallStack interface taking allocation type and list of
 // call stack ids.
 // Test that an allocation call reached by both cold and non cold call stacks
 // gets memprof metadata representing the different allocation type contexts.
 TEST_F(MemoryProfileInfoTest, ColdAndNotColdMIB) {
   LLVMContext C;
else {
       ASSERT_EQ(StackId->getZExtValue(), 3u);
       EXPECT_EQ(getMIBAllocType(MIB), AllocationType::NotCold);
     }
   }
 }
 
 // Test CallStackTrie::addCallStack interface taking allocation type and list of
 // call stack ids.
+// Test that an allocation call reached by both cold and hot call stacks
+// gets memprof metadata representing the different allocation type contexts.
+TEST_F(MemoryProfileInfoTest, ColdAndHotMIB) {
+  LLVMContext C;
+  std::unique_ptr<Module> M = makeLLVMModule(C,
+                                             R"IR(
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-linux-gnu"
+define i32* @test() {
+entry:
+  %call = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40)
+  %0 = bitcast i8* %call to i32*
+  ret i32* %0
+}
+declare dso_local noalias noundef i8* @malloc(i64 noundef)
+)IR");
+
+  Function *Func = M->getFunction("test");
+
+  CallStackTrie Trie;
+  Trie.addCallStack(AllocationType::Cold, {1, 2});
+  Trie.addCallStack(AllocationType::Hot, {1, 3});
+
+  CallBase *Call = findCall(*Func, "call");
+  Trie.buildAndAttachMIBMetadata(Call);
+
+  EXPECT_FALSE(Call->hasFnAttr("memprof"));
+  EXPECT_TRUE(Call->hasMetadata(LLVMContext::MD_memprof));
+  MDNode *MemProfMD = Call->getMetadata(LLVMContext::MD_memprof);
+  ASSERT_EQ(MemProfMD->getNumOperands(), 2u);
+  for (auto &MIBOp : MemProfMD->operands()) {
+    MDNode *MIB = dyn_cast<MDNode>(MIBOp);
+    MDNode *StackMD = getMIBStackNode(MIB);
+    ASSERT_NE(StackMD, nullptr);
+    ASSERT_EQ(StackMD->getNumOperands(), 2u);
+    auto *StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(0));
+    ASSERT_EQ(StackId->getZExtValue(), 1u);
+    StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(1));
+    if (StackId->getZExtValue() == 2u)
+      EXPECT_EQ(getMIBAllocType(MIB), AllocationType::Cold);
+    else {
+      ASSERT_EQ(StackId->getZExtValue(), 3u);
+      EXPECT_EQ(getMIBAllocType(MIB), AllocationType::Hot);
+    }
+  }
+}
+
+// Test CallStackTrie::addCallStack interface taking allocation type and list of
+// call stack ids.
+// Test that an allocation call reached by both non cold and hot call stacks
+// gets memprof metadata representing the different allocation type contexts.
+TEST_F(MemoryProfileInfoTest, NotColdAndHotMIB) {
+  LLVMContext C;
+  std::unique_ptr<Module> M = makeLLVMModule(C,
+                                             R"IR(
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-linux-gnu"
+define i32* @test() {
+entry:
+  %call = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40)
+  %0 = bitcast i8* %call to i32*
+  ret i32* %0
+}
+declare dso_local noalias noundef i8* @malloc(i64 noundef)
+)IR");
+
+  Function *Func = M->getFunction("test");
+
+  CallStackTrie Trie;
+  Trie.addCallStack(AllocationType::NotCold, {1, 2});
+  Trie.addCallStack(AllocationType::Hot, {1, 3});
+
+  CallBase *Call = findCall(*Func, "call");
+  Trie.buildAndAttachMIBMetadata(Call);
+
+  EXPECT_FALSE(Call->hasFnAttr("memprof"));
+  EXPECT_TRUE(Call->hasMetadata(LLVMContext::MD_memprof));
+  MDNode *MemProfMD = Call->getMetadata(LLVMContext::MD_memprof);
+  ASSERT_EQ(MemProfMD->getNumOperands(), 2u);
+  for (auto &MIBOp : MemProfMD->operands()) {
+    MDNode *MIB = dyn_cast<MDNode>(MIBOp);
+    MDNode *StackMD = getMIBStackNode(MIB);
+    ASSERT_NE(StackMD, nullptr);
+    ASSERT_EQ(StackMD->getNumOperands(), 2u);
+    auto *StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(0));
+    ASSERT_EQ(StackId->getZExtValue(), 1u);
+    StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(1));
+    if (StackId->getZExtValue() == 2u)
+      EXPECT_EQ(getMIBAllocType(MIB), AllocationType::NotCold);
+    else {
+      ASSERT_EQ(StackId->getZExtValue(), 3u);
+      EXPECT_EQ(getMIBAllocType(MIB), AllocationType::Hot);
+    }
+  }
+}
+
+// Test CallStackTrie::addCallStack interface taking allocation type and list of
+// call stack ids.
+// Test that an allocation call reached by both cold, non cold and hot call
+// stacks gets memprof metadata representing the different allocation type
+// contexts.
+TEST_F(MemoryProfileInfoTest, ColdAndNotColdAndHotMIB) {
+  LLVMContext C;
+  std::unique_ptr<Module> M = makeLLVMModule(C,
+                                             R"IR(
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-linux-gnu"
+define i32* @test() {
+entry:
+  %call = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40)
+  %0 = bitcast i8* %call to i32*
+  ret i32* %0
+}
+declare dso_local noalias noundef i8* @malloc(i64 noundef)
+)IR");
+
+  Function *Func = M->getFunction("test");
+
+  CallStackTrie Trie;
+  Trie.addCallStack(AllocationType::Cold, {1, 2});
+  Trie.addCallStack(AllocationType::NotCold, {1, 3});
+  Trie.addCallStack(AllocationType::Hot, {1, 4});
+
+  CallBase *Call = findCall(*Func, "call");
+  Trie.buildAndAttachMIBMetadata(Call);
+
+  EXPECT_FALSE(Call->hasFnAttr("memprof"));
+  EXPECT_TRUE(Call->hasMetadata(LLVMContext::MD_memprof));
+  MDNode *MemProfMD = Call->getMetadata(LLVMContext::MD_memprof);
+  ASSERT_EQ(MemProfMD->getNumOperands(), 3u);
+  for (auto &MIBOp : MemProfMD->operands()) {
+    MDNode *MIB = dyn_cast<MDNode>(MIBOp);
+    MDNode *StackMD = getMIBStackNode(MIB);
+    ASSERT_NE(StackMD, nullptr);
+    ASSERT_EQ(StackMD->getNumOperands(), 2u);
+    auto *StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(0));
+    ASSERT_EQ(StackId->getZExtValue(), 1u);
+    StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(1));
+    if (StackId->getZExtValue() == 2u) {
+      EXPECT_EQ(getMIBAllocType(MIB), AllocationType::Cold);
+    } else if (StackId->getZExtValue() == 3u) {
+      EXPECT_EQ(getMIBAllocType(MIB), AllocationType::NotCold);
+    } else {
+      ASSERT_EQ(StackId->getZExtValue(), 4u);
+      EXPECT_EQ(getMIBAllocType(MIB), AllocationType::Hot);
+    }
+  }
+}
+
+// Test CallStackTrie::addCallStack interface taking allocation type and list of
+// call stack ids.
 // Test that an allocation call reached by multiple call stacks has memprof
 // metadata with the contexts trimmed to the minimum context required to
 // identify the allocation type.
 TEST_F(MemoryProfileInfoTest, TrimmedMIBContext) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
)IR");
   // We should be able to trim the following two and combine into a single MIB
   // with the cold context {1, 2}.
   Trie.addCallStack(AllocationType::Cold, {1, 2, 3});
   Trie.addCallStack(AllocationType::Cold, {1, 2, 4});
   // We should be able to trim the following two and combine into a single MIB
   // with the non-cold context {1, 5}.
   Trie.addCallStack(AllocationType::NotCold, {1, 5, 6});
   Trie.addCallStack(AllocationType::NotCold, {1, 5, 7});
+  // We should be able to trim the following two and combine into a single MIB
+  // with the hot context {1, 8}.
+  Trie.addCallStack(AllocationType::Hot, {1, 8, 9});
+  Trie.addCallStack(AllocationType::Hot, {1, 8, 10});
 
   CallBase *Call = findCall(*Func, "call");
   Trie.buildAndAttachMIBMetadata(Call);
 
   EXPECT_FALSE(Call->hasFnAttr("memprof"));
   EXPECT_TRUE(Call->hasMetadata(LLVMContext::MD_memprof));
   MDNode *MemProfMD = Call->getMetadata(LLVMContext::MD_memprof);
-  ASSERT_EQ(MemProfMD->getNumOperands(), 2u);
+  ASSERT_EQ(MemProfMD->getNumOperands(), 3u);
   for (auto &MIBOp : MemProfMD->operands()) {
     MDNode *MIB = dyn_cast<MDNode>(MIBOp);
     MDNode *StackMD = getMIBStackNode(MIB);
     ASSERT_NE(StackMD, nullptr);
     ASSERT_EQ(StackMD->getNumOperands(), 2u);
     auto *StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(0));
     EXPECT_EQ(StackId->getZExtValue(), 1u);
     StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(1));
     if (StackId->getZExtValue() == 2u)
       EXPECT_EQ(getMIBAllocType(MIB), AllocationType::Cold);
-    else {
-      ASSERT_EQ(StackId->getZExtValue(), 5u);
+    else if (StackId->getZExtValue() == 5u)
       EXPECT_EQ(getMIBAllocType(MIB), AllocationType::NotCold);
+    else {
+      ASSERT_EQ(StackId->getZExtValue(), 8u);
+      EXPECT_EQ(getMIBAllocType(MIB), AllocationType::Hot);
     }
   }
 }
 
 // Test CallStackTrie::addCallStack interface taking memprof MIB metadata.
 // Check that allocations annotated with memprof metadata with a single
 // allocation type get simplified to an attribute.
 TEST_F(MemoryProfileInfoTest, SimplifyMIBToAttribute) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 define i32* @test() {
 entry:
   %call1 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !0
   %0 = bitcast i8* %call1 to i32*
   %call2 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !3
   %1 = bitcast i8* %call2 to i32*
+  %call3 = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !6
+  %2 = bitcast i8* %call3 to i32*
   ret i32* %1
 }
 declare dso_local noalias noundef i8* @malloc(i64 noundef)
 !0 = !{!1}
 !1 = !{!2, !"cold"}
 !2 = !{i64 1, i64 2, i64 3}
 !3 = !{!4}
 !4 = !{!5, !"notcold"}
 !5 = !{i64 4, i64 5, i64 6, i64 7}
+!6 = !{!7}
+!7 = !{!8, !"hot"}
+!8 = !{i64 8, i64 9, i64 10}
 )IR");
 
   Function *Func = M->getFunction("test");
 
   // First call has all cold contexts.
   CallStackTrie Trie1;
   CallBase *Call1 = findCall(*Func, "call1");
   MDNode *MemProfMD1 = Call1->getMetadata(LLVMContext::MD_memprof);
)IR");
   MDNode *MemProfMD2 = Call2->getMetadata(LLVMContext::MD_memprof);
   ASSERT_EQ(MemProfMD2->getNumOperands(), 1u);
   MDNode *MIB2 = dyn_cast<MDNode>(MemProfMD2->getOperand(0));
   Trie2.addCallStack(MIB2);
   Trie2.buildAndAttachMIBMetadata(Call2);
 
   EXPECT_TRUE(Call2->hasFnAttr("memprof"));
   EXPECT_EQ(Call2->getFnAttr("memprof").getValueAsString(), "notcold");
+
+  // Third call has all hot contexts.
+  CallStackTrie Trie3;
+  CallBase *Call3 = findCall(*Func, "call3");
+  MDNode *MemProfMD3 = Call3->getMetadata(LLVMContext::MD_memprof);
+  ASSERT_EQ(MemProfMD2->getNumOperands(), 1u);
+  MDNode *MIB3 = dyn_cast<MDNode>(MemProfMD3->getOperand(0));
+  Trie3.addCallStack(MIB3);
+  Trie3.buildAndAttachMIBMetadata(Call3);
+
+  EXPECT_TRUE(Call3->hasFnAttr("memprof"));
+  EXPECT_EQ(Call3->getFnAttr("memprof").getValueAsString(), "hot");
 }
 
 // Test CallStackTrie::addCallStack interface taking memprof MIB metadata.
 // Test that allocations annotated with memprof metadata with multiple call
 // stacks gets new memprof metadata with the contexts trimmed to the minimum
 // context required to identify the allocation type.
 TEST_F(MemoryProfileInfoTest, ReTrimMIBContext) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 define i32* @test() {
 entry:
   %call = call noalias dereferenceable_or_null(40) i8* @malloc(i64 noundef 40), !memprof !0
   %0 = bitcast i8* %call to i32*
   ret i32* %0
 }
 declare dso_local noalias noundef i8* @malloc(i64 noundef)
-!0 = !{!1, !3, !5, !7}
+!0 = !{!1, !3, !5, !7, !9, !11}
 !1 = !{!2, !"cold"}
 !2 = !{i64 1, i64 2, i64 3}
 !3 = !{!4, !"cold"}
 !4 = !{i64 1, i64 2, i64 4}
 !5 = !{!6, !"notcold"}
 !6 = !{i64 1, i64 5, i64 6}
 !7 = !{!8, !"notcold"}
 !8 = !{i64 1, i64 5, i64 7}
+!9 = !{!10, !"hot"}
+!10 = !{i64 1, i64 8, i64 9}
+!11 = !{!12, !"hot"}
+!12 = !{i64 1, i64 8, i64 10}  
 )IR");
 
   Function *Func = M->getFunction("test");
 
   CallStackTrie Trie;
   ASSERT_TRUE(Trie.empty());
   CallBase *Call = findCall(*Func, "call");
   MDNode *MemProfMD = Call->getMetadata(LLVMContext::MD_memprof);
   for (auto &MIBOp : MemProfMD->operands()) {
     MDNode *MIB = dyn_cast<MDNode>(MIBOp);
     Trie.addCallStack(MIB);
   }
   ASSERT_FALSE(Trie.empty());
   Trie.buildAndAttachMIBMetadata(Call);
 
   // We should be able to trim the first two and combine into a single MIB
   // with the cold context {1, 2}.
   // We should be able to trim the second two and combine into a single MIB
   // with the non-cold context {1, 5}.
 
   EXPECT_FALSE(Call->hasFnAttr("memprof"));
   EXPECT_TRUE(Call->hasMetadata(LLVMContext::MD_memprof));
   MemProfMD = Call->getMetadata(LLVMContext::MD_memprof);
-  ASSERT_EQ(MemProfMD->getNumOperands(), 2u);
+  ASSERT_EQ(MemProfMD->getNumOperands(), 3u);
   for (auto &MIBOp : MemProfMD->operands()) {
     MDNode *MIB = dyn_cast<MDNode>(MIBOp);
     MDNode *StackMD = getMIBStackNode(MIB);
     ASSERT_NE(StackMD, nullptr);
     ASSERT_EQ(StackMD->getNumOperands(), 2u);
     auto *StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(0));
     EXPECT_EQ(StackId->getZExtValue(), 1u);
     StackId = mdconst::dyn_extract<ConstantInt>(StackMD->getOperand(1));
     if (StackId->getZExtValue() == 2u)
       EXPECT_EQ(getMIBAllocType(MIB), AllocationType::Cold);
-    else {
-      ASSERT_EQ(StackId->getZExtValue(), 5u);
+    else if (StackId->getZExtValue() == 5u)
       EXPECT_EQ(getMIBAllocType(MIB), AllocationType::NotCold);
+    else {
+      ASSERT_EQ(StackId->getZExtValue(), 8u);
+      EXPECT_EQ(getMIBAllocType(MIB), AllocationType::Hot);
     }
   }
 }
 
 TEST_F(MemoryProfileInfoTest, CallStackTestIR) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 define ptr @test() {
 entry:
   %call = call noalias noundef nonnull dereferenceable(10) ptr @_Znam(i64 noundef 10), !memprof !1, !callsite !6
   ret ptr %call
 }
 declare noundef nonnull ptr @_Znam(i64 noundef)
-!1 = !{!2, !4}
+!1 = !{!2, !4, !7}
 !2 = !{!3, !"notcold"}
 !3 = !{i64 1, i64 2, i64 3, i64 4}
 !4 = !{!5, !"cold"}
 !5 = !{i64 1, i64 2, i64 3, i64 5}
 !6 = !{i64 1}
+!7 = !{!8, !"hot"}
+!8 = !{i64 1, i64 2, i64 3, i64 6}  
 )IR");
 
   Function *Func = M->getFunction("test");
   CallBase *Call = findCall(*Func, "call");
 
   CallStack<MDNode, MDNode::op_iterator> InstCallsite(
       Call->getMetadata(LLVMContext::MD_callsite));
 
   MDNode *MemProfMD = Call->getMetadata(LLVMContext::MD_memprof);
-  bool First = true;
+  uint Idx = 0;
   for (auto &MIBOp : MemProfMD->operands()) {
     auto *MIBMD = cast<const MDNode>(MIBOp);
     MDNode *StackNode = getMIBStackNode(MIBMD);
     CallStack<MDNode, MDNode::op_iterator> StackContext(StackNode);
-    uint64_t ExpectedBack = First ? 4 : 5;
-    EXPECT_EQ(StackContext.back(), ExpectedBack);
+    EXPECT_EQ(StackContext.back(), 4 + Idx);
     std::vector<uint64_t> StackIds;
     for (auto ContextIter = StackContext.beginAfterSharedPrefix(InstCallsite);
          ContextIter != StackContext.end(); ++ContextIter)
       StackIds.push_back(*ContextIter);
-    if (First) {
+    if (Idx == 0) {
       std::vector<uint64_t> Expected = {2, 3, 4};
       EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
-    } else {
+    } else if (Idx == 1) {
       std::vector<uint64_t> Expected = {2, 3, 5};
       EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
+    } else {
+      std::vector<uint64_t> Expected = {2, 3, 6};
+      EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
     }
-    First = false;
+    Idx++;
   }
 }
 
 TEST_F(MemoryProfileInfoTest, CallStackTestSummary) {
   std::unique_ptr<ModuleSummaryIndex> Index = makeLLVMIndex(R"Summary(
 ^0 = module: (path: "test.o", hash: (0, 0, 0, 0, 0))
-^1 = gv: (guid: 23, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 2, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), allocs: ((versions: (none), memProf: ((type: notcold, stackIds: (1, 2, 3, 4)), (type: cold, stackIds: (1, 2, 3, 5))))))))
-^2 = gv: (guid: 25, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 22, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), calls: ((callee: ^1)), callsites: ((callee: ^1, clones: (0), stackIds: (3, 4)), (callee: ^1, clones: (0), stackIds: (3, 5))))))
+^1 = gv: (guid: 23, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 2, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), allocs: ((versions: (none), memProf: ((type: notcold, stackIds: (1, 2, 3, 4)), (type: cold, stackIds: (1, 2, 3, 5)), (type: hot, stackIds: (1, 2, 3, 6))))))))
+^2 = gv: (guid: 25, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 22, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0, noUnwind: 0, mayThrow: 0, hasUnknownCall: 0, mustBeUnreachable: 0), calls: ((callee: ^1)), callsites: ((callee: ^1, clones: (0), stackIds: (3, 4)), (callee: ^1, clones: (0), stackIds: (3, 5)), (callee: ^1, clones: (0), stackIds: (3, 6))))))
 )Summary");
 
   ASSERT_NE(Index, nullptr);
   auto *CallsiteSummary =
       cast<FunctionSummary>(Index->getGlobalValueSummary(/*guid=*/25));
-  bool First = true;
+  uint Idx = 0;
   for (auto &CI : CallsiteSummary->callsites()) {
     CallStack<CallsiteInfo, SmallVector<unsigned>::const_iterator> InstCallsite(
         &CI);
     std::vector<uint64_t> StackIds;
     for (auto StackIdIndex : InstCallsite)
       StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex));
-    if (First) {
+    if (Idx == 0) {
       std::vector<uint64_t> Expected = {3, 4};
       EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
-    } else {
+    } else if (Idx == 1) {
       std::vector<uint64_t> Expected = {3, 5};
       EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
+    } else {
+      std::vector<uint64_t> Expected = {3, 6};
+      EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
     }
-    First = false;
+    Idx++;
   }
 
   auto *AllocSummary =
       cast<FunctionSummary>(Index->getGlobalValueSummary(/*guid=*/23));
   for (auto &AI : AllocSummary->allocs()) {
-    bool First = true;
+    uint Idx = 0;
     for (auto &MIB : AI.MIBs) {
       CallStack<MIBInfo, SmallVector<unsigned>::const_iterator> StackContext(
           &MIB);
-      uint64_t ExpectedBack = First ? 4 : 5;
-      EXPECT_EQ(Index->getStackIdAtIndex(StackContext.back()), ExpectedBack);
+      EXPECT_EQ(Index->getStackIdAtIndex(StackContext.back()), 4 + Idx);
       std::vector<uint64_t> StackIds;
       for (auto StackIdIndex : StackContext)
         StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex));
-      if (First) {
+      if (Idx == 0) {
         std::vector<uint64_t> Expected = {1, 2, 3, 4};
         EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
-      } else {
+      } else if (Idx == 1) {
         std::vector<uint64_t> Expected = {1, 2, 3, 5};
         EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
+      } else {
+        std::vector<uint64_t> Expected = {1, 2, 3, 6};
+        EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected));
       }
-      First = false;
+      Idx++;
     }
   }
 }
 } // end anonymous namespace