simpleperf: fix percentage comment in stat cmd.

Fix a bug of aggregating time_enabled,time_running introduced
in
https://android-review.googlesource.com/c/platform/system/extras/+/1220206/1/simpleperf/cmd_stat.cpp#1012.

Move some code to cmd_stat_impl.h to add tests.

Bug: 152518722
Test: run simpleperf_unit_test.
Change-Id: I50dcaf9aa83de838cc00554420d232f1a8d54601

1 files changed, 146 insertions, 0 deletions

diff --git a/simpleperf/cmd_stat_test.cpp b/simpleperf/cmd_stat_test.cpp
index bbeb4b66..8bc4e4ff 100644
--- a/simpleperf/cmd_stat_test.cpp
+++ b/simpleperf/cmd_stat_test.cpp
@@ -22,12 +22,15 @@
 
 #include <thread>
 
+#include "cmd_stat_impl.h"
 #include "command.h"
 #include "environment.h"
 #include "event_selection_set.h"
 #include "get_test_data.h"
 #include "test_util.h"
 
+using namespace simpleperf;
+
 static std::unique_ptr<Command> StatCmd() {
   return CreateCommandInstance("stat");
 }
@@ -341,3 +344,146 @@ TEST(stat_cmd, per_core_option) {
   ASSERT_TRUE(StatCmd()->Run({"--per-core", "sleep", "0.1"}));
   TEST_IN_ROOT(StatCmd()->Run({"--per-core", "-a", "--duration", "0.1"}));
 }
+
+TEST(stat_cmd, counter_sum) {
+  PerfCounter counter;
+  counter.value = 1;
+  counter.time_enabled = 2;
+  counter.time_running = 3;
+  CounterSum a;
+  a.FromCounter(counter);
+  ASSERT_EQ(a.value, 1);
+  ASSERT_EQ(a.time_enabled, 2);
+  ASSERT_EQ(a.time_running, 3);
+  CounterSum b = a + a;
+  ASSERT_EQ(b.value, 2);
+  ASSERT_EQ(b.time_enabled, 4);
+  ASSERT_EQ(b.time_running, 6);
+  CounterSum c = a - a;
+  ASSERT_EQ(c.value, 0);
+  ASSERT_EQ(c.time_enabled, 0);
+  ASSERT_EQ(c.time_running, 0);
+  b.ToCounter(counter);
+  ASSERT_EQ(counter.value, 2);
+  ASSERT_EQ(counter.time_enabled, 4);
+  ASSERT_EQ(counter.time_running, 6);
+}
+
+class StatCmdSummaryBuilderTest : public ::testing::Test {
+ protected:
+  void AddCounter(int event_id, pid_t tid, int cpu, int value, int time_enabled, int time_running) {
+    if (thread_map_.count(tid) == 0) {
+      ThreadInfo& thread = thread_map_[tid];
+      thread.pid = thread.tid = tid;
+      thread.name = "thread" + std::to_string(tid);
+    }
+    if (event_id >= counters_.size()) {
+      counters_.resize(event_id + 1);
+      counters_[event_id].group_id = 0;
+      counters_[event_id].event_name = "event" + std::to_string(event_id);
+    }
+    CountersInfo& info = counters_[event_id];
+    info.counters.resize(info.counters.size() + 1);
+    CounterInfo& counter = info.counters.back();
+    counter.tid = tid;
+    counter.cpu = cpu;
+    counter.counter.id = 0;
+    counter.counter.value = value;
+    counter.counter.time_enabled = time_enabled;
+    counter.counter.time_running = time_running;
+  }
+
+  std::vector<CounterSummary> BuildSummary(bool report_per_thread, bool report_per_core) {
+    CounterSummaryBuilder builder(report_per_thread, report_per_core, false, thread_map_);
+    for (auto& info : counters_) {
+      builder.AddCountersForOneEventType(info);
+    }
+    return builder.Build();
+  }
+
+  std::unordered_map<pid_t, ThreadInfo> thread_map_;
+  std::vector<CountersInfo> counters_;
+};
+
+TEST_F(StatCmdSummaryBuilderTest, multiple_events) {
+  AddCounter(0, 0, 0, 1, 1, 1);
+  AddCounter(1, 0, 0, 2, 2, 2);
+  std::vector<CounterSummary> summaries = BuildSummary(false, false);
+  ASSERT_EQ(summaries.size(), 2);
+  ASSERT_EQ(summaries[0].type_name, "event0");
+  ASSERT_EQ(summaries[0].count, 1);
+  ASSERT_NEAR(summaries[0].scale, 1.0, 1e-5);
+  ASSERT_EQ(summaries[1].type_name, "event1");
+  ASSERT_EQ(summaries[1].count, 2);
+  ASSERT_NEAR(summaries[1].scale, 1.0, 1e-5);
+}
+
+TEST_F(StatCmdSummaryBuilderTest, default_aggregate) {
+  AddCounter(0, 0, 0, 1, 1, 1);
+  AddCounter(0, 0, 1, 1, 1, 1);
+  AddCounter(0, 1, 0, 1, 1, 1);
+  AddCounter(0, 1, 1, 2, 2, 1);
+  std::vector<CounterSummary> summaries = BuildSummary(false, false);
+  ASSERT_EQ(summaries.size(), 1);
+  ASSERT_EQ(summaries[0].count, 5);
+  ASSERT_NEAR(summaries[0].scale, 1.25, 1e-5);
+}
+
+TEST_F(StatCmdSummaryBuilderTest, per_thread_aggregate) {
+  AddCounter(0, 0, 0, 1, 1, 1);
+  AddCounter(0, 0, 1, 1, 1, 1);
+  AddCounter(0, 1, 0, 1, 1, 1);
+  AddCounter(0, 1, 1, 2, 2, 1);
+  std::vector<CounterSummary> summaries = BuildSummary(true, false);
+  ASSERT_EQ(summaries.size(), 2);
+  ASSERT_EQ(summaries[0].thread->tid, 1);
+  ASSERT_EQ(summaries[0].cpu, -1);
+  ASSERT_EQ(summaries[0].count, 3);
+  ASSERT_NEAR(summaries[0].scale, 1.5, 1e-5);
+  ASSERT_EQ(summaries[1].thread->tid, 0);
+  ASSERT_EQ(summaries[0].cpu, -1);
+  ASSERT_EQ(summaries[1].count, 2);
+  ASSERT_NEAR(summaries[1].scale, 1.0, 1e-5);
+}
+
+TEST_F(StatCmdSummaryBuilderTest, per_core_aggregate) {
+  AddCounter(0, 0, 0, 1, 1, 1);
+  AddCounter(0, 0, 1, 1, 1, 1);
+  AddCounter(0, 1, 0, 1, 1, 1);
+  AddCounter(0, 1, 1, 2, 2, 1);
+  std::vector<CounterSummary> summaries = BuildSummary(false, true);
+  ASSERT_EQ(summaries.size(), 2);
+  ASSERT_TRUE(summaries[0].thread == nullptr);
+  ASSERT_EQ(summaries[0].cpu, 1);
+  ASSERT_EQ(summaries[0].count, 3);
+  ASSERT_NEAR(summaries[0].scale, 1.5, 1e-5);
+  ASSERT_TRUE(summaries[1].thread == nullptr);
+  ASSERT_EQ(summaries[1].cpu, 0);
+  ASSERT_EQ(summaries[1].count, 2);
+  ASSERT_NEAR(summaries[1].scale, 1.0, 1e-5);
+}
+
+TEST_F(StatCmdSummaryBuilderTest, per_thread_core_aggregate) {
+  AddCounter(0, 0, 0, 1, 1, 1);
+  AddCounter(0, 0, 1, 2, 1, 1);
+  AddCounter(0, 1, 0, 3, 1, 1);
+  AddCounter(0, 1, 1, 4, 2, 1);
+  std::vector<CounterSummary> summaries = BuildSummary(true, true);
+  ASSERT_EQ(summaries.size(), 4);
+  ASSERT_EQ(summaries[0].thread->tid, 1);
+  ASSERT_EQ(summaries[0].cpu, 1);
+  ASSERT_EQ(summaries[0].count, 4);
+  ASSERT_NEAR(summaries[0].scale, 2.0, 1e-5);
+  ASSERT_EQ(summaries[1].thread->tid, 1);
+  ASSERT_EQ(summaries[1].cpu, 0);
+  ASSERT_EQ(summaries[1].count, 3);
+  ASSERT_NEAR(summaries[1].scale, 1.0, 1e-5);
+  ASSERT_EQ(summaries[2].thread->tid, 0);
+  ASSERT_EQ(summaries[2].cpu, 1);
+  ASSERT_EQ(summaries[2].count, 2);
+  ASSERT_NEAR(summaries[2].scale, 1.0, 1e-5);
+  ASSERT_EQ(summaries[3].thread->tid, 0);
+  ASSERT_EQ(summaries[3].cpu, 0);
+  ASSERT_EQ(summaries[3].count, 1);
+  ASSERT_NEAR(summaries[3].scale, 1.0, 1e-5);
+}