Re: Non-overridable and non-redefinable methods

Hi,

Florian Growrote:
> I'd propose doing it similar to YARV. Optimize 1 + 2, but only if you 
> clearly see a Fixnum.freeze at the beginning of the file.

YARV doesn't inline Fixnum#+.  If Fixnum#+ is redefined, YARV invoke 
redefined function (same as current Ruby interpreter).   ... In the 
future version.  I have already inserted redefine check code, but not 
write redefine notify code (in rb_define_method()).


pseudo instruction code of current YARV:

instruction opt_plus(recv, obj){
   if(FIXNUM_P(recv) && FIXNUM_P(obj) &&
      !REDEFINED(FIXNUM, +)){
     /* in real code, you must check overflow */
     return INT2FIX(FIX2INT(recv)+FIX2INT(obj));
   }
   else if(...){
     ...
   }
   else{
     return recv.__send__(:+, obj);
   }
}

This optimization makss good performance.

===============================================
Another idea:

fixnum_plus(recv, obj){
   if(FIXNUM_P(recv) && FIXNUM_P(obj)){
     return INT2FIX(FIX2INT(recv) + FIX2INT(obj));
   }
   else{
     vm->plus_func = search_plus_func(recv, obj);
     return vm->plus_func(recv, obj);
   }
}

search_plus_func(recv, obj){
   if(FIXNUM_P(recv) && FIXNUM_P(obj) && !redefine(Fixnum#+)){
     return fixnum_plus;
   }
   else if(CLASS_OF(recv) == String && CLASS_OF(obj) == String
           && !redefine(String#+)){
     return string_plus;
   }
   ...
   return normal_dispatch;
}

vm->plus_func = fixnum_plus;

define_method(klass, id, body){
   ...
   if(klass == Fixnum && id == :+){
     vm->plus_func = normal_dispatch;
   }
   ...
}

instruction opt_plus(recv, obj){
   func = vm->plus_func;
   return func(recv, obj);
}


* good:
   * flexibile replacement of inlining code with context

* bad:
   * C function call overhead
   * design "normal_dispatch" is difficult


===============================================

Re-compile inlining code if someone redefines some special methods, has 
some difficulty.  If re-compiled function was already called, you must 
replace return address of method like "on stack replacement".


===============================================


BTW, I hate redefinable method for VM performance (of course!).  But 
redefine method is power of language (flexibility, refrectionability). 
IMO, if you restrict Ruby's language specification, it will be Ruby--. 
I'm trying to beet this "bad specification for performance" with VM 
implementation technique (not change specification).

(But current ruby interpreter inlinie "/foo/ =~ expr" ...)

Of course, I want to add restriction to Ruby's specification :) 
Especially Evil Eval!


Excume me my poor English.
Regards,
-- 
SASADA Koichi at atdot dot net