Add a specialized instruction for .nil? calls

tenderlove · tenderlove · commit 82c0cb96297c · 2019-06-04T16:35:14.000-07:00
This commit adds a specialized instruction for called to `.nil?`.  It is
about 27% faster than master.  Here is a benchmark:

```
[aaron@TC ~/g/ruby (specialized-nilp)]$ cat compil.rb
require "benchmark/ips"

not_nil = Object.new
xnil = nil

Benchmark.ips do |x|
  x.report("nil?") { xnil.nil? }
  x.report("not nil") { not_nil.nil? }
end
```

On Ruby master:

```
[aaron@TC ~/g/ruby (master)]$ ./ruby compil.rb
Warming up --------------------------------------
                nil?   450.695k i/100ms
             not nil   443.863k i/100ms
Calculating -------------------------------------
                nil?     20.829M (&plusmn; 7.6%) i/s -    103.660M in   5.015627s
             not nil     20.700M (&plusmn; 7.9%) i/s -    102.976M in   5.015786s
[aaron@TC ~/g/ruby (master)]$ ./ruby compil.rb
Warming up --------------------------------------
                nil?   412.899k i/100ms
             not nil   420.359k i/100ms
Calculating -------------------------------------
                nil?     17.882M (&plusmn;15.1%) i/s -     87.122M in   5.010014s
             not nil     18.445M (&plusmn; 7.6%) i/s -     91.638M in   5.006561s
[aaron@TC ~/g/ruby (master)]$ ./ruby compil.rb
Warming up --------------------------------------
                nil?   423.562k i/100ms
             not nil   446.841k i/100ms
Calculating -------------------------------------
                nil?     20.547M (&plusmn; 7.8%) i/s -    102.078M in   5.009083s
             not nil     20.050M (&plusmn;12.8%) i/s -     98.305M in   5.007470s
```

On this branch:

```
[aaron@TC ~/g/ruby (specialized-nilp)]$ ./ruby compil.rb
Warming up --------------------------------------
                nil?   475.495k i/100ms
             not nil   406.826k i/100ms
Calculating -------------------------------------
                nil?     27.379M (&plusmn;12.1%) i/s -    134.565M in   5.009041s
             not nil     26.911M (&plusmn; 8.0%) i/s -    133.439M in   5.001739s
[aaron@TC ~/g/ruby (specialized-nilp)]$ ./ruby compil.rb
Warming up --------------------------------------
                nil?   448.738k i/100ms
             not nil   443.743k i/100ms
Calculating -------------------------------------
                nil?     27.265M (&plusmn;12.4%) i/s -    133.724M in   5.004383s
             not nil     27.125M (&plusmn; 5.8%) i/s -    135.342M in   5.012178s
[aaron@TC ~/g/ruby (specialized-nilp)]$ ./ruby compil.rb
Warming up --------------------------------------
                nil?   461.641k i/100ms
             not nil   465.173k i/100ms
Calculating -------------------------------------
                nil?     27.170M (&plusmn;12.3%) i/s -    133.414M in   5.008517s
             not nil     26.930M (&plusmn; 8.6%) i/s -    133.505M in   5.006783s
```
diff --git a/compile.c b/compile.c
@@ -3251,6 +3251,7 @@ iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
 		  case idLength: SP_INSN(length); return COMPILE_OK;
 		  case idSize:	 SP_INSN(size);	  return COMPILE_OK;
 		  case idEmptyP: SP_INSN(empty_p);return COMPILE_OK;
+		  case idNilP:   SP_INSN(nil_p);return COMPILE_OK;
 		  case idSucc:	 SP_INSN(succ);	  return COMPILE_OK;
 		  case idNot:	 SP_INSN(not);	  return COMPILE_OK;
 		}
diff --git a/defs/id.def b/defs/id.def
@@ -3,6 +3,7 @@ firstline, predefined = __LINE__+1, %[\
   max
   min
   freeze
+  nil?
   inspect
   intern
   object_id
diff --git a/insns.def b/insns.def
@@ -808,6 +808,20 @@ opt_str_freeze
     }
 }
 
+/* optimized empty? */
+DEFINE_INSN
+opt_nil_p
+(CALL_INFO ci, CALL_CACHE cc)
+(VALUE recv)
+(VALUE val)
+{
+    val = vm_opt_nil_p(ci, cc, recv);
+
+    if (val == Qundef) {
+        CALL_SIMPLE_METHOD();
+    }
+}
+
 DEFINE_INSN
 opt_str_uminus
 (VALUE str, CALL_INFO ci, CALL_CACHE cc)
diff --git a/object.c b/object.c
@@ -1664,7 +1664,7 @@ rb_true(VALUE obj)
  */
 
 
-static VALUE
+VALUE
 rb_false(VALUE obj)
 {
     return Qfalse;
diff --git a/vm.c b/vm.c
@@ -1657,6 +1657,7 @@ vm_init_redefined_flag(void)
     OP(Call, CALL), (C(Proc));
     OP(And, AND), (C(Integer));
     OP(Or, OR), (C(Integer));
+    OP(NilP, NIL_P), (C(NilClass));
 #undef C
 #undef OP
 }
diff --git a/vm_core.h b/vm_core.h
@@ -547,6 +547,7 @@ enum ruby_basic_operators {
     BOP_LENGTH,
     BOP_SIZE,
     BOP_EMPTY_P,
+    BOP_NIL_P,
     BOP_SUCC,
     BOP_GT,
     BOP_GE,
diff --git a/vm_insnhelper.c b/vm_insnhelper.c
@@ -4239,6 +4239,26 @@ vm_opt_empty_p(VALUE recv)
     }
 }
 
+VALUE rb_false(VALUE obj);
+
+static VALUE
+vm_opt_nil_p(CALL_INFO ci, CALL_CACHE cc, VALUE recv)
+{
+    if (recv == Qnil) {
+        if (BASIC_OP_UNREDEFINED_P(BOP_NIL_P, NIL_REDEFINED_OP_FLAG)) {
+            return Qtrue;
+        } else {
+            return Qundef;
+        }
+    } else {
+        if (vm_method_cfunc_is(ci, cc, recv, rb_false)) {
+            return Qfalse;
+        } else {
+            return Qundef;
+        }
+    }
+}
+
 static VALUE
 fix_succ(VALUE x)
 {

Original file line number	Diff line number	Diff line change
`@@ -3251,6 +3251,7 @@ iseq_specialized_instruction(rb_iseq_t iseq, INSN iobj)`
`3251`	`3251`	`case idLength: SP_INSN(length); return COMPILE_OK;`
`3252`	`3252`	`case idSize: SP_INSN(size); return COMPILE_OK;`
`3253`	`3253`	`case idEmptyP: SP_INSN(empty_p);return COMPILE_OK;`
	`3254`	`+ case idNilP: SP_INSN(nil_p);return COMPILE_OK;`
`3254`	`3255`	`case idSucc: SP_INSN(succ); return COMPILE_OK;`
`3255`	`3256`	`case idNot: SP_INSN(not); return COMPILE_OK;`
`3256`	`3257`	`}`
-Original file line number
+Diff line change
   max
   min
   freeze
 +  nil?
   inspect
   intern
   object_id
Original file line number	Diff line number	Diff line change
`@@ -1664,7 +1664,7 @@ rb_true(VALUE obj)`
`1664`	`1664`	`*/`
`1665`	`1665`
`1666`	`1666`
`1667`		`-static VALUE`
	`1667`	`+VALUE`
`1668`	`1668`	`rb_false(VALUE obj)`
`1669`	`1669`	`{`
`1670`	`1670`	`return Qfalse;`
Original file line number	Diff line number	Diff line change
`@@ -1657,6 +1657,7 @@ vm_init_redefined_flag(void)`
`1657`	`1657`	`OP(Call, CALL), (C(Proc));`
`1658`	`1658`	`OP(And, AND), (C(Integer));`
`1659`	`1659`	`OP(Or, OR), (C(Integer));`
	`1660`	`+ OP(NilP, NIL_P), (C(NilClass));`
`1660`	`1661`	`#undef C`
`1661`	`1662`	`#undef OP`
`1662`	`1663`	`}`