Native Image Committer Community Meeting 2021-12-16

[christianwimmer]

List of all past and upcoming meetings: #3933

New and Noteworthy

• Feature freeze for GraalVM 22.0 was on November 26, still possible to merge bugfixes for a few weeks.

• JDK 8 support is going to be deleted. Working through the whole GraalVM gate #system to remove JDK 8 ##gates.
  e02fcc1 Will be merged before Christmas. Really ;-)

• New user-friendly build output:
  [GR-33602] [RFC] More User-friendly Output for Native Image #3955
  [GR-33602] Improve and fix ProgressReporter (#3955). #4066
  [GR-33602] Bugfixes and improvements for ProgressReporter (#3955). #4100
  [GR-33602] Additional bugfixes for ProgressReporter (#3955). #4106
  [GR-33602] [GR-35238] [GR-35714] Additional bugfixes for ProgressReporter (#3955). #4123

• Module system support:
  [GR-34444] Replicate hosted module relations in runtime boot module layer #3991
  [GR-34740] [GR-34739] Implement ResourcesFeature Module awareness. #4007
  Support showing module names in stack traces #4056
  [GR-35630] Ensure modules from module path can resolve their system module dependencies. #4110

• Compatibility improvements:
  [GR-34703] Sealed classes support #3979
  8781e80 UseReferenceHandlerThread will be true by default soon to avoid deadlocks.
  07a0c3f Proper getStackAccessControlContext implementation

• JFR support:
  Adding support for JFR ExecutionSample event. #4005
  [GR-35806] Support Flight Recorder at image build time. #4125
  Refactor Jfr into core and hosted #3746 Merging blocked by JDK 8 removal

• Image size reduction:
  [GR-35117] Avoid pulling File and URL code in image via CodeSource.location. #4032 Uses static analysis reachability information to remove unnecessary code paths.

• Other
  [GR-21865] Introduce copy-on-write image heap provider on Windows. #4051
  [GR-34935] Run escape analysis before static analysis. #3993
  More usages of FactoryMethod #4085: Factory method are synthetic methods that combine allocation and constructor invocation
  e59968c and e26fa71: Certain GC arguments need to be parsed when isolate is created. Also, custom prologues/epilogues/handlers for CEntryPoint methods need to be explicitly Uninterruptible

• MacOS-AArch64 support:
  [GR-31170] Add some AArch64 Windows and Darwin features. #3864
  Fix fstat call in darwin-aarch64. #4107

• Continuations:
  [GR-34749] Continuation support independent of Project Loom. #4114

Deep Dive: New and improved heap scanning

Current approach:

• Scan entire heap from roots when analysis reaches a fixed point
  • Necessary to ensure newly reachable fields are seen and values processed
  • Restart analysis if new state is discovered
• Downsides of repeated scans
  • Performance overhead of repeated scans during analysis
  • Nothing prevents heap from modyfing after analysis
    • Late heap mutation can lead to hard to debug issues
      • The infamous Image heap writing found a class not seen during static analysis. error
        • https://github.com/oracle/graal/blob/master/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageHeap.java#L500
  • Scanned constants are discarded and heap is snapshoted later for image writing

Better approach: Scan and snapshot heap gradually and concurrently during analysis

• In the new architecture heap scanning and analysis work in tandem:
  • Reachable roots (static fields, embedded constants) lead to reachable types
  • Reachable types expand analysis universe, may lead to more reachable fields/methods
  • Reachable instance fields lead to heap expansion, i.e., scanning reachable constants
• Benefits of new heap scanning architecture:
  • Reduce number of scans from roots during analysis to reach a fixed point faster and reduce scanning overhead
  • Reuse snapshot when writing heap out to avoid re-scans and ensure no late heap mutation
• Some scans from roots are still necessary to capture lazy data structure mutation during analysis
  • After analysis fixed point run a verification scan from roots, patch heap if necessary and restart analysis
• Methods to avoid unnecessary re-scans from roots
  • Trigger early initialization for application/JDK caches, e.g., through eager class initialization
    • For example triggering computation of jdk.internal.access.SharedSecrets lazy fields in SecurityServicesFeature
      • https://github.com/oracle/graal/pull/3926/files#diff-b74986643ea0d26f6a08173f26b9330b4b26d3f4369a7a524b7bc2c36092d56fR330
  • Automatically re-scan well known VM caches during analysis as they mutate by using ImageHeapMap
    • Run time optimized map: ConcurrentHashMap at build time automatically transformed into EconomicMap for run time
      • https://github.com/oracle/graal/blob/master/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/util/ImageHeapMap.java#L53
    • Observable during image heap building, i.e., its mutations are tracked and automatically snapshotted
  • For application code guide developers through actionable reports (-H:HeapVerifierVerbosity=1)
    • e.g., “Init map reachable from static field x.y.Z.f early to avoid re-scan ...”
    • Code restructuring may be necessary

Current status

• Concurrent scanning during analysis and verification implemented
  • Refactor Native Image heap scanning. #3926
• Observed 20% reduction in analysis time, e.g. when building the Truffle JS engine
  • More optimizations are necessary, e.g., reducing the size of the heap snapshot

Code structure

The heap snapshot

• The main class is com.oracle.graal.pointsto.heap.ImageHeap
  • https://github.com/oracle/graal/pull/3926/files#diff-7f4956afa5f90124c9f78de1e46b5bd006951e7071f925617845dc8c2613711bR40
• It stores the object snapshots as com.oracle.graal.pointsto.heap.ImageHeap.ImageHeapObject
  • The ImageHeapObject wraps the original JavaConstant and holds an array of referenced values (either fileds or array elements)
• An ImageHeapObject is created when a constant value is found as reachable by the ImageHeapScanner

The heap scanner

• The main class is com.oracle.graal.pointsto.heap.ImageHeapScanner
• The scanning API has three main entry points:
  • Constants embedded in Graal graphs are scanned when the graph is first parsed:
    • com.oracle.graal.pointsto.heap.ImageHeapScanner#scanEmbeddedRoot
      • https://github.com/oracle/graal/pull/3926/files#diff-8762aafe4f2ae0abc5b2499edcdd5e7276a1f72f0f4a0fc53a79ae75b19fe83bR112
  • Field values are scanned when a field is marked as accessed (i.e., unsafe accessed or read)
    • com.oracle.graal.pointsto.heap.ImageHeapScanner#onFieldRead
      • https://github.com/oracle/graal/pull/3926/files#diff-8762aafe4f2ae0abc5b2499edcdd5e7276a1f72f0f4a0fc53a79ae75b19fe83bR128
    • For static fields first the static state of its declaring class is computed (com.oracle.graal.pointsto.heap.TypeData)
    • For instance fields all objects snapshotted so far are iterated and the field value is scanned
  • Rescaning can be used to programatically trigger scanning during analysis for either
    • a static field
      • com.oracle.graal.pointsto.heap.ImageHeapScanner#rescanRoot
        • https://github.com/oracle/graal/pull/3926/files#diff-8762aafe4f2ae0abc5b2499edcdd5e7276a1f72f0f4a0fc53a79ae75b19fe83bR441
    • an instance field of a specific receiver
      • com.oracle.graal.pointsto.heap.ImageHeapScanner#rescanField
        • https://github.com/oracle/graal/pull/3926/files#diff-8762aafe4f2ae0abc5b2499edcdd5e7276a1f72f0f4a0fc53a79ae75b19fe83bR463
    • an object, i.e., all its fields are rescanned
      • com.oracle.graal.pointsto.heap.ImageHeapScanner#rescanObject
        • https://github.com/oracle/graal/pull/3926/files#diff-8762aafe4f2ae0abc5b2499edcdd5e7276a1f72f0f4a0fc53a79ae75b19fe83bR503

The heap snapshot verifier

• The main class is com.oracle.graal.pointsto.heap.HeapSnapshotVerifier
• The verification API entry point is
  • com.oracle.graal.pointsto.heap.HeapSnapshotVerifier#verifyHeapSnapshot
    • https://github.com/oracle/graal/pull/3926/files#diff-7d580fac50f0174fc7dec26f691126dda9e042b59223e278a6832fa600e6cc34R120
• It scans the entire heap from roots, patching the heap snapshot and notifying when analysis state has changed
  • It implements com.oracle.graal.pointsto.ObjectScanningObserver and reuses com.oracle.graal.pointsto.ObjectScanner
• If analysis state changes during verification then another analysis iteration is run

Future steps

• Reuse heap snapshot also for the image writing phase
  • Currently there is a complete re-scan from roots before writing out the heap
  • Requires major refactoring: there are many “lazy“ values computed based on analysis results

Open Discussion

Possible deep dive topics for next meeting

Please send suggestions, or "upvote" a suggestion, by adding a comment to this discussion.

• Reflection configuration: "query only" vs. "allow invocation" configuration for methods
• Conditional reflection configuration
• Module system implementation: state and implications
• CE debug information generation (RedHat)