Diff heap statistics.

packages/devtools_app/lib/src/screens/memory/panes/diff/controller/diff_pane_controller.dart

@@ -10,13 +10,16 @@ import 'package:flutter/foundation.dart';
 import '../../../../../primitives/utils.dart';
 import '../../../primitives/memory_utils.dart';
 import '../../../shared/heap/model.dart';
-import 'model.dart';
+import 'heap_diff.dart';
+import 'item_controller.dart';
 
 class DiffPaneController {
   DiffPaneController(this.snapshotTaker);
 
   final SnapshotTaker snapshotTaker;
 
+  final diffStore = HeapDiffStore();
+
   /// The list contains one item that show information and all others
   /// are snapshots.
   ValueListenable<List<DiffListItem>> get snapshots => _snapshots;
@@ -29,7 +32,12 @@ class DiffPaneController {
   ValueListenable<bool> get isProcessing => _isProcessing;
   final _isProcessing = ValueNotifier<bool>(false);
 
-  DiffListItem get selected => snapshots.value[selectedIndex.value];
+  DiffListItem get selectedItem => snapshots.value[selectedIndex.value];
+
+  /// Full name for the selected class.
+  ValueListenable<String?> get selectedClass => _selectedClass;
+  final _selectedClass = ValueNotifier<String?>(null);
+  void setSelectedClass(String? value) => _selectedClass.value = value;
 
   /// True, if the list contains snapshots, i.e. items beyond the first
   /// informational item.
@@ -43,6 +51,8 @@ class DiffPaneController {
         future,
         _nextDisplayNumber(),
         currentIsolateName ?? '<isolate-not-detected>',
+        diffStore,
+        selectedClass,
       ),
     );
     await future;
@@ -52,6 +62,9 @@ class DiffPaneController {
   }
 
   Future<void> clearSnapshots() async {
+    for (var i = 1; i < snapshots.value.length; i++) {
+      snapshots.value[i].dispose();
+    }
     _snapshots.removeRange(1, snapshots.value.length);
     _selectedIndex.value = 0;
   }
@@ -63,7 +76,8 @@ class DiffPaneController {
   }
 
   void deleteCurrentSnapshot() {
-    assert(selected is SnapshotListItem);
+    assert(selectedItem is SnapshotListItem);
+    selectedItem.dispose();
     _snapshots.removeRange(selectedIndex.value, selectedIndex.value + 1);
     // We must change the selectedIndex, because otherwise the content will
     // not be re-rendered.

packages/devtools_app/lib/src/screens/memory/panes/diff/controller/heap_diff.dart

@@ -0,0 +1,102 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/foundation.dart';
+
+import '../../../shared/heap/heap.dart';
+import '../../../shared/heap/model.dart';
+
+/// Stores already calculated comparisons for heap couples.
+class HeapDiffStore {
+  final _store = <_HeapCouple, HeapComparison>{};
+
+  HeapComparison compare(AdaptedHeap heap1, AdaptedHeap heap2) {
+    final couple = _HeapCouple(heap1, heap2);
+    return _store.putIfAbsent(couple, () => HeapComparison(couple));
+  }
+}
+
+@immutable
+class _HeapCouple {
+  _HeapCouple(AdaptedHeap heap1, AdaptedHeap heap2) {
+    older = _older(heap1, heap2);
+    younger = older == heap1 ? heap2 : heap1;
+  }
+
+  late final AdaptedHeap older;
+  late final AdaptedHeap younger;
+
+  /// Finds most deterministic way to declare earliest heap.
+  ///
+  /// If earliest heap cannot be identified, returns first argument.
+  static AdaptedHeap _older(AdaptedHeap heap1, AdaptedHeap heap2) {
+    assert(heap1.data != heap2.data);
+    if (heap1.data.created.isBefore(heap2.data.created)) return heap1;
+    if (heap2.data.created.isBefore(heap1.data.created)) return heap2;
+    if (identityHashCode(heap1) < identityHashCode(heap2)) return heap1;
+    if (identityHashCode(heap2) < identityHashCode(heap1)) return heap2;
+    if (identityHashCode(heap1.data) < identityHashCode(heap2.data))
+      return heap1;
+    if (identityHashCode(heap2.data) < identityHashCode(heap1.data))
+      return heap2;
+    return heap1;
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (other.runtimeType != runtimeType) {
+      return false;
+    }
+    return other is _HeapCouple &&
+        other.older == older &&
+        other.younger == younger;
+  }
+
+  @override
+  int get hashCode => Object.hash(older, younger);
+}
+
+class HeapComparison {
+  HeapComparison(this.heapCouple);
+
+  late final HeapStatistics stats = _stats();
+
+  final _HeapCouple heapCouple;
+
+  HeapStatistics _stats() {
+    final result = <String, HeapStatsRecord>{};
+
+    final older = heapCouple.older.stats.recordsByClass;
+    final younger = heapCouple.younger.stats.recordsByClass;
+
+    final unionOfKeys = older.keys.toSet().union(younger.keys.toSet());
+
+    for (var key in unionOfKeys) {
+      final olderRecord = older[key];
+      final youngerRecord = younger[key];
+
+      if (olderRecord != null && youngerRecord != null) {
+        final diff = _diffStatsRecords(olderRecord, youngerRecord);
+        if (!diff.isZero) result[key] = diff;
+      } else if (youngerRecord != null) {
+        result[key] = youngerRecord;
+      } else {
+        result[key] = olderRecord!.negative();
+      }
+    }
+
+    return HeapStatistics(result);
+  }
+
+  static HeapStatsRecord _diffStatsRecords(
+    HeapStatsRecord older,
+    HeapStatsRecord younger,
+  ) {
+    assert(older.heapClass.fullName == younger.heapClass.fullName);
+    return HeapStatsRecord(older.heapClass)
+      ..instanceCount = younger.instanceCount - older.instanceCount
+      ..shallowSize = younger.shallowSize - older.shallowSize
+      ..retainedSize = younger.retainedSize - older.retainedSize;
+  }
+}

packages/devtools_app/lib/src/screens/memory/panes/diff/controller/item_controller.dart

@@ -0,0 +1,97 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/foundation.dart';
+
+import '../../../../../primitives/auto_dispose.dart';
+import '../../../../../primitives/utils.dart';
+import '../../../shared/heap/heap.dart';
+import '../../../shared/heap/model.dart';
+import 'heap_diff.dart';
+
+abstract class DiffListItem extends DisposableController {
+  /// Number, that if shown in name, should be unique in the list.
+  ///
+  /// If the number is not expected to be shown in UI, it should be 0.
+  int get displayNumber;
+
+  ValueListenable<bool> get isProcessing => _isProcessing;
+  final _isProcessing = ValueNotifier<bool>(false);
+
+  /// If true, the item contains data, that can be compared and analyzed.
+  bool get hasData;
+}
+
+class InformationListItem extends DiffListItem {
+  @override
+  int get displayNumber => 0;
+
+  @override
+  bool get hasData => false;
+}
+
+class SnapshotListItem extends DiffListItem with AutoDisposeControllerMixin {
+  SnapshotListItem(
+    Future<AdaptedHeapData?> receiver,
+    this.displayNumber,
+    this._isolateName,
+    this.diffStore,
+    this.selectedClassName,
+  ) {
+    _isProcessing.value = true;
+    receiver.whenComplete(() async {
+      final data = await receiver;
+      if (data != null) {
+        heap = AdaptedHeap(data);
+        updateSelectedRecord();
+        addAutoDisposeListener(selectedClassName, () => updateSelectedRecord());
+      }
+      _isProcessing.value = false;
+    });
+  }
+
+  final String _isolateName;
+
+  final HeapDiffStore diffStore;
+
+  AdaptedHeap? heap;
+
+  @override
+  final int displayNumber;
+
+  String get name => '$_isolateName-$displayNumber';
+
+  var sorting = ColumnSorting();
+
+  ValueListenable<SnapshotListItem?> get diffWith => _diffWith;
+  final _diffWith = ValueNotifier<SnapshotListItem?>(null);
+  void setDiffWith(SnapshotListItem? value) {
+    _diffWith.value = value;
+    updateSelectedRecord();
+  }
+
+  final ValueListenable<String?> selectedClassName;
+
+  ValueListenable<HeapStatsRecord?> get selectedRecord => _selectedRecord;
+  final _selectedRecord = ValueNotifier<HeapStatsRecord?>(null);
+
+  @override
+  bool get hasData => heap != null;
+
+  HeapStatistics get statsToShow {
+    final theHeap = heap!;
+    final itemToDiffWith = diffWith.value;
+    if (itemToDiffWith == null) return theHeap.stats;
+    return diffStore.compare(theHeap, itemToDiffWith.heap!).stats;
+  }
+
+  void updateSelectedRecord() => _selectedRecord.value =
+      statsToShow.recordsByClass[selectedClassName.value];
+}
+
+class ColumnSorting {
+  bool initialized = false;
+  SortDirection direction = SortDirection.ascending;
+  int columnIndex = 0;
+}

packages/devtools_app/lib/src/screens/memory/panes/diff/diff_pane.dart

@@ -6,8 +6,9 @@ import 'package:flutter/material.dart';
 
 import '../../../../shared/common_widgets.dart';
 import '../../../../shared/split.dart';
+import '../../../../shared/theme.dart';
 import 'controller/diff_pane_controller.dart';
-import 'controller/model.dart';
+import 'controller/item_controller.dart';
 import 'widgets/snapshot_control_pane.dart';
 import 'widgets/snapshot_list.dart';
 import 'widgets/snapshot_view.dart';
@@ -22,7 +23,7 @@ class DiffPane extends StatelessWidget {
     final Widget itemContent = ValueListenableBuilder<int>(
       valueListenable: controller.selectedIndex,
       builder: (_, index, __) {
-        final item = controller.selected;
+        final item = controller.selectedItem;
 
         if (item is InformationListItem) {
           return const _SnapshotDoc();
@@ -68,7 +69,7 @@ class _SnapshotDoc extends StatelessWidget {
 
 class _SnapshotContent extends StatelessWidget {
   _SnapshotContent({Key? key, required this.item, required this.controller})
-      : assert(controller.selected == item),
+      : assert(controller.selectedItem == item),
         super(key: key);
 
   final SnapshotListItem item;
@@ -78,9 +79,11 @@ class _SnapshotContent extends StatelessWidget {
   Widget build(BuildContext context) {
     return Column(
       children: [
+        const SizedBox(height: denseRowSpacing),
         SnapshotControlPane(controller: controller),
+        const SizedBox(height: denseRowSpacing),
         Expanded(
-          child: SnapshotView(item: item),
+          child: SnapshotView(controller: controller),
         ),
       ],
     );

packages/devtools_app/lib/src/screens/memory/panes/diff/widgets/class_details.dart

@@ -0,0 +1,24 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/widgets.dart';
+
+import '../../../shared/heap/model.dart';
+
+class HeapClassDetails extends StatelessWidget {
+  const HeapClassDetails({Key? key, required this.heapClass}) : super(key: key);
+
+  final HeapClass? heapClass;
+
+  @override
+  Widget build(BuildContext context) {
+    final theClass = heapClass;
+    if (theClass == null) {
+      return const Center(
+        child: Text('Select class to see details here.'),
+      );
+    }
+    return Center(child: Text('Details for ${theClass.fullName} will be here'));
+  }
+}