ZJIT: handle megamorphic and skewed megamorphic profiling results

Author: st0012

zjit/src/hir.rs

@@ -564,29 +564,35 @@ impl std::fmt::Display for SideExitReason {
 /// Represents whether we know the receiver's class statically at compile-time,
 /// have profiled type information, or know nothing about it.
 pub enum ReceiverTypeResolution {
-    /// The receiver's class is statically known at JIT compile-time (no guard needed)
-    StaticallyKnown { class: VALUE },
+    /// No profile information available for the receiver
+    NoProfile,
     /// The receiver has a monomorphic profile (single type observed, guard needed)
     Monomorphic { class: VALUE, profiled_type: ProfiledType },
-    /// The receiver has a skewed polymorphic profile (dominant type with some other types, guard needed)
-    SkewedPolymorphic { class: VALUE, profiled_type: ProfiledType },
     /// The receiver is polymorphic (multiple types, none dominant)
     Polymorphic,
-    /// No profile information available for the receiver
-    NoProfile,
+    /// The receiver has a skewed polymorphic profile (dominant type with some other types, guard needed)
+    SkewedPolymorphic { class: VALUE, profiled_type: ProfiledType },
+    /// More than N types seen with no clear winner
+    Megamorphic,
+    /// Megamorphic, but with a significant skew towards one type
+    SkewedMegamorphic { class: VALUE, profiled_type: ProfiledType },
+    /// The receiver's class is statically known at JIT compile-time (no guard needed)
+    StaticallyKnown { class: VALUE },
 }
 
 /// Reason why a send-ish instruction cannot be optimized from a fallback instruction
 #[derive(Debug, Clone, Copy)]
 pub enum SendFallbackReason {
     SendWithoutBlockPolymorphic,
+    SendWithoutBlockMegamorphic,
     SendWithoutBlockNoProfiles,
     SendWithoutBlockCfuncNotVariadic,
     SendWithoutBlockCfuncArrayVariadic,
     SendWithoutBlockNotOptimizedMethodType(MethodType),
     SendWithoutBlockNotOptimizedOptimizedMethodType(OptimizedMethodType),
     SendWithoutBlockDirectTooManyArgs,
     SendPolymorphic,
+    SendMegamorphic,
     SendNoProfiles,
     SendNotOptimizedMethodType(MethodType),
     CCallWithFrameTooManyArgs,
@@ -2156,8 +2162,16 @@ impl Function {
                         class: profiled_type.class(),
                         profiled_type,
                     };
+                } else if entry_type_summary.is_skewed_megamorphic() {
+                    let profiled_type = entry_type_summary.bucket(0);
+                    return ReceiverTypeResolution::SkewedMegamorphic {
+                        class: profiled_type.class(),
+                        profiled_type,
+                    };
                 } else if entry_type_summary.is_polymorphic() {
                     return ReceiverTypeResolution::Polymorphic;
+                } else if entry_type_summary.is_megamorphic() {
+                    return ReceiverTypeResolution::Megamorphic;
                 }
             }
         }
@@ -2312,7 +2326,15 @@ impl Function {
                         let (klass, profiled_type) = match self.resolve_receiver_type(recv, self.type_of(recv), frame_state.insn_idx) {
                             ReceiverTypeResolution::StaticallyKnown { class } => (class, None),
                             ReceiverTypeResolution::Monomorphic { class, profiled_type }
-                            | ReceiverTypeResolution::SkewedPolymorphic { class, profiled_type } => (class, Some(profiled_type)),
+                            | ReceiverTypeResolution::SkewedPolymorphic { class, profiled_type }
+                            | ReceiverTypeResolution::SkewedMegamorphic { class, profiled_type } => (class, Some(profiled_type)),
+                            ReceiverTypeResolution::Megamorphic => {
+                                if get_option!(stats) {
+                                    self.set_dynamic_send_reason(insn_id, SendWithoutBlockMegamorphic);
+                                }
+                                self.push_insn_id(block, insn_id);
+                                continue;
+                            }
                             ReceiverTypeResolution::Polymorphic => {
                                 if get_option!(stats) {
                                     self.set_dynamic_send_reason(insn_id, SendWithoutBlockPolymorphic);
@@ -2505,7 +2527,15 @@ impl Function {
                         let klass = match self.resolve_receiver_type(recv, self.type_of(recv), frame_state.insn_idx) {
                             ReceiverTypeResolution::StaticallyKnown { class } => class,
                             ReceiverTypeResolution::Monomorphic { class, .. }
-                            | ReceiverTypeResolution::SkewedPolymorphic { class, .. } => class,
+                            | ReceiverTypeResolution::SkewedPolymorphic { class, .. }
+                            | ReceiverTypeResolution::SkewedMegamorphic { class, .. } => class,
+                            ReceiverTypeResolution::Megamorphic => {
+                                if get_option!(stats) {
+                                    self.set_dynamic_send_reason(insn_id, SendMegamorphic);
+                                }
+                                self.push_insn_id(block, insn_id);
+                                continue;
+                            }
                             ReceiverTypeResolution::Polymorphic => {
                                 if get_option!(stats) {
                                     self.set_dynamic_send_reason(insn_id, SendPolymorphic);
@@ -2785,8 +2815,9 @@ impl Function {
             let (recv_class, profiled_type) = match fun.resolve_receiver_type(recv, self_type, iseq_insn_idx) {
                 ReceiverTypeResolution::StaticallyKnown { class } => (class, None),
                 ReceiverTypeResolution::Monomorphic { class, profiled_type }
-                | ReceiverTypeResolution::SkewedPolymorphic { class, profiled_type } => (class, Some(profiled_type)),
-                ReceiverTypeResolution::Polymorphic | ReceiverTypeResolution::NoProfile => return Err(()),
+                | ReceiverTypeResolution::SkewedPolymorphic { class, profiled_type }
+                | ReceiverTypeResolution::SkewedMegamorphic { class, profiled_type } => (class, Some(profiled_type)),
+                ReceiverTypeResolution::Polymorphic | ReceiverTypeResolution::Megamorphic | ReceiverTypeResolution::NoProfile => return Err(()),
             };
 
             // Do method lookup
@@ -2890,8 +2921,9 @@ impl Function {
             let (recv_class, profiled_type) = match fun.resolve_receiver_type(recv, self_type, iseq_insn_idx) {
                 ReceiverTypeResolution::StaticallyKnown { class } => (class, None),
                 ReceiverTypeResolution::Monomorphic { class, profiled_type }
-                | ReceiverTypeResolution::SkewedPolymorphic { class, profiled_type } => (class, Some(profiled_type)),
-                ReceiverTypeResolution::Polymorphic | ReceiverTypeResolution::NoProfile => return Err(()),
+                | ReceiverTypeResolution::SkewedPolymorphic { class, profiled_type }
+                | ReceiverTypeResolution::SkewedMegamorphic { class, profiled_type } => (class, Some(profiled_type)),
+                ReceiverTypeResolution::Polymorphic | ReceiverTypeResolution::Megamorphic | ReceiverTypeResolution::NoProfile => return Err(()),
             };
 
             // Do method lookup

zjit/src/stats.rs

@@ -165,13 +165,15 @@ make_counters! {
     dynamic_send {
         // send_fallback_: Fallback reasons for send-ish instructions
         send_fallback_send_without_block_polymorphic,
+        send_fallback_send_without_block_megamorphic,
         send_fallback_send_without_block_no_profiles,
         send_fallback_send_without_block_cfunc_not_variadic,
         send_fallback_send_without_block_cfunc_array_variadic,
         send_fallback_send_without_block_not_optimized_method_type,
         send_fallback_send_without_block_not_optimized_optimized_method_type,
         send_fallback_send_without_block_direct_too_many_args,
         send_fallback_send_polymorphic,
+        send_fallback_send_megamorphic,
         send_fallback_send_no_profiles,
         send_fallback_send_not_optimized_method_type,
         send_fallback_ccall_with_frame_too_many_args,
@@ -422,6 +424,7 @@ pub fn send_fallback_counter(reason: crate::hir::SendFallbackReason) -> Counter
     use crate::stats::Counter::*;
     match reason {
         SendWithoutBlockPolymorphic               => send_fallback_send_without_block_polymorphic,
+        SendWithoutBlockMegamorphic               => send_fallback_send_without_block_megamorphic,
         SendWithoutBlockNoProfiles                => send_fallback_send_without_block_no_profiles,
         SendWithoutBlockCfuncNotVariadic          => send_fallback_send_without_block_cfunc_not_variadic,
         SendWithoutBlockCfuncArrayVariadic        => send_fallback_send_without_block_cfunc_array_variadic,
@@ -430,6 +433,7 @@ pub fn send_fallback_counter(reason: crate::hir::SendFallbackReason) -> Counter
                                                   => send_fallback_send_without_block_not_optimized_optimized_method_type,
         SendWithoutBlockDirectTooManyArgs         => send_fallback_send_without_block_direct_too_many_args,
         SendPolymorphic                           => send_fallback_send_polymorphic,
+        SendMegamorphic                           => send_fallback_send_megamorphic,
         SendNoProfiles                            => send_fallback_send_no_profiles,
         ComplexArgPass                            => send_fallback_one_or_more_complex_arg_pass,
         BmethodNonIseqProc                        => send_fallback_bmethod_non_iseq_proc,