Fine. Use library manifest handles; discard instances to save memory

Replace in-memory `LibraryManifest` objects with lightweight
`LibraryManifestHandle`s that carry a requirements hash and (optionally)
serialized bytes. Handles defer deserialization, can discard the live
instance, and rehydrate on demand. This reduces heap usage without
sacrificing correctness.

Key changes:
- Introduce `LibraryManifestHandle` with `hashForRequirements`, lazy
  `instance` materialization, and `discardInstance()`.
- Persist and load handles in the linked bundle cache entry; cache now
  stores the manifest hash + bytes instead of full objects.
- Change `LibraryElementImpl.manifest` to `LibraryManifestHandle?` and
  update call sites to use `.instance` or `.hashForRequirements` as
  appropriate.
- Update `BundleReader`, `LibraryContext`, and manifest builder to pass
  and produce handles; builder emits handles via
  `LibraryManifestHandle.fromInstance(...)`.
- Add `LinkedElementFactory.discardLibraryManifestInstances()` and call
  it from the scheduler when idle (with fine dependencies enabled) to
  aggressively free manifest instances.
- Bump `AnalysisDriver.DATA_VERSION` from 567 to 568 to invalidate old
  cached entries that used plain manifests.

Impact:
- Peak memory drops from ~785 MB to ~652 MB (−133 MB, −17.0%) with
  fine-grained dependencies enabled.
- Compared to the ~512 MB baseline without fine-grained dependencies,
  the new peak is +140 MB (+27.3%).

Rationale: By storing only a digest and bytes most of the time, we keep
manifests off-heap until their full contents are needed, while
preserving stable IDs and compatibility across relinks.

Change-Id: Ibbfd0159d73ecca93835b7ee447cc05ec8eefb09
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/452260
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -106,7 +106,7 @@ testFineAfterLibraryAnalyzerHook;
 // TODO(scheglov): Clean up the list of implicitly analyzed files.
 class AnalysisDriver {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 567;
+  static const int DATA_VERSION = 568;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.
@@ -2637,6 +2637,8 @@ class AnalysisDriverScheduler {
         if (priority == AnalysisDriverPriority.nothing) {
           if (driver.withFineDependencies) {
             driver.currentSession.clearHierarchies();
+            driver.libraryContext.elementFactory
+                .discardLibraryManifestInstances();
           }
         }
       }

pkg/analyzer/lib/src/dart/analysis/library_context.dart

@@ -33,6 +33,7 @@ import 'package:analyzer/src/summary2/link.dart';
 import 'package:analyzer/src/summary2/linked_element_factory.dart';
 import 'package:analyzer/src/summary2/reference.dart';
 import 'package:analyzer/src/util/performance/operation_performance.dart';
+import 'package:analyzer/src/utilities/extensions/collection.dart';
 import 'package:collection/collection.dart';
 
 /// Context information necessary to analyze one or more libraries within an
@@ -242,12 +243,15 @@ class LibraryContext {
           });
           newLinkedBytes = linkResult.resolutionBytes;
 
-          var newLibraryManifests = <Uri, LibraryManifest>{};
+          var newLibraryManifests = <Uri, LibraryManifestHandle>{};
           performance.run('computeManifests', (performance) {
+            var inputManifests = performance.run('inputManifests', (_) {
+              return probe.libraryManifests.mapValue((h) => h.instance);
+            });
             newLibraryManifests = LibraryManifestBuilder(
               elementFactory: elementFactory,
               inputLibraries: cycle.libraries,
-              inputManifests: probe.libraryManifests,
+              inputManifests: inputManifests,
             ).computeManifests(performance: performance);
             elementFactory.libraryManifests.addAll(newLibraryManifests);
           });
@@ -493,7 +497,7 @@ class _LinkedBundleCacheEntry {
   ///
   /// If we have to relink libraries, we will match new elements against
   /// these old manifests, and reuse IDs for not affected elements.
-  final Map<Uri, LibraryManifest> libraryManifests;
+  final Map<Uri, LibraryManifestHandle> libraryManifests;
 
   /// The serialized libraries, for [BundleReader].
   final Uint8List linkedBytes;
@@ -548,27 +552,15 @@ class _LinkedBundleCacheEntry {
     var reader = BinaryReader(bytes);
     reader.initFromTableTrailer();
 
-    var nonTransitiveApiSignature = reader.readStringUtf8();
-    var requirementsDigest = RequirementsManifestDigest.read(reader);
-    var requirementsBytes = reader.readUint8List();
-
-    var libraryManifests = performance.run('readLibraryManifests', (
-      performance,
-    ) {
-      return reader.readMap(
-        readKey: () => reader.readUri(),
-        readValue: () => LibraryManifest.read(reader),
-      );
-    });
-
-    var linkedBytes = reader.readUint8List();
-
     var result = _LinkedBundleCacheEntry(
-      nonTransitiveApiSignature: nonTransitiveApiSignature,
-      requirementsDigest: requirementsDigest,
-      requirementsBytes: requirementsBytes,
-      libraryManifests: libraryManifests,
-      linkedBytes: linkedBytes,
+      nonTransitiveApiSignature: reader.readStringUtf8(),
+      requirementsDigest: RequirementsManifestDigest.read(reader),
+      requirementsBytes: reader.readUint8List(),
+      libraryManifests: reader.readMap(
+        readKey: () => reader.readUri(),
+        readValue: () => LibraryManifestHandle.read(reader),
+      ),
+      linkedBytes: reader.readUint8List(),
     );
 
     // We have copies of all data.
@@ -579,7 +571,7 @@ class _LinkedBundleCacheEntry {
 }
 
 class _LinkedBundleProbeResult {
-  final Map<Uri, LibraryManifest> libraryManifests;
+  final Map<Uri, LibraryManifestHandle> libraryManifests;
   final Uint8List? linkedBytes;
 
   _LinkedBundleProbeResult({

pkg/analyzer/lib/src/dart/element/element.dart

@@ -6036,7 +6036,7 @@ class LibraryElementImpl extends ElementImpl
 
   /// With fine-grained dependencies, the manifest of the library.
   @trackedInternal
-  LibraryManifest? manifest;
+  LibraryManifestHandle? manifest;
 
   @trackedInternal
   LibraryElementRequirementState requirementState =

pkg/analyzer/lib/src/fine/library_manifest.dart

@@ -277,9 +277,6 @@ class LibraryManifestBuilder {
   /// items for declared elements that don't have items in this map.
   final Map<Element, ManifestItem> declaredItems = Map.identity();
 
-  /// The new manifests for libraries.
-  final Map<Uri, LibraryManifest> newManifests = {};
-
   LibraryManifestBuilder({
     required this.elementFactory,
     required this.inputLibraries,
@@ -292,7 +289,7 @@ class LibraryManifestBuilder {
         .toList(growable: false);
   }
 
-  Map<Uri, LibraryManifest> computeManifests({
+  Map<Uri, LibraryManifestHandle> computeManifests({
     required OperationPerformanceImpl performance,
   }) {
     performance.getDataInt('libraryCount').add(inputLibraries.length);
@@ -310,7 +307,10 @@ class LibraryManifestBuilder {
 
     assert(_assertSerialization());
 
-    return newManifests;
+    return {
+      for (var libraryElement in libraryElements)
+        libraryElement.uri: libraryElement.manifest!,
+    };
   }
 
   void _addClass({
@@ -429,7 +429,7 @@ class LibraryManifestBuilder {
 
   void _addExportedExtensions() {
     for (var libraryElement in libraryElements) {
-      var manifest = libraryElement.manifest!;
+      var manifest = libraryElement.manifest!.instance;
 
       var extensionIds = <ManifestItemId>{};
 
@@ -440,7 +440,8 @@ class LibraryManifestBuilder {
           .whereType<ExtensionElementImpl>();
       for (var extensionElement in exportedExtensionElements) {
         var extensionName = extensionElement.lookupName?.asLookupName;
-        var extensionLibraryManifest = extensionElement.library.manifest!;
+        var extensionLibraryManifest =
+            extensionElement.library.manifest!.instance;
         var extensionItem =
             extensionLibraryManifest.declaredExtensions[extensionName]!;
         extensionIds.add(extensionItem.id);
@@ -707,8 +708,7 @@ class LibraryManifestBuilder {
 
   void _addReExports() {
     for (var libraryElement in libraryElements) {
-      var libraryUri = libraryElement.uri;
-      var manifest = newManifests[libraryUri]!;
+      var manifest = libraryElement.manifest!.instance;
 
       for (var exported in libraryElement.exportedReferences) {
         // We want only re-exports, skip declared.
@@ -731,7 +731,7 @@ class LibraryManifestBuilder {
 
         // Every library has a manifest at this point.
         // We already set manifests for the current cycle.
-        var elementLibraryManifest = elementLibrary.manifest!;
+        var elementLibraryManifest = elementLibrary.manifest!.instance;
 
         // We use the manifest of the library that declares this element.
         // So, the element must be declared in the manifest.
@@ -828,27 +828,29 @@ class LibraryManifestBuilder {
   /// Assert that every manifest can be serialized, and when deserialized
   /// results in the same manifest.
   bool _assertSerialization() {
-    newManifests.forEach((uri, manifest) {
+    for (var libraryElement in libraryElements) {
+      var uri = libraryElement.uri;
+      var manifest = libraryElement.manifest!.instance;
+
       var bytes = manifest.toBytes();
       var readManifest = LibraryManifest.fromBytes(bytes);
       var readBytes = readManifest.toBytes();
 
       if (!const ListEquality<int>().equals(bytes, readBytes)) {
         throw StateError('Library manifest bytes are different: $uri');
       }
-    });
+    }
 
     return true;
   }
 
   /// Fill `result` with new library manifests.
   /// We reuse existing items when they fully match.
   /// We build new items for mismatched elements.
-  Map<Uri, LibraryManifest> _buildManifests() {
+  void _buildManifests() {
     var encodingContext = EncodeContext(elementFactory: elementFactory);
 
     for (var libraryElement in libraryElements) {
-      var libraryUri = libraryElement.uri;
       var newClassItems = <LookupName, ClassItem>{};
       var newEnumItems = <LookupName, EnumItem>{};
       var newExtensionItems = <LookupName, ExtensionItem>{};
@@ -975,19 +977,16 @@ class LibraryManifestBuilder {
         exportedExtensions: ManifestItemIdList([]),
         hashForRequirements: Hash.empty,
       );
-      libraryElement.manifest = newManifest;
-      newManifests[libraryUri] = newManifest;
+      libraryElement.manifest = LibraryManifestHandle.fromInstance(newManifest);
     }
 
     _fillInterfaceElementsInterface();
     _addClassTypeAliasConstructors();
-
-    return newManifests;
   }
 
   void _computeHashForRequirements() {
     for (var libraryElement in libraryElements) {
-      var manifest = libraryElement.manifest!;
+      var manifest = libraryElement.manifest!.instance;
       var builder = ApiSignature();
 
       List<MapEntry<LookupName, T>> sortedMapEntries<T>(
@@ -1097,7 +1096,7 @@ class LibraryManifestBuilder {
 
     for (var libraryElement in libraryElements) {
       var libraryUri = libraryElement.uri;
-      var manifest = newManifests[libraryUri]!;
+      var manifest = libraryElement.manifest!.instance;
       manifest._fillExportMap();
 
       var inputManifest = _getInputManifest(libraryUri);
@@ -1391,6 +1390,81 @@ class LibraryManifestBuilder {
   }
 }
 
+/// Handle for [LibraryManifest.hashForRequirements] or [instance].
+///
+/// Most [RequirementsManifest] can be checked using just [hashForRequirements],
+/// so we don't even need to read the whole [instance] from bytes. But we can,
+/// if we have to check for details of the manifest.
+///
+/// This class has several states:
+/// 1. Has incomplete [_instance], during building.
+/// 2. Has complete [_instance], no bytes, after building.
+/// 3. Has [_instance], has bytes, after building and write.
+/// 4. No [_instance], has bytes, after [discardInstance] or `read`.
+/// 5. Has [instance], has bytes, after [instance] read it.
+class LibraryManifestHandle {
+  Hash? _hashForRequirements;
+  Uint8List? _bytes;
+  LibraryManifest? _instance;
+
+  LibraryManifestHandle({
+    required Hash? hashForRequirements,
+    required Uint8List? bytes,
+    required LibraryManifest? instance,
+  }) : _hashForRequirements = hashForRequirements,
+       _bytes = bytes,
+       _instance = instance;
+
+  factory LibraryManifestHandle.fromInstance(LibraryManifest instance) {
+    // Note, we don't convert instance to bytes here.
+    // The instance is not finished yet in the builder.
+    return LibraryManifestHandle(
+      bytes: null,
+      hashForRequirements: null,
+      instance: instance,
+    );
+  }
+
+  factory LibraryManifestHandle.read(BinaryReader reader) {
+    return LibraryManifestHandle(
+      hashForRequirements: Hash.read(reader),
+      bytes: reader.readUint8List(),
+      instance: null,
+    );
+  }
+
+  Hash get hashForRequirements {
+    return _hashForRequirements ?? _instance!.hashForRequirements;
+  }
+
+  LibraryManifest get instance {
+    return _instance ??= LibraryManifest.fromBytes(_bytes!);
+  }
+
+  void discardInstance() {
+    if (_instance case var instance?) {
+      _hashForRequirements ??= instance.hashForRequirements;
+      _bytes ??= instance.toBytes();
+    }
+    _instance = null;
+  }
+
+  void write(BinaryWriter writer) {
+    var hashForRequirements =
+        _hashForRequirements ?? _instance?.hashForRequirements;
+    if (hashForRequirements == null) {
+      throw StateError('Missing hashForRequirements');
+    }
+    hashForRequirements.write(writer);
+
+    var bytes = _bytes ?? _instance?.toBytes();
+    if (bytes == null) {
+      throw StateError('Missing bytes');
+    }
+    writer.writeUint8List(bytes);
+  }
+}
+
 /// Compares structures of [library] children against [manifest].
 class _LibraryMatch {
   final LibraryElementImpl library;

pkg/analyzer/lib/src/fine/manifest_context.dart

@@ -365,7 +365,7 @@ extension LinkedElementFactoryExtension on LinkedElementFactory {
     var libraryUri = topLevelElement.library!.uri;
 
     // Prepare the external library manifest.
-    var manifest = libraryManifests[libraryUri];
+    var manifest = libraryManifests[libraryUri]?.instance;
     if (manifest == null) {
       return null;
     }