llvm/unittests/XRay/ProfileTest.cpp

//===- ProfileTest.cpp - XRay Profile unit tests ----------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/XRay/Profile.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

#include <numeric>

namespace llvm {
namespace xray {
namespace {

using ::testing::AllOf;
using ::testing::ElementsAre;
using ::testing::Eq;
using ::testing::Field;
using ::testing::Not;
using ::testing::Pair;
using ::testing::UnorderedElementsAre;

TEST(ProfileTest, CreateProfile) { Profile P; }

TEST(ProfileTest, InternPath) {
  Profile P;
  auto Path0 = P.internPath({3, 2, 1});
  auto Path1 = P.internPath({3, 2, 1});
  auto Path2 = P.internPath({2, 1});
  EXPECT_THAT(Path0, Eq(Path1));
  EXPECT_THAT(Path0, Not(Eq(Path2)));
}

TEST(ProfileTest, ExpandPath) {
  Profile P;
  auto PathID = P.internPath({3, 2, 1});
  auto PathOrError = P.expandPath(PathID);
  if (!PathOrError)
    FAIL() << "Error: " << PathOrError.takeError();
  EXPECT_THAT(PathOrError.get(), ElementsAre(3, 2, 1));
}

TEST(ProfileTest, AddBlocks) {
  Profile P;
  // Expect an error on adding empty blocks.
  EXPECT_TRUE(errorToBool(P.addBlock({})));

  // Thread blocks may not be empty.
  EXPECT_TRUE(errorToBool(P.addBlock({1, {}})));

  // Thread blocks with data must succeed.
  EXPECT_FALSE(errorToBool(P.addBlock(
      Profile::Block{Profile::ThreadID{1},
                     {
                         {P.internPath({2, 1}), Profile::Data{1, 1000}},
                         {P.internPath({3, 2, 1}), Profile::Data{10, 100}},
                     }})));
}

TEST(ProfileTest, CopyProfile) {
  Profile P0, P1;
  EXPECT_FALSE(errorToBool(P0.addBlock(
      Profile::Block{Profile::ThreadID{1},
                     {
                         {P0.internPath({2, 1}), Profile::Data{1, 1000}},
                         {P0.internPath({3, 2, 1}), Profile::Data{10, 100}},
                     }})));
  P1 = P0;
  EXPECT_THAT(
      P1, UnorderedElementsAre(AllOf(
              Field(&Profile::Block::Thread, Eq(Profile::ThreadID{1})),
              Field(&Profile::Block::PathData,
                    UnorderedElementsAre(
                        Pair(P1.internPath({2, 1}),
                             AllOf(Field(&Profile::Data::CallCount, Eq(1u)),
                                   Field(&Profile::Data::CumulativeLocalTime,
                                         Eq(1000u)))),
                        Pair(P1.internPath({3, 2, 1}),
                             AllOf(Field(&Profile::Data::CallCount, Eq(10u)),
                                   Field(&Profile::Data::CumulativeLocalTime,
                                         Eq(100u)))))))));
}

TEST(ProfileTest, MoveProfile) {
  Profile P0, P1;
  EXPECT_FALSE(errorToBool(P0.addBlock(
      Profile::Block{Profile::ThreadID{1},
                     {
                         {P0.internPath({2, 1}), Profile::Data{1, 1000}},
                         {P0.internPath({3, 2, 1}), Profile::Data{10, 100}},
                     }})));
  P1 = std::move(P0);
  EXPECT_THAT(
      P1, UnorderedElementsAre(AllOf(
              Field(&Profile::Block::Thread, Eq(Profile::ThreadID{1})),
              Field(&Profile::Block::PathData,
                    UnorderedElementsAre(
                        Pair(P1.internPath({2, 1}),
                             AllOf(Field(&Profile::Data::CallCount, Eq(1u)),
                                   Field(&Profile::Data::CumulativeLocalTime,
                                         Eq(1000u)))),
                        Pair(P1.internPath({3, 2, 1}),
                             AllOf(Field(&Profile::Data::CallCount, Eq(10u)),
                                   Field(&Profile::Data::CumulativeLocalTime,
                                         Eq(100u)))))))));
  EXPECT_THAT(P0, UnorderedElementsAre());
}

TEST(ProfileTest, MergeProfilesByThread) {
  Profile P0, P1;

  // Set up the blocks for two different threads in P0.
  EXPECT_FALSE(errorToBool(P0.addBlock(
      Profile::Block{Profile::ThreadID{1},
                     {{P0.internPath({2, 1}), Profile::Data{1, 1000}},
                      {P0.internPath({4, 1}), Profile::Data{1, 1000}}}})));
  EXPECT_FALSE(errorToBool(P0.addBlock(
      Profile::Block{Profile::ThreadID{2},
                     {{P0.internPath({3, 1}), Profile::Data{1, 1000}}}})));

  // Set up the blocks for two different threads in P1.
  EXPECT_FALSE(errorToBool(P1.addBlock(
      Profile::Block{Profile::ThreadID{1},
                     {{P1.internPath({2, 1}), Profile::Data{1, 1000}}}})));
  EXPECT_FALSE(errorToBool(P1.addBlock(
      Profile::Block{Profile::ThreadID{2},
                     {{P1.internPath({3, 1}), Profile::Data{1, 1000}},
                      {P1.internPath({4, 1}), Profile::Data{1, 1000}}}})));

  Profile Merged = mergeProfilesByThread(P0, P1);
  EXPECT_THAT(
      Merged,
      UnorderedElementsAre(
          // We want to see two threads after the merge.
          AllOf(Field(&Profile::Block::Thread, Eq(Profile::ThreadID{1})),
                Field(&Profile::Block::PathData,
                      UnorderedElementsAre(
                          Pair(Merged.internPath({2, 1}),
                               AllOf(Field(&Profile::Data::CallCount, Eq(2u)),
                                     Field(&Profile::Data::CumulativeLocalTime,
                                           Eq(2000u)))),
                          Pair(Merged.internPath({4, 1}),
                               AllOf(Field(&Profile::Data::CallCount, Eq(1u)),
                                     Field(&Profile::Data::CumulativeLocalTime,
                                           Eq(1000u))))))),
          AllOf(Field(&Profile::Block::Thread, Eq(Profile::ThreadID{2})),
                Field(&Profile::Block::PathData,
                      UnorderedElementsAre(
                          Pair(Merged.internPath({3, 1}),
                               AllOf(Field(&Profile::Data::CallCount, Eq(2u)),
                                     Field(&Profile::Data::CumulativeLocalTime,
                                           Eq(2000u)))),
                          Pair(Merged.internPath({4, 1}),
                               AllOf(Field(&Profile::Data::CallCount, Eq(1u)),
                                     Field(&Profile::Data::CumulativeLocalTime,
                                           Eq(1000u)))))))));
}

TEST(ProfileTest, MergeProfilesByStack) {
  Profile P0, P1;
  EXPECT_FALSE(errorToBool(P0.addBlock(
      Profile::Block{Profile::ThreadID{1},
                     {{P0.internPath({2, 1}), Profile::Data{1, 1000}}}})));
  EXPECT_FALSE(errorToBool(P1.addBlock(
      Profile::Block{Profile::ThreadID{2},
                     {{P1.internPath({2, 1}), Profile::Data{1, 1000}}}})));

  Profile Merged = mergeProfilesByStack(P0, P1);
  EXPECT_THAT(Merged,
              ElementsAre(AllOf(
                  // We expect that we lose the ThreadID dimension in this
                  // algorithm.
                  Field(&Profile::Block::Thread, Eq(Profile::ThreadID{0})),
                  Field(&Profile::Block::PathData,
                        ElementsAre(Pair(
                            Merged.internPath({2, 1}),
                            AllOf(Field(&Profile::Data::CallCount, Eq(2u)),
                                  Field(&Profile::Data::CumulativeLocalTime,
                                        Eq(2000u)))))))));
}

TEST(ProfileTest, MergeProfilesByStackAccumulate) {
  std::vector<Profile> Profiles(3);
  EXPECT_FALSE(errorToBool(Profiles[0].addBlock(Profile::Block{
      Profile::ThreadID{1},
      {{Profiles[0].internPath({2, 1}), Profile::Data{1, 1000}}}})));
  EXPECT_FALSE(errorToBool(Profiles[1].addBlock(Profile::Block{
      Profile::ThreadID{2},
      {{Profiles[1].internPath({2, 1}), Profile::Data{1, 1000}}}})));
  EXPECT_FALSE(errorToBool(Profiles[2].addBlock(Profile::Block{
      Profile::ThreadID{3},
      {{Profiles[2].internPath({2, 1}), Profile::Data{1, 1000}}}})));
  Profile Merged = std::accumulate(Profiles.begin(), Profiles.end(), Profile(),
                                   mergeProfilesByStack);
  EXPECT_THAT(Merged,
              ElementsAre(AllOf(
                  // We expect that we lose the ThreadID dimension in this
                  // algorithm.
                  Field(&Profile::Block::Thread, Eq(Profile::ThreadID{0})),
                  Field(&Profile::Block::PathData,
                        ElementsAre(Pair(
                            Merged.internPath({2, 1}),
                            AllOf(Field(&Profile::Data::CallCount, Eq(3u)),
                                  Field(&Profile::Data::CumulativeLocalTime,
                                        Eq(3000u)))))))));
}

TEST(ProfileTest, MergeProfilesByThreadAccumulate) {
  std::vector<Profile> Profiles(2);

  // Set up the blocks for two different threads in Profiles[0].
  EXPECT_FALSE(errorToBool(Profiles[0].addBlock(Profile::Block{
      Profile::ThreadID{1},
      {{Profiles[0].internPath({2, 1}), Profile::Data{1, 1000}},
       {Profiles[0].internPath({4, 1}), Profile::Data{1, 1000}}}})));
  EXPECT_FALSE(errorToBool(Profiles[0].addBlock(Profile::Block{
      Profile::ThreadID{2},
      {{Profiles[0].internPath({3, 1}), Profile::Data{1, 1000}}}})));

  // Set up the blocks for two different threads in Profiles[1].
  EXPECT_FALSE(errorToBool(Profiles[1].addBlock(Profile::Block{
      Profile::ThreadID{1},
      {{Profiles[1].internPath({2, 1}), Profile::Data{1, 1000}}}})));
  EXPECT_FALSE(errorToBool(Profiles[1].addBlock(Profile::Block{
      Profile::ThreadID{2},
      {{Profiles[1].internPath({3, 1}), Profile::Data{1, 1000}},
       {Profiles[1].internPath({4, 1}), Profile::Data{1, 1000}}}})));

  Profile Merged = std::accumulate(Profiles.begin(), Profiles.end(), Profile(),
                                   mergeProfilesByThread);
  EXPECT_THAT(
      Merged,
      UnorderedElementsAre(
          // We want to see two threads after the merge.
          AllOf(Field(&Profile::Block::Thread, Eq(Profile::ThreadID{1})),
                Field(&Profile::Block::PathData,
                      UnorderedElementsAre(
                          Pair(Merged.internPath({2, 1}),
                               AllOf(Field(&Profile::Data::CallCount, Eq(2u)),
                                     Field(&Profile::Data::CumulativeLocalTime,
                                           Eq(2000u)))),
                          Pair(Merged.internPath({4, 1}),
                               AllOf(Field(&Profile::Data::CallCount, Eq(1u)),
                                     Field(&Profile::Data::CumulativeLocalTime,
                                           Eq(1000u))))))),
          AllOf(Field(&Profile::Block::Thread, Eq(Profile::ThreadID{2})),
                Field(&Profile::Block::PathData,
                      UnorderedElementsAre(
                          Pair(Merged.internPath({3, 1}),
                               AllOf(Field(&Profile::Data::CallCount, Eq(2u)),
                                     Field(&Profile::Data::CumulativeLocalTime,
                                           Eq(2000u)))),
                          Pair(Merged.internPath({4, 1}),
                               AllOf(Field(&Profile::Data::CallCount, Eq(1u)),
                                     Field(&Profile::Data::CumulativeLocalTime,
                                           Eq(1000u)))))))));
}
// FIXME: Add a test creating a Trace and generating a Profile
// FIXME: Add tests for ranking/sorting profile blocks by dimension

} // namespace
} // namespace xray
} // namespace llvm