Add current rss and embedder name to Observatory

runtime/observatory/lib/src/elements/memory/graph.dart

 // Copyright (c) 2017, 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.
 
 /// This Element is part of MemoryDashboardElement.
 ///
 /// The Element periodically interrogates the VM to log the memory usage of each
 /// Isolate and of the Native Memory.
 ///
 /// For each isolate it is shown the Used and Free heap (new and old are merged
@@ skipping 23 matching lines @@
 
   RenderingScheduler<MemoryGraphElement> _r;
 
   final StreamController<IsolateSelectedEvent> _onIsolateSelected =
       new StreamController<IsolateSelectedEvent>();
 
   Stream<RenderedEvent<MemoryGraphElement>> get onRendered => _r.onRendered;
   Stream<IsolateSelectedEvent> get onIsolateSelected =>
       _onIsolateSelected.stream;
 
-  M.VM _vm;
+  M.VMRef _vm;
+  M.VMRepository _vms;
   M.IsolateRepository _isolates;
   M.EventRepository _events;
   StreamSubscription _onGCSubscription;
   StreamSubscription _onResizeSubscription;
   StreamSubscription _onConnectionClosedSubscription;
   Timer _onTimer;
 
-  M.VM get vm => _vm;
+  M.VMRef get vm => _vm;
 
-  factory MemoryGraphElement(
-      M.VM vm, M.IsolateRepository isolates, M.EventRepository events,
+  factory MemoryGraphElement(M.VMRef vm, M.VMRepository vms,
+      M.IsolateRepository isolates, M.EventRepository events,
       {RenderingQueue queue}) {
     assert(vm != null);
+    assert(vms != null);
     assert(isolates != null);
     assert(events != null);
     MemoryGraphElement e = document.createElement(tag.name);
     e._r = new RenderingScheduler(e, queue: queue);
     e._vm = vm;
+    e._vms = vms;
     e._isolates = isolates;
     e._events = events;
     return e;
   }
 
   MemoryGraphElement.created() : super.created() {
     final now = new DateTime.now();
     var sample = now.subtract(_window);
     while (sample.isBefore(now)) {
       _ts.add(sample);
-      _vmSamples.add(0);
+      _vmSamples.add(<int>[0, 0]);
       _isolateUsedSamples.add([]);
       _isolateFreeSamples.add([]);
       sample = sample.add(_period);
     }
     _ts.add(now);
-    _vmSamples.add(0);
+    _vmSamples.add(<int>[0, 0]);
     _isolateUsedSamples.add([]);
     _isolateFreeSamples.add([]);
   }
 
   static const Duration _period = const Duration(seconds: 2);
   static const Duration _window = const Duration(minutes: 2);
 
   @override
   attached() {
     super.attached();
@@ skipping 12 matching lines @@
     super.detached();
     _r.disable(notify: true);
     children = [];
     _onGCSubscription.cancel();
     _onConnectionClosedSubscription.cancel();
     _onResizeSubscription.cancel();
     _onTimer.cancel();
   }
 
   final List<DateTime> _ts = <DateTime>[];
-  final List<int> _vmSamples = <int>[];
+  final List<List<int>> _vmSamples = <List<int>>[];
   final List<M.IsolateRef> _seenIsolates = <M.IsolateRef>[];
   final List<List<int>> _isolateUsedSamples = <List<int>>[];
   final List<List<int>> _isolateFreeSamples = <List<int>>[];
   final Map<String, int> _isolateIndex = <String, int>{};
   final Map<String, String> _isolateName = <String, String>{};
 
   var _selected;
   var _previewed;
   var _hovered;
 
   void render() {
     if (_previewed != null || _hovered != null) return;
 
+    // cache data of hoverboards
+    final ts = new List<DateTime>.from(_ts);
+    final vmSamples = new List<List<int>>.from(_vmSamples);
+    final isolateFreeSamples = new List<List<int>>.from(_isolateFreeSamples);
+    final isolateUsedSamples = new List<List<int>>.from(_isolateUsedSamples);
+
     final now = _ts.last;
     final nativeComponents = 1;
     final legend = new DivElement();
     final host = new DivElement();
     final theme = new MemoryChartTheme(1);
     children = [theme.style, legend, host];
     final rect = host.getBoundingClientRect();
 
     final series =
         new List<int>.generate(_isolateIndex.length * 2 + 1, (i) => i + 1);
     // The stacked line chart sorts from top to bottom
     final columns = [
       new ChartColumnSpec(
           formatter: _formatTimeAxis, type: ChartColumnSpec.TYPE_NUMBER),
       new ChartColumnSpec(label: 'Native', formatter: Utils.formatSize)
     ]..addAll(_isolateName.keys.expand((id) => [
           new ChartColumnSpec(formatter: Utils.formatSize),
           new ChartColumnSpec(label: _label(id), formatter: Utils.formatSize)
         ]));
     // The stacked line chart sorts from top to bottom
     final rows = new List.generate(_ts.length, (sampleIndex) {
-      final free = _isolateFreeSamples[sampleIndex];
-      final used = _isolateUsedSamples[sampleIndex];
+      final free = isolateFreeSamples[sampleIndex];
+      final used = isolateUsedSamples[sampleIndex];
+      final isolates = _isolateIndex.keys.expand((key) {
+        final isolateIndex = _isolateIndex[key];
+        return <int>[free[isolateIndex], used[isolateIndex]];
+      });
       return [
-        _ts[sampleIndex].difference(now).inMicroseconds,
-        _vmSamples[sampleIndex]
-      ]..addAll(_isolateIndex.keys.expand((key) {
-          final isolateIndex = _isolateIndex[key];
-          return [free[isolateIndex], used[isolateIndex]];
-        }));
+        ts[sampleIndex].difference(now).inMicroseconds,
+        vmSamples[sampleIndex][1] ?? 1000000
+      ]..addAll(isolates);
     });
 
     final scale = new LinearScale()..domain = [(-_window).inMicroseconds, 0];
     final axisConfig = new ChartAxisConfig()..scale = scale;
     final sMemory =
         new ChartSeries('Memory', series, new StackedLineChartRenderer());
     final config = new ChartConfig([sMemory], [0])
       ..legend = new ChartLegend(legend)
       ..registerDimensionAxis(0, axisConfig);
     config.minimumSize = new Rect(rect.width, rect.height);
     final data = new ChartData(columns, rows);
     final state = new ChartState(isMultiSelect: true)
       ..changes.listen(_handleEvent);
     final area = new CartesianArea(host, data, config, state: state)
       ..theme = theme;
     area.addChartBehavior(new Hovercard(builder: (int column, int row) {
-      final data = rows[row];
       if (column == 1) {
-        return _formatNativeOvercard(data[1]);
+        final data = vmSamples[row];
+        return _formatNativeOvercard(data[0], data[1]);
       }
       final isolate = _seenIsolates[column - 2];
-      final index = _isolateIndex[isolate.id] * 2 + 2;
-      return _formatIsolateOvercard(isolate.name, data[index], data[index + 1]);
+      final index = _isolateIndex[isolate.id];
+      final free = isolateFreeSamples[row][index];
+      final used = isolateUsedSamples[row][index];
+      return _formatIsolateOvercard(isolate.name, free, used);
     }));
     area.draw();
 
     if (_selected != null) {
       state.select(_selected);
       if (_selected > 1) {
         state.select(_selected + 1);
       }
     }
   }
 
   String _formatTimeAxis(num ms) =>
       Utils.formatDuration(new Duration(microseconds: ms.toInt()),
           precision: DurationComponent.Seconds);
 
   bool _running = false;
 
   Future _refresh({M.IsolateRef gcIsolate}) async {
     if (_running) return;
     _running = true;
     final now = new DateTime.now();
     final start = now.subtract(_window);
+    final vm = await _vms.get(_vm);
     // The Service classes order isolates from the older to the newer
     final isolates =
-        (await Future.wait(_vm.isolates.map(_isolates.get))).reversed.toList();
+        (await Future.wait(vm.isolates.map(_isolates.get))).reversed.toList();
     while (_ts.first.isBefore(start)) {
       _ts.removeAt(0);
       _vmSamples.removeAt(0);
       _isolateUsedSamples.removeAt(0);
       _isolateFreeSamples.removeAt(0);
     }
 
     if (_ts.first.isAfter(start)) {
       _ts.insert(0, start);
       _vmSamples.insert(0, _vmSamples.first);
@@ skipping 34 matching lines @@
               _isolateUsedSamples.last[index] + _isolateFreeSamples.last[index];
           isolateFreeSample[index] = 0;
         } else {
           isolateUsedSample[index] = _used(isolate);
           isolateFreeSample[index] = _free(isolate);
         }
       });
       _isolateUsedSamples.add(isolateUsedSample);
       _isolateFreeSamples.add(isolateFreeSample);
 
-      _vmSamples.add(vm.heapAllocatedMemoryUsage);
+      _vmSamples.add(<int>[vm.currentRSS, vm.heapAllocatedMemoryUsage]);
 
       _ts.add(now);
     }
     final List<int> isolateUsedSample = new List<int>.filled(length, 0);
     final List<int> isolateFreeSample = new List<int>.filled(length, 0);
     isolates.forEach((M.Isolate isolate) {
       _isolateName[isolate.id] = isolate.name;
       final index = _isolateIndex[isolate.id];
       isolateUsedSample[index] = _used(isolate);
       isolateFreeSample[index] = _free(isolate);
     });
     _isolateUsedSamples.add(isolateUsedSample);
     _isolateFreeSamples.add(isolateFreeSample);
 
-    _vmSamples.add(vm.heapAllocatedMemoryUsage);
+    _vmSamples.add(<int>[vm.currentRSS, vm.heapAllocatedMemoryUsage]);
 
     _ts.add(now);
     _r.dirty();
     _running = false;
   }
 
   void _handleEvent(records) => records.forEach((record) {
         if (record is ChartSelectionChangeRecord) {
           var selected = record.add;
           if (selected == null) {
@@ skipping 34 matching lines @@
     final index = _isolateIndex[isolateId];
     final name = _isolateName[isolateId];
     final free = _isolateFreeSamples.last[index];
     final used = _isolateUsedSamples.last[index];
     final usedStr = Utils.formatSize(used);
     final capacity = free + used;
     final capacityStr = Utils.formatSize(capacity);
     return '${name} ($usedStr / $capacityStr)';
   }
 
-  static HtmlElement _formatNativeOvercard(int heap) => new DivElement()
-    ..children = [
+  static HtmlElement _formatNativeOvercard(int currentRSS, int heap) =>
       new DivElement()
-        ..classes = ['hovercard-title']
-        ..text = 'Native',
-      new DivElement()
-        ..classes = ['hovercard-measure', 'hovercard-multi']
         ..children = [
           new DivElement()
-            ..classes = ['hovercard-measure-label']
-            ..text = 'Heap',
+            ..classes = ['hovercard-title']
+            ..text = 'Native',
           new DivElement()
-            ..classes = ['hovercard-measure-value']
-            ..text = Utils.formatSize(heap),
-        ]
-    ];
+            ..classes = ['hovercard-measure', 'hovercard-multi']
+            ..children = [
+              new DivElement()
+                ..classes = ['hovercard-measure-label']
+                ..text = 'Total Memory Usage',
+              new DivElement()
+                ..classes = ['hovercard-measure-value']
+                ..text = currentRSS != null
+                    ? Utils.formatSize(currentRSS)
+                    : "unavailable",
+            ],
+          new DivElement()
+            ..classes = ['hovercard-measure', 'hovercard-multi']
+            ..children = [
+              new DivElement()
+                ..classes = ['hovercard-measure-label']
+                ..text = 'Native Heap',
+              new DivElement()
+                ..classes = ['hovercard-measure-value']
+                ..text = heap != null ? Utils.formatSize(heap) : "unavailable",
+            ]
+        ];
 
   static HtmlElement _formatIsolateOvercard(String name, int free, int used) {
     final capacity = free + used;
     return new DivElement()
       ..children = [
         new DivElement()
           ..classes = ['hovercard-title']
           ..text = name,
         new DivElement()
           ..classes = ['hovercard-measure', 'hovercard-multi']
@@ skipping 73 matching lines @@
   </defs>
 ''';
 
   StyleElement get style => new StyleElement()
     ..text = '''
 memory-graph svg .stacked-line-rdr-line:nth-child(2n+${_offset+1})
   path:nth-child(1) {
   filter: url(#stroke-grid);
 }''';
 }