[lldb][NFCI] Timer::DumpCategoryTimes should take a reference instead of a pointer

[bulbazord]

Summary

We are assuming that the pointer is always valid, might as well take a
reference instead.

[JDevlieghere]

LGTM

[fdeazeve]

Nice!

lldb/include/lldb/Utility/Timer.h

#endif
   ~Timer();
 
   void Dump();
 
   static void SetDisplayDepth(uint32_t depth);
 
   static void SetQuiet(bool value);
 
-  static void DumpCategoryTimes(Stream *s);
+  static void DumpCategoryTimes(Stream &s);
 
   static void ResetCategoryTimes();
 
 protected:
   using TimePoint = std::chrono::steady_clock::time_point;
   void ChildDuration(TimePoint::duration dur) { m_child_duration += dur; }
 
   Category &m_category;

lldb/source/Commands/CommandObjectLog.cpp

CommandObjectLogTimerDisable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "log timers disable",
                             "disable LLDB internal performance timers",
                             nullptr) {}
 
   ~CommandObjectLogTimerDisable() override = default;
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
-    Timer::DumpCategoryTimes(&result.GetOutputStream());
+    Timer::DumpCategoryTimes(result.GetOutputStream());
     Timer::SetDisplayDepth(0);
     result.SetStatus(eReturnStatusSuccessFinishResult);
 
     if (!result.Succeeded()) {
       result.AppendError("Missing subcommand");
       result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str());
     }
     return result.Succeeded();
   }
 };
 
 class CommandObjectLogTimerDump : public CommandObjectParsed {
 public:
   // Constructors and Destructors
   CommandObjectLogTimerDump(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "log timers dump",
                             "dump LLDB internal performance timers", nullptr) {}
 
   ~CommandObjectLogTimerDump() override = default;
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
-    Timer::DumpCategoryTimes(&result.GetOutputStream());
+    Timer::DumpCategoryTimes(result.GetOutputStream());
     result.SetStatus(eReturnStatusSuccessFinishResult);
 
     if (!result.Succeeded()) {
       result.AppendError("Missing subcommand");
       result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str());
     }
     return result.Succeeded();
   }

lldb/source/Utility/Timer.cpp

 void Timer::ResetCategoryTimes() {
   for (Category *i = g_categories; i; i = i->m_next) {
     i->m_nanos.store(0, std::memory_order_release);
     i->m_nanos_total.store(0, std::memory_order_release);
     i->m_count.store(0, std::memory_order_release);
   }
 }
 
-void Timer::DumpCategoryTimes(Stream *s) {
+void Timer::DumpCategoryTimes(Stream &s) {
   std::vector<Stats> sorted;
   for (Category *i = g_categories; i; i = i->m_next) {
     uint64_t nanos = i->m_nanos.load(std::memory_order_acquire);
     if (nanos) {
       uint64_t nanos_total = i->m_nanos_total.load(std::memory_order_acquire);
       uint64_t count = i->m_count.load(std::memory_order_acquire);
       Stats stats{i->m_name, nanos, nanos_total, count};
       sorted.push_back(stats);
     }
   }
   if (sorted.empty())
     return; // Later code will break without any elements.
 
   // Sort by time
   llvm::sort(sorted, CategoryMapIteratorSortCriterion);
 
   for (const auto &stats : sorted)
-    s->Printf("%.9f sec (total: %.3fs; child: %.3fs; count: %" PRIu64
-              ") for %s\n",
-              stats.nanos / 1000000000., stats.nanos_total / 1000000000.,
-              (stats.nanos_total - stats.nanos) / 1000000000., stats.count,
-              stats.name);
+    s.Printf("%.9f sec (total: %.3fs; child: %.3fs; count: %" PRIu64
 }

lldb/unittests/Utility/TimerTest.cpp

 TEST(TimerTest, CategoryTimes) {
   Timer::ResetCategoryTimes();
   {
     static Timer::Category tcat("CAT1");
     Timer t(tcat, ".");
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
   StreamString ss;
-  Timer::DumpCategoryTimes(&ss);
+  Timer::DumpCategoryTimes(ss);
   double seconds;
   ASSERT_EQ(1, sscanf(ss.GetData(), "%lf sec for CAT1", &seconds));
   EXPECT_LT(0.001, seconds);
   EXPECT_GT(0.1, seconds);
 }
 
 TEST(TimerTest, CategoryTimesNested) {
   Timer::ResetCategoryTimes();
   {
     static Timer::Category tcat1("CAT1");
     Timer t1(tcat1, ".");
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
     // Explicitly testing the same category as above.
     Timer t2(tcat1, ".");
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
   StreamString ss;
-  Timer::DumpCategoryTimes(&ss);
+  Timer::DumpCategoryTimes(ss);
   double seconds;
   // It should only appear once.
   ASSERT_EQ(ss.GetString().count("CAT1"), 1U);
   ASSERT_EQ(1, sscanf(ss.GetData(), "%lf sec for CAT1", &seconds));
   EXPECT_LT(0.002, seconds);
   EXPECT_GT(0.2, seconds);
 }
 
 TEST(TimerTest, CategoryTimes2) {
   Timer::ResetCategoryTimes();
   {
     static Timer::Category tcat1("CAT1");
     Timer t1(tcat1, ".");
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     static Timer::Category tcat2("CAT2");
     Timer t2(tcat2, ".");
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
   StreamString ss;
-  Timer::DumpCategoryTimes(&ss);
+  Timer::DumpCategoryTimes(ss);
   double seconds1, seconds2;
   ASSERT_EQ(2, sscanf(ss.GetData(),
                       "%lf sec (total: %*fs; child: %*fs; count: %*d) for "
                       "CAT1%*[\n ]%lf sec for CAT2",
                       &seconds1, &seconds2))
       << "String: " << ss.GetData();
   EXPECT_LT(0.01, seconds1);
   EXPECT_GT(1, seconds1);
static Timer::Category tcat2("CAT2");
       Timer t3(tcat2, ".");
       std::this_thread::sleep_for(std::chrono::milliseconds(10));
     }
   }
   // Example output:
   // 0.105202764 sec (total: 0.132s; child: 0.027s; count: 1) for CAT1
   // 0.026772798 sec (total: 0.027s; child: 0.000s; count: 2) for CAT2
   StreamString ss;
-  Timer::DumpCategoryTimes(&ss);
+  Timer::DumpCategoryTimes(ss);
   double seconds1, total1, child1, seconds2;
   int count1, count2;
   ASSERT_EQ(
       6, sscanf(ss.GetData(),
                 "%lf sec (total: %lfs; child: %lfs; count: %d) for CAT1%*[\n\r ]"
                 "%lf sec (total: %*fs; child: %*fs; count: %d) for CAT2",
                 &seconds1, &total1, &child1, &count1, &seconds2, &count2))
       << "String: " << ss.GetData();
   EXPECT_NEAR(total1 - child1, seconds1, 0.002);
   EXPECT_EQ(1, count1);
   EXPECT_NEAR(child1, seconds2, 0.002);
   EXPECT_EQ(2, count2);
 }