[counters] Increase --runtime-call-stats output resolution

src/counters.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/counters.h"
 
 #include <iomanip>
 
 #include "src/base/platform/platform.h"
 #include "src/isolate.h"
@@ skipping 182 matching lines @@
 #define HM(name, caption) name##_.Reset();
     HISTOGRAM_LEGACY_MEMORY_LIST(HM)
 #undef HM
 }
 
 class RuntimeCallStatEntries {
  public:
   void Print(std::ostream& os) {
     if (total_call_count == 0) return;
     std::sort(entries.rbegin(), entries.rend());
-    os << std::setw(50) << "Runtime Function/C++ Builtin" << std::setw(10)
+    os << std::setw(50) << "Runtime Function/C++ Builtin" << std::setw(12)
        << "Time" << std::setw(18) << "Count" << std::endl
-       << std::string(86, '=') << std::endl;
+       << std::string(88, '=') << std::endl;
     for (Entry& entry : entries) {
       entry.SetTotal(total_time, total_call_count);
       entry.Print(os);
     }
-    os << std::string(86, '-') << std::endl;
+    os << std::string(88, '-') << std::endl;
     Entry("Total", total_time, total_call_count).Print(os);
   }
 
   void Add(RuntimeCallCounter* counter) {
     if (counter->count == 0) return;
     entries.push_back(Entry(counter->name, counter->time, counter->count));
     total_time += counter->time;
     total_call_count += counter->count;
   }
 
  private:
   class Entry {
    public:
     Entry(const char* name, base::TimeDelta time, uint64_t count)
         : name_(name),
-          time_(time.InMilliseconds()),
+          time_(time.InMicroseconds()),
           count_(count),
           time_percent_(100),
           count_percent_(100) {}
 
     bool operator<(const Entry& other) const {
       if (time_ < other.time_) return true;
       if (time_ > other.time_) return false;
       return count_ < other.count_;
     }
 
     void Print(std::ostream& os) {
       os.precision(2);
-      os << std::fixed;
+      os << std::fixed << std::setprecision(2);
       os << std::setw(50) << name_;
-      os << std::setw(8) << time_ << "ms ";
+      os << std::setw(10) << static_cast<double>(time_) / 1000 << "ms ";
       os << std::setw(6) << time_percent_ << "%";
       os << std::setw(10) << count_ << " ";
       os << std::setw(6) << count_percent_ << "%";
       os << std::endl;
     }
 
     void SetTotal(base::TimeDelta total_time, uint64_t total_count) {
-      if (total_time.InMilliseconds() == 0) {
+      if (total_time.InMicroseconds() == 0) {
         time_percent_ = 0;
       } else {
-        time_percent_ = 100.0 * time_ / total_time.InMilliseconds();
+        time_percent_ = 100.0 * time_ / total_time.InMicroseconds();
       }
       count_percent_ = 100.0 * count_ / total_count;
     }
 
    private:
     const char* name_;
     int64_t time_;
     uint64_t count_;
     double time_percent_;
     double count_percent_;
@@ skipping 78 matching lines @@
   FOR_EACH_API_COUNTER(RESET_COUNTER)
 #undef RESET_COUNTER
 
 #define RESET_COUNTER(name) this->Handler_##name.Reset();
   FOR_EACH_HANDLER_COUNTER(RESET_COUNTER)
 #undef RESET_COUNTER
 }
 
 }  // namespace internal
 }  // namespace v8