simpleperf/sample_tree_test.cpp

   1 /*
   2  * Copyright (C) 2015 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18
  19 #include "sample_tree.h"
  20 #include "thread_tree.h"
  21
  22 namespace {
  23
  24 struct SampleEntry {
  25   int pid;
  26   int tid;
  27   const char* thread_comm;
  28   std::string dso_name;
  29   uint64_t map_start_addr;
  30   size_t sample_count;
  31
  32   SampleEntry(int pid, int tid, const char* thread_comm,
  33               const std::string& dso_name, uint64_t map_start_addr,
  34               size_t sample_count = 1u)
  35       : pid(pid),
  36         tid(tid),
  37         thread_comm(thread_comm),
  38         dso_name(dso_name),
  39         map_start_addr(map_start_addr),
  40         sample_count(sample_count) {}
  41 };
  42
  43 BUILD_COMPARE_VALUE_FUNCTION(TestComparePid, pid);
  44 BUILD_COMPARE_VALUE_FUNCTION(TestCompareTid, tid);
  45 BUILD_COMPARE_STRING_FUNCTION(TestCompareDsoName, dso_name.c_str());
  46 BUILD_COMPARE_VALUE_FUNCTION(TestCompareMapStartAddr, map_start_addr);
  47
  48 class TestSampleComparator : public SampleComparator<SampleEntry> {
  49  public:
  50   TestSampleComparator() {
  51     AddCompareFunction(TestComparePid);
  52     AddCompareFunction(TestCompareTid);
  53     AddCompareFunction(CompareComm);
  54     AddCompareFunction(TestCompareDsoName);
  55     AddCompareFunction(TestCompareMapStartAddr);
  56   }
  57 };
  58
  59 class TestSampleTreeBuilder : public SampleTreeBuilder<SampleEntry, int> {
  60  public:
  61   explicit TestSampleTreeBuilder(ThreadTree* thread_tree)
  62       : SampleTreeBuilder(TestSampleComparator()), thread_tree_(thread_tree) {}
  63
  64   void AddSample(int pid, int tid, uint64_t ip, bool in_kernel) {
  65     const ThreadEntry* thread = thread_tree_->FindThreadOrNew(pid, tid);
  66     const MapEntry* map = thread_tree_->FindMap(thread, ip, in_kernel);
  67     InsertSample(std::unique_ptr<SampleEntry>(new SampleEntry(
  68         pid, tid, thread->comm, map->dso->Path(), map->start_addr)));
  69   }
  70
  71  protected:
  72   SampleEntry* CreateSample(const SampleRecord&, bool, int*) override {
  73     return nullptr;
  74   }
  75   SampleEntry* CreateBranchSample(const SampleRecord&,
  76                                   const BranchStackItemType&) override {
  77     return nullptr;
  78   };
  79   SampleEntry* CreateCallChainSample(const SampleEntry*, uint64_t, bool,
  80                                      const std::vector<SampleEntry*>&,
  81                                      const int&) override {
  82     return nullptr;
  83   }
  84   const ThreadEntry* GetThreadOfSample(SampleEntry*) override {
  85     return nullptr;
  86   }
  87   uint64_t GetPeriodForCallChain(const int&) override { return 0; }
  88   void MergeSample(SampleEntry* sample1, SampleEntry* sample2) override {
  89     sample1->sample_count += sample2->sample_count;
  90   }
  91
  92  private:
  93   ThreadTree* thread_tree_;
  94 };
  95
  96 static void SampleMatchExpectation(const SampleEntry& sample,
  97                                    const SampleEntry& expected,
  98                                    bool* has_error) {
  99   *has_error = true;
 100   ASSERT_EQ(expected.pid, sample.pid);
 101   ASSERT_EQ(expected.tid, sample.tid);
 102   ASSERT_STREQ(expected.thread_comm, sample.thread_comm);
 103   ASSERT_EQ(expected.dso_name, sample.dso_name);
 104   ASSERT_EQ(expected.map_start_addr, sample.map_start_addr);
 105   ASSERT_EQ(expected.sample_count, sample.sample_count);
 106   *has_error = false;
 107 }
 108
 109 static void CheckSamples(const std::vector<SampleEntry*>& samples,
 110                          const std::vector<SampleEntry>& expected_samples) {
 111   ASSERT_EQ(samples.size(), expected_samples.size());
 112   for (size_t i = 0; i < samples.size(); ++i) {
 113     bool has_error;
 114     SampleMatchExpectation(*samples[i], expected_samples[i], &has_error);
 115     ASSERT_FALSE(has_error) << "Error matching sample at pos " << i;
 116   }
 117 }
 118 }
 119
 120 class SampleTreeTest : public testing::Test {
 121  protected:
 122   virtual void SetUp() {
 123     thread_tree.SetThreadName(1, 1, "p1t1");
 124     thread_tree.SetThreadName(1, 11, "p1t11");
 125     thread_tree.SetThreadName(2, 2, "p2t2");
 126     thread_tree.AddThreadMap(1, 1, 1, 5, 0, 0, "process1_thread1");
 127     thread_tree.AddThreadMap(1, 11, 6, 5, 0, 0, "process1_thread1_map2");
 128     thread_tree.AddThreadMap(2, 2, 1, 20, 0, 0, "process2_thread2");
 129     thread_tree.AddKernelMap(10, 20, 0, 0, "kernel");
 130     sample_tree_builder.reset(new TestSampleTreeBuilder(&thread_tree));
 131   }
 132
 133   void CheckSamples(const std::vector<SampleEntry>& expected_samples) {
 134     ::CheckSamples(sample_tree_builder->GetSamples(), expected_samples);
 135   }
 136
 137   ThreadTree thread_tree;
 138   std::unique_ptr<TestSampleTreeBuilder> sample_tree_builder;
 139 };
 140
 141 TEST_F(SampleTreeTest, ip_in_map) {
 142   sample_tree_builder->AddSample(1, 1, 1, false);
 143   sample_tree_builder->AddSample(1, 1, 2, false);
 144   sample_tree_builder->AddSample(1, 1, 5, false);
 145   std::vector<SampleEntry> expected_samples = {
 146       SampleEntry(1, 1, "p1t1", "process1_thread1", 1, 3),
 147   };
 148   CheckSamples(expected_samples);
 149 }
 150
 151 TEST_F(SampleTreeTest, different_pid) {
 152   sample_tree_builder->AddSample(1, 1, 1, false);
 153   sample_tree_builder->AddSample(2, 2, 1, false);
 154   std::vector<SampleEntry> expected_samples = {
 155       SampleEntry(1, 1, "p1t1", "process1_thread1", 1, 1),
 156       SampleEntry(2, 2, "p2t2", "process2_thread2", 1, 1),
 157   };
 158   CheckSamples(expected_samples);
 159 }
 160
 161 TEST_F(SampleTreeTest, different_tid) {
 162   sample_tree_builder->AddSample(1, 1, 1, false);
 163   sample_tree_builder->AddSample(1, 11, 1, false);
 164   std::vector<SampleEntry> expected_samples = {
 165       SampleEntry(1, 1, "p1t1", "process1_thread1", 1, 1),
 166       SampleEntry(1, 11, "p1t11", "process1_thread1", 1, 1),
 167   };
 168   CheckSamples(expected_samples);
 169 }
 170
 171 TEST_F(SampleTreeTest, different_comm) {
 172   sample_tree_builder->AddSample(1, 1, 1, false);
 173   thread_tree.SetThreadName(1, 1, "p1t1_comm2");
 174   sample_tree_builder->AddSample(1, 1, 1, false);
 175   std::vector<SampleEntry> expected_samples = {
 176       SampleEntry(1, 1, "p1t1", "process1_thread1", 1, 1),
 177       SampleEntry(1, 1, "p1t1_comm2", "process1_thread1", 1, 1),
 178   };
 179   CheckSamples(expected_samples);
 180 }
 181
 182 TEST_F(SampleTreeTest, different_map) {
 183   sample_tree_builder->AddSample(1, 1, 1, false);
 184   sample_tree_builder->AddSample(1, 1, 6, false);
 185   std::vector<SampleEntry> expected_samples = {
 186       SampleEntry(1, 1, "p1t1", "process1_thread1", 1, 1),
 187       SampleEntry(1, 1, "p1t1", "process1_thread1_map2", 6, 1),
 188   };
 189   CheckSamples(expected_samples);
 190 }
 191
 192 TEST_F(SampleTreeTest, unmapped_sample) {
 193   sample_tree_builder->AddSample(1, 1, 0, false);
 194   sample_tree_builder->AddSample(1, 1, 31, false);
 195   sample_tree_builder->AddSample(1, 1, 70, false);
 196   // Match the unknown map.
 197   std::vector<SampleEntry> expected_samples = {
 198       SampleEntry(1, 1, "p1t1", "unknown", 0, 3),
 199   };
 200   CheckSamples(expected_samples);
 201 }
 202
 203 TEST_F(SampleTreeTest, map_kernel) {
 204   sample_tree_builder->AddSample(1, 1, 10, true);
 205   sample_tree_builder->AddSample(1, 1, 10, false);
 206   std::vector<SampleEntry> expected_samples = {
 207       SampleEntry(1, 1, "p1t1", "kernel", 10, 1),
 208       SampleEntry(1, 1, "p1t1", "process1_thread1_map2", 6, 1),
 209   };
 210   CheckSamples(expected_samples);
 211 }
 212
 213 TEST(sample_tree, overlapped_map) {
 214   ThreadTree thread_tree;
 215   TestSampleTreeBuilder sample_tree_builder(&thread_tree);
 216   thread_tree.SetThreadName(1, 1, "thread1");
 217   thread_tree.AddThreadMap(1, 1, 1, 10, 0, 0, "map1");  // Add map 1.
 218   sample_tree_builder.AddSample(1, 1, 5, false);        // Hit map 1.
 219   thread_tree.AddThreadMap(1, 1, 5, 20, 0, 0, "map2");  // Add map 2.
 220   sample_tree_builder.AddSample(1, 1, 6, false);        // Hit map 2.
 221   sample_tree_builder.AddSample(1, 1, 4, false);        // Hit map 1.
 222   thread_tree.AddThreadMap(1, 1, 2, 7, 0, 0, "map3");   // Add map 3.
 223   sample_tree_builder.AddSample(1, 1, 7, false);        // Hit map 3.
 224   sample_tree_builder.AddSample(1, 1, 10, false);       // Hit map 2.
 225
 226   std::vector<SampleEntry> expected_samples = {
 227       SampleEntry(1, 1, "thread1", "map1", 1, 2),
 228       SampleEntry(1, 1, "thread1", "map2", 5, 1),
 229       SampleEntry(1, 1, "thread1", "map2", 9, 1),
 230       SampleEntry(1, 1, "thread1", "map3", 2, 1),
 231   };
 232   CheckSamples(sample_tree_builder.GetSamples(), expected_samples);
 233 }
 234
 235 TEST(thread_tree, symbol_ULLONG_MAX) {
 236   ThreadTree thread_tree;
 237   thread_tree.ShowIpForUnknownSymbol();
 238   ASSERT_TRUE(thread_tree.FindKernelSymbol(ULLONG_MAX) != nullptr);
 239 }