Thread-Local Object Split-Scalarization for Heap Access Reduction

The patent segments the scalarization optimization into two distinct parts: scalarized fields (stored in local variables) and non-scalarized fields (stored in heap memory). This segmentation allows thread-local objects to be partially optimized through split-scalarization, where only the scalarizable portion benefits from reduced memory overhead while the non-scalarizable portion maintains heap storage. This resolves the contradiction by enabling selective optimization of thread-local objects without requiring complete scalarization.

The patent applies local quality by differentiating between scalarizable and non-scalarizable fields within the same object. Each field is analyzed independently to determine its scalarization eligibility based on whether it is accessed exclusively within a single thread. This allows the optimizer to apply different storage strategies (local variable vs. heap memory) to different fields, achieving memory overhead reduction for thread-local fields while maintaining correctness for shared fields.

The patent introduces dynamic analysis through escape analysis that determines at compile time whether each field is thread-local or shared. The scalarization decision is not static but dynamically adapted based on the actual access patterns detected during analysis. Fields that escape the current method (potentially shared by multiple threads) are marked as non-scalarizable and stored in heap memory, while fields that remain confined to a single thread are scalarized. This dynamic approach ensures thread safety while maximizing memory overhead reduction.

The patent employs feedback through iterative analysis passes that examine field access patterns and determine scalarization eligibility. The escape analysis feedback loop identifies which fields are accessed by multiple threads and prevents their scalarization, while allowing scalarization of purely thread-local fields. This feedback mechanism ensures that the optimization maintains thread safety correctness while achieving memory overhead reduction for eligible fields.