Visual refresh of allocation profile page

runtime/bin/vmservice/client/lib/src/service/object.dart

 // 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.
 
 part of service;
 
 /// A [ServiceObject] is an object known to the VM service and is tied
 /// to an owning [Isolate].
 abstract class ServiceObject extends Observable {
   /// The owner of this [ServiceObject].  This can be an [Isolate], a
@@ skipping 173 matching lines @@
 
   @reflectable String get link => '$id';
   @reflectable String relativeLink(String id) => '$id';
 
   @observable String version = 'unknown';
   @observable String architecture = 'unknown';
   @observable double uptime = 0.0;
   @observable bool assertsEnabled = false;
   @observable bool typeChecksEnabled = false;
   @observable String pid = '';
+  @observable DateTime lastUpdate;
 
   VM() : super._empty(null) {
     name = 'vm';
     vmName = 'vm';
     _cache['vm'] = this;
     update(toObservable({'id':'vm', 'type':'@VM'}));
   }
 
   final StreamController<ServiceException> exceptions =
       new StreamController.broadcast();
@@ skipping 163 matching lines @@
   Future<String> getString(String id);
 
   void _update(ObservableMap map, bool mapIsRef) {
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     version = map['version'];
     architecture = map['architecture'];
     uptime = map['uptime'];
+    var dateInMillis = int.parse(map['date']);
+    lastUpdate = new DateTime.fromMillisecondsSinceEpoch(dateInMillis);
     assertsEnabled = map['assertsEnabled'];
     pid = map['pid'];
     typeChecksEnabled = map['typeChecksEnabled'];
     _updateIsolates(map['isolates']);
   }
 
   void _updateIsolates(List newIsolates) {
     var oldIsolateCache = _isolateCache;
     var newIsolateCache = new Map<String,Isolate>();
     for (var isolateMap in newIsolates) {
@@ skipping 92 matching lines @@
     snapshot.delta(counters, _maxSnapshot.counters);
     _maxSnapshot.max(counters);
     snapshots.add(snapshot);
     // Only keep _historySize snapshots.
     if (snapshots.length > _historySize) {
       snapshots.removeAt(0);
     }
   }
 }
 
+class IsolateHeap extends Observable {

[koda, 2014/06/18 17:04:02]

To nit, I think either "space" or "generation" would be a less ambiguous term
than "heap" (and you already call the instances newSpace/oldSpace). I think of
the heap as the basic abstraction and the spaces and generations as
implementation details.

[Cutch, 2014/06/18 17:13:04]

Done. HeapSpace.

+  @observable int used = 0;
+  @observable int capacity = 0;
+  @observable int external = 0;
+  @observable int collections = 0;
+  @observable double totalCollectionTimeInSeconds = 0.0;
+
+  void update(Map heapMap) {
+    used = heapMap['used'];
+    capacity = heapMap['capacity'];
+    external = heapMap['external'];
+    collections = heapMap['collections'];
+    totalCollectionTimeInSeconds = heapMap['time'];
+  }
+}
+
 /// State for a running isolate.
 class Isolate extends ServiceObjectOwner {
   @reflectable VM get vm => owner;
   @reflectable Isolate get isolate => this;
   @observable ObservableMap counters = new ObservableMap();
 
   String get link => '/${_id}';
 
   @observable ServiceMap pauseEvent = null;
   bool get _isPaused => pauseEvent != null;
@@ skipping 155 matching lines @@
   @observable ObservableMap topFrame;
 
   @observable String name;
   @observable String vmName;
   @observable String mainPort;
   @observable Map entry;
 
   @observable final Map<String, double> timers =
       toObservable(new Map<String, double>());
 
-  @observable int newHeapUsed = 0;
-  @observable int oldHeapUsed = 0;
-  @observable int newHeapCapacity = 0;
-  @observable int oldHeapCapacity = 0;
+  final IsolateHeap newSpace = new IsolateHeap();
+  final IsolateHeap oldSpace = new IsolateHeap();
 
   @observable String fileAndLine;
 
   @observable DartError error;
 
+  void updateHeapsFromMap(ObservableMap map) {
+    newSpace.update(map['new']);
+    oldSpace.update(map['old']);
+  }
+
   void _update(ObservableMap map, bool mapIsRef) {
     mainPort = map['mainPort'];
     name = map['name'];
     vmName = map['name'];
     if (mapIsRef) {
       return;
     }
     _loaded = true;
     loading = false;
     _upgradeCollection(map, isolate);
     if (map['rootLib'] == null ||
         map['timers'] == null ||
-        map['heap'] == null) {
+        map['heaps'] == null) {
       Logger.root.severe("Malformed 'Isolate' response: $map");
       return;
     }
     rootLib = map['rootLib'];
     if (map['entry'] != null) {
       entry = map['entry'];
     }
     if (map['topFrame'] != null) {
       topFrame = map['topFrame'];
     } else {
@@ skipping 28 matching lines @@
       });
     timers['total'] = timerMap['time_total_runtime'];
     timers['compile'] = timerMap['time_compilation'];
     timers['gc'] = 0.0;  // TODO(turnidge): Export this from VM.
     timers['init'] = (timerMap['time_script_loading'] +
                       timerMap['time_creating_snapshot'] +
                       timerMap['time_isolate_initialization'] +
                       timerMap['time_bootstrap']);
     timers['dart'] = timerMap['time_dart_execution'];
 
-    newHeapUsed = map['heap']['usedNew'];
-    oldHeapUsed = map['heap']['usedOld'];
-    newHeapCapacity = map['heap']['capacityNew'];
-    oldHeapCapacity = map['heap']['capacityOld'];
+    updateHeapsFromMap(map['heaps']);
 
     List features = map['features'];
     if (features != null) {
       for (var feature in features) {
         if (feature == 'io') {
           ioEnabled = true;
         }
       }
     }
     // Isolate status
@@ skipping 219 matching lines @@
     scripts.addAll(map['scripts']);
     classes.clear();
     classes.addAll(map['classes']);
     variables.clear();
     variables.addAll(map['variables']);
     functions.clear();
     functions.addAll(map['functions']);
   }
 }
 
+class AllocationCount extends Observable {
+  @observable int instances = 0;
+  @observable int bytes = 0;
+
+  void reset() {
+    instances = 0;
+    bytes = 0;
+  }
+
+  bool get empty => (instances == 0) && (bytes == 0);
+}
+
+class Allocations {
+  // Indexes into VM provided array. (see vm/class_table.h).
+  static const ALLOCATED_BEFORE_GC = 0;
+  static const ALLOCATED_BEFORE_GC_SIZE = 1;
+  static const LIVE_AFTER_GC = 2;
+  static const LIVE_AFTER_GC_SIZE = 3;
+  static const ALLOCATED_SINCE_GC = 4;
+  static const ALLOCATED_SINCE_GC_SIZE = 5;
+  static const ACCUMULATED = 6;
+  static const ACCUMULATED_SIZE = 7;
+
+  final AllocationCount accumulated = new AllocationCount();
+  final AllocationCount current = new AllocationCount();
+
+  void update(List stats) {
+    accumulated.instances = stats[ACCUMULATED];
+    accumulated.bytes = stats[ACCUMULATED_SIZE];
+    current.instances = stats[LIVE_AFTER_GC] + stats[ALLOCATED_SINCE_GC];
+    current.bytes = stats[LIVE_AFTER_GC_SIZE] + stats[ALLOCATED_SINCE_GC_SIZE];
+  }
+
+  bool get empty => accumulated.empty && current.empty;
+}
+
 class Class extends ServiceObject {
   @observable Library library;
   @observable Script script;
   @observable Class superClass;
 
   @observable bool isAbstract;
   @observable bool isConst;
   @observable bool isFinalized;
   @observable bool isPatch;
   @observable bool isImplemented;
 
   @observable int tokenPos;
 
   @observable ServiceMap error;
 
+  final Allocations newSpace = new Allocations();
+  final Allocations oldSpace = new Allocations();
+
+  bool get hasNoAllocations => newSpace.empty && oldSpace.empty;
+
   @reflectable final children = new ObservableList<Class>();
   @reflectable final subClasses = new ObservableList<Class>();
   @reflectable final fields = new ObservableList<ServiceMap>();
   @reflectable final functions = new ObservableList<ServiceMap>();
   @reflectable final interfaces = new ObservableList<Class>();
 
   bool get canCache => true;
   bool get immutable => false;
 
   Class._empty(ServiceObjectOwner owner) : super._empty(owner);
@@ skipping 738 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }