ZJIT: Add stats for reasons why cfuncs are not optimized

Author: st0012

zjit.rb

@@ -42,6 +42,7 @@ def stats_string
     # Show non-exit counters
     print_counters_with_prefix(prefix: 'dynamic_send_type_', prompt: 'dynamic send types', buf:, stats:, limit: 20)
     print_counters_with_prefix(prefix: 'unspecialized_def_type_', prompt: 'send fallback unspecialized def_types', buf:, stats:, limit: 20)
+    print_counters_with_prefix(prefix: 'not_optimized_cfunc_', prompt: 'reasons cfuncs are not optimized', buf:, stats:, limit: 20)
     print_counters_with_prefix(prefix: 'send_fallback_', prompt: 'dynamic send types', buf:, stats:, limit: 20)
 
     # Show exit counters, ordered by the typical amount of exits for the prefix at the time

zjit/src/hir.rs

@@ -2122,15 +2122,30 @@ impl Function {
                     //
                     // Bail on argc mismatch
                     if argc != cfunc_argc as u32 {
+                        fun.push_insn(block, Insn::IncrCounter(Counter::not_optimized_cfunc_argc_mismatch));
                         return Err(());
                     }
 
                     // Filter for a leaf and GC free function
                     use crate::cruby_methods::FnProperties;
-                    let Some(FnProperties { leaf: true, no_gc: true, return_type, elidable }) =
-                        ZJITState::get_method_annotations().get_cfunc_properties(method)
-                    else {
-                        return Err(());
+                    let cfunc_properties = ZJITState::get_method_annotations().get_cfunc_properties(method);
+
+                    let (return_type, elidable) = match cfunc_properties {
+                        Some(FnProperties { leaf: true, no_gc: true, return_type, elidable }) => {
+                            (return_type, elidable)
+                        }
+                        Some(FnProperties { leaf: false, no_gc: true, .. }) => {
+                            fun.push_insn(block, Insn::IncrCounter(Counter::not_optimized_cfunc_not_leaf));
+                            return Err(());
+                        }
+                        Some(FnProperties { leaf: true, no_gc: false, .. }) => {
+                            fun.push_insn(block, Insn::IncrCounter(Counter::not_optimized_cfunc_not_no_gc));
+                            return Err(());
+                        }
+                        _ => {
+                            fun.push_insn(block, Insn::IncrCounter(Counter::not_optimized_cfunc_not_leaf_nor_no_gc));
+                            return Err(());
+                        }
                     };
 
                     let ci_flags = unsafe { vm_ci_flag(call_info) };
@@ -2147,7 +2162,10 @@ impl Function {
                         cfunc_args.append(&mut args);
                         let ccall = fun.push_insn(block, Insn::CCall { cfun, args: cfunc_args, name: method_id, return_type, elidable });
                         fun.make_equal_to(send_insn_id, ccall);
-                        return Ok(());
+                        Ok(())
+                    } else {
+                        fun.push_insn(block, Insn::IncrCounter(Counter::not_optimized_cfunc_not_args_simple));
+                        Err(())
                     }
                 }
                 // Variadic method
@@ -2186,17 +2204,20 @@ impl Function {
 
                         fun.make_equal_to(send_insn_id, ccall);
                         return Ok(());
+                    } else {
+                        // Fall through for complex cases (splat, kwargs, etc.)
+                        fun.push_insn(block, Insn::IncrCounter(Counter::not_optimized_cfunc_variadic_not_args_simple));
+                        return Err(());
                     }
-                    // Fall through for complex cases (splat, kwargs, etc.)
                 }
                 -2 => {
                     // (self, args_ruby_array) parameter form
                     // Falling through for now
+                    fun.push_insn(block, Insn::IncrCounter(Counter::not_optimized_cfunc_variadic_ruby_array_arg));
+                    return Err(());
                 }
                 _ => unreachable!("unknown cfunc kind: argc={argc}")
             }
-
-            Err(())
         }
 
         for block in self.rpo() {
@@ -8072,6 +8093,7 @@ mod opt_tests {
         bb0(v0:BasicObject):
           v4:Fixnum[1] = Const Value(1)
           v5:Fixnum[0] = Const Value(0)
+          IncrCounter not_optimized_cfunc_argc_mismatch
           v7:BasicObject = SendWithoutBlock v4, :itself, v5
           CheckInterrupts
           Return v7
@@ -8709,6 +8731,7 @@ mod opt_tests {
         fn test@<compiled>:2:
         bb0(v0:BasicObject):
           v5:HashExact = NewHash
+          IncrCounter not_optimized_cfunc_not_leaf_nor_no_gc
           v7:BasicObject = SendWithoutBlock v5, :dup
           v9:BasicObject = SendWithoutBlock v7, :freeze
           CheckInterrupts
@@ -8726,6 +8749,7 @@ mod opt_tests {
         bb0(v0:BasicObject):
           v5:HashExact = NewHash
           v6:NilClass = Const Value(nil)
+          IncrCounter not_optimized_cfunc_argc_mismatch
           v8:BasicObject = SendWithoutBlock v5, :freeze, v6
           CheckInterrupts
           Return v8
@@ -8772,6 +8796,7 @@ mod opt_tests {
         fn test@<compiled>:2:
         bb0(v0:BasicObject):
           v5:ArrayExact = NewArray
+          IncrCounter not_optimized_cfunc_not_leaf_nor_no_gc
           v7:BasicObject = SendWithoutBlock v5, :dup
           v9:BasicObject = SendWithoutBlock v7, :freeze
           CheckInterrupts
@@ -8789,6 +8814,7 @@ mod opt_tests {
         bb0(v0:BasicObject):
           v5:ArrayExact = NewArray
           v6:NilClass = Const Value(nil)
+          IncrCounter not_optimized_cfunc_argc_mismatch
           v8:BasicObject = SendWithoutBlock v5, :freeze, v6
           CheckInterrupts
           Return v8
@@ -8836,6 +8862,7 @@ mod opt_tests {
         bb0(v0:BasicObject):
           v4:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000))
           v6:StringExact = StringCopy v4
+          IncrCounter not_optimized_cfunc_not_leaf_nor_no_gc
           v8:BasicObject = SendWithoutBlock v6, :dup
           v10:BasicObject = SendWithoutBlock v8, :freeze
           CheckInterrupts
@@ -8854,6 +8881,7 @@ mod opt_tests {
           v4:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000))
           v6:StringExact = StringCopy v4
           v7:NilClass = Const Value(nil)
+          IncrCounter not_optimized_cfunc_argc_mismatch
           v9:BasicObject = SendWithoutBlock v6, :freeze, v7
           CheckInterrupts
           Return v9
@@ -8901,6 +8929,7 @@ mod opt_tests {
         bb0(v0:BasicObject):
           v4:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000))
           v6:StringExact = StringCopy v4
+          IncrCounter not_optimized_cfunc_not_leaf_nor_no_gc
           v8:BasicObject = SendWithoutBlock v6, :dup
           v10:BasicObject = SendWithoutBlock v8, :-@
           CheckInterrupts
@@ -9000,6 +9029,7 @@ mod opt_tests {
         bb0(v0:BasicObject, v1:BasicObject):
           v5:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000))
           v17:BasicObject = GuardTypeNot v1, String
+          IncrCounter not_optimized_cfunc_not_leaf_nor_no_gc
           v18:BasicObject = SendWithoutBlock v1, :to_s
           v9:String = AnyToString v1, str: v18
           v11:StringExact = StringConcat v5, v9

zjit/src/stats.rs

@@ -152,6 +152,15 @@ make_counters! {
     unspecialized_def_type_refined,
     unspecialized_def_type_null,
 
+    // Specific reasons why a C function is not optimized
+    not_optimized_cfunc_argc_mismatch,
+    not_optimized_cfunc_not_no_gc,
+    not_optimized_cfunc_not_leaf,
+    not_optimized_cfunc_not_leaf_nor_no_gc,
+    not_optimized_cfunc_not_args_simple,
+    not_optimized_cfunc_variadic_not_args_simple,
+    not_optimized_cfunc_variadic_ruby_array_arg,
+
     send_fallback_polymorphic,
     send_fallback_no_profiles,