Add --print-benchmarking-metrics to the VM for Golem.

runtime/vm/metrics.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/metrics.h"
 
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/native_entry.h"
 #include "vm/runtime_entry.h"
@@ skipping 57 matching lines @@
 }
 
 
 #ifndef PRODUCT
 static const char* UnitString(intptr_t unit) {
   switch (unit) {
     case Metric::kCounter:
       return "counter";
     case Metric::kByte:
       return "byte";
+    case Metric::kMicrosecond:
+      return "us";
     default:
       UNREACHABLE();
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void Metric::PrintJSON(JSONStream* stream) {
   if (!FLAG_support_service) {
@@ skipping 18 matching lines @@
 
 char* Metric::ValueToString(int64_t value, Unit unit) {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   Zone* zone = thread->zone();
   ASSERT(zone != NULL);
   switch (unit) {
     case kCounter:
       return zone->PrintToString("%" Pd64 "", value);
     case kByte: {
-      const char* scaled_suffix = "b";
+      const char* scaled_suffix = "B";
       double scaled_value = static_cast<double>(value);
-      if (value > KB) {
-        scaled_suffix = "kb";
+      if (value > GB) {
+        scaled_suffix = "GB";
+        scaled_value /= GB;
+      } else if (value > MB) {
+        scaled_suffix = "MB";
+        scaled_value /= MB;
+      } else if (value > KB) {
+        scaled_suffix = "kB";
         scaled_value /= KB;
-      } else if (value > MB) {
-        scaled_suffix = "mb";
-        scaled_value /= MB;
-      } else if (value > GB) {
-        scaled_suffix = "gb";
-        scaled_value /= GB;
       }
-      return zone->PrintToString("%.3f %s (%" Pd64 ")", scaled_value,
+      return zone->PrintToString("%.3f %s (%" Pd64 " B)", scaled_value,
+                                 scaled_suffix, value);
+    }
+    case kMicrosecond: {
+      const char* scaled_suffix = "us";
+      double scaled_value = static_cast<double>(value);
+      if (value > kMicrosecondsPerSecond) {
+        scaled_suffix = "s";
+        scaled_value /= kMicrosecondsPerSecond;
+      } else if (value > kMicrosecondsPerMillisecond) {
+        scaled_suffix = "ms";
+        scaled_value /= kMicrosecondsPerMillisecond;
+      }
+      return zone->PrintToString("%.3f %s (%" Pd64 " us)", scaled_value,
                                  scaled_suffix, value);
     }
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 char* Metric::ToString() {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   Zone* zone = thread->zone();
   ASSERT(zone != NULL);
-  return zone->PrintToString("%s %s", name(), ValueToString(value(), unit()));
+  return zone->PrintToString("%s %s", name(), ValueToString(Value(), unit()));

[rmacnak, 2017/01/31 23:49:19]

Forcing compute here.

[Cutch, 2017/01/31 23:50:56]

Acknowledged.

 }
 
 
 bool Metric::NameExists(Metric* head, const char* name) {
   ASSERT(name != NULL);
   while (head != NULL) {
     const char* metric_name = head->name();
     ASSERT(metric_name != NULL);
     if (strcmp(metric_name, name) == 0) {
       return true;
@@ skipping 130 matching lines @@
 int64_t MetricHeapUsed::Value() const {
   ASSERT(isolate() == Isolate::Current());
   return isolate()->heap()->UsedInWords(Heap::kNew) * kWordSize +
          isolate()->heap()->UsedInWords(Heap::kOld) * kWordSize;
 }
 
 int64_t MetricIsolateCount::Value() const {
   return Isolate::IsolateListLength();
 }
 
+
+int64_t MetricPeakRSS::Value() const {
+  return OS::MaxRSS();
+}
+
 #define VM_METRIC_VARIABLE(type, variable, name, unit)                         \
   static type vm_metric_##variable##_;
 VM_METRIC_LIST(VM_METRIC_VARIABLE);
 #undef VM_METRIC_VARIABLE
 
 
 void Metric::InitOnce() {
 #define VM_METRIC_INIT(type, variable, name, unit)                             \
   vm_metric_##variable##_.Init(name, NULL, Metric::unit);
   VM_METRIC_LIST(VM_METRIC_INIT);
 #undef VM_METRIC_INIT
 }
 
 void Metric::Cleanup() {
-  if (FLAG_print_metrics) {
+  if (FLAG_print_metrics || FLAG_print_benchmarking_metrics) {
     // Create a zone to allocate temporary strings in.
     StackZone sz(Thread::Current());
     OS::PrintErr("Printing metrics for VM\n");
     Metric* current = Metric::vm_head();
     while (current != NULL) {
       OS::PrintErr("%s\n", current->ToString());
       current = current->next();
     }
     OS::PrintErr("\n");
   }
@@ skipping 17 matching lines @@
 }
 
 
 void MinMetric::SetValue(int64_t new_value) {
   if (new_value < value()) {
     set_value(new_value);
   }
 }
 
 }  // namespace dart