[CodeLayout] Add unittest for cache-directed sort

[MaskRay]

Summary

The function reordering algorithm added by https://reviews.llvm.org/D152834 and
used by BOLT (https://reviews.llvm.org/D153039) is untested.

Add some tests at the appropriate layer.

Depends on D159526

[MaskRay]

rebase

[MaskRay]

rebase

[rahmanl]

Another example would be where the algorithm stops merging functions (with call edges) because the temporal locality degrades too much, but this can be done in a separate patch.

llvm/unittests/Transforms/Utils/CodeLayoutTest.cpp

15

I might be missing something. Isn't this supposed to be the same size as Counts?

[spupyrev]

llvm/unittests/Transforms/Utils/CodeLayoutTest.cpp

15

I agree. Does it make sense to add an assertion to catch such problems?

[MaskRay]

llvm/unittests/Transforms/Utils/CodeLayoutTest.cpp

15

I think the code is correct. The https://en.cppreference.com/w/cpp/container/vector/vector (3) overload (size_type count, const T& value) is picked. Sizes.size() == std::size(Counts).

[spupyrev]

I'd suggest to explicitly initialize Sizes for each element to improve readability and avoid confusion.

[MaskRay]

Use std::size to avoid referencing vector size by integer literals

llvm/test/CodeGen/X86/code_placement_ext_tsp.ll

+;; See also llvm/unittests/Transforms/Utils/CodeLayoutTest.cpp
 ; RUN: llc -mcpu=corei7 -mtriple=x86_64-linux -enable-ext-tsp-block-placement=1 < %s | FileCheck %s
 ; RUN: llc -mcpu=corei7 -mtriple=x86_64-linux -enable-ext-tsp-block-placement=1 -ext-tsp-chain-split-threshold=0 -ext-tsp-enable-chain-split-along-jumps=0 < %s | FileCheck %s -check-prefix=CHECK2
 
 define void @func1a()  {
 ; Test that the algorithm positions the most likely successor first
 ;
 ; +-----+
 ; | b0  | -+

llvm/unittests/Transforms/Utils/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   )
 
 add_llvm_unittest(UtilsTests
   ASanStackFrameLayoutTest.cpp
   BasicBlockUtilsTest.cpp
   CallPromotionUtilsTest.cpp
   CloningTest.cpp
   CodeExtractorTest.cpp
+  CodeLayoutTest.cpp
   CodeMoverUtilsTest.cpp
   DebugifyTest.cpp
   FunctionComparatorTest.cpp
   IntegerDivisionTest.cpp
   LocalTest.cpp
   LoopRotationUtilsTest.cpp
   LoopUtilsTest.cpp
   MemTransferLowering.cpp

llvm/unittests/Transforms/Utils/CodeLayoutTest.cpp

+#include "llvm/Transforms/Utils/CodeLayout.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include <vector>
+
+using namespace llvm;
+using namespace llvm::codelayout;
+using testing::ElementsAreArray;
+
+namespace {
+TEST(CodeLayout, ThreeFunctions) {
+  // Place the most likely successor (2) first.
+  {
+    const uint64_t Counts[3] = {140, 40, 140};
+    const std::vector<uint64_t> Sizes(std::size(Counts), 9);
+    const EdgeCount Edges[] = {{0, 1, 40}, {0, 2, 100}, {1, 2, 40}};
+    const std::vector<uint64_t> CallOffsets(std::size(Edges), 5);
+    auto Order = computeCacheDirectedLayout(Sizes, Counts, Edges, CallOffsets);
+    EXPECT_THAT(Order, ElementsAreArray({0, 2, 1}));
+  }
+
+  // Prefer fallthroughs even in the presence of a heavy successor.
+  {
+    const uint64_t Counts[3] = {180, 80, 180};
+    const std::vector<uint64_t> Sizes(std::size(Counts), 9);
+    const EdgeCount Edges[] = {{0, 1, 80}, {0, 2, 100}, {1, 2, 80}};
+    const uint64_t CallOffsets[] = {9, 5, 9};
+    auto Order = computeCacheDirectedLayout(Sizes, Counts, Edges, CallOffsets);
+    EXPECT_THAT(Order, ElementsAreArray({0, 1, 2}));
+  }
+}
+
+TEST(CodeLayout, HotChain) {
+  // Place the hot chain (0,3,4,2) continuously.
+  {
+    const uint64_t Counts[5] = {22, 7, 22, 15, 46};
+    const std::vector<uint64_t> Sizes(std::size(Counts), 9);
+    const EdgeCount Edges[] = {{0, 1, 7},  {1, 2, 7},  {0, 3, 15},
+                               {3, 4, 15}, {4, 4, 31}, {4, 2, 15}};
+    const std::vector<uint64_t> CallOffsets(std::size(Edges), 5);
+    auto Order = computeCacheDirectedLayout(Sizes, Counts, Edges, CallOffsets);
+    EXPECT_THAT(Order, ElementsAreArray({0, 3, 4, 2, 1}));
+  }
+}
+
+TEST(CodeLayout, BreakLoop) {
+  // There are two loops (1,2,3) and (1,2,4). It is beneficial to place 4
+  // elsewhere.
+  const uint64_t Counts[6] = {177, 371, 196, 124, 70, 177};
+  std::vector<uint64_t> Sizes(std::size(Counts), 9);
+  const EdgeCount Edges[] = {{0, 1, 177}, {1, 2, 196}, {2, 3, 124}, {3, 1, 124},
+                             {1, 5, 177}, {2, 4, 79},  {4, 1, 70}};
+  const std::vector<uint64_t> CallOffsets(std::size(Edges), 5);
+  auto Order = computeCacheDirectedLayout(Sizes, Counts, Edges, CallOffsets);
+  EXPECT_THAT(Order, ElementsAreArray({4, 0, 1, 2, 3, 5}));
+
+  // When node 0 is larger, it is beneficial to move node 4 closer to the
+  // (1,2,3) loop.
+  Sizes[0] = 18;
+  Order = computeCacheDirectedLayout(Sizes, Counts, Edges, CallOffsets);
+  EXPECT_THAT(Order, ElementsAreArray({0, 4, 1, 2, 3, 5}));
+}
+} // namespace