随笔 - 4, 文章 - 0, 评论 - 2, 引用 - 0
数据加载中……

Groovy深入探索——Call Site分析

Groovy 1.6引入了Call Site优化。Call Site优化实际上就是方法选择的cache。

方法选择
在静态语言(如Java)中,方法调用的绑定是在编译期完成的(不完全是这样,如虚函数,但总的来说,静态语言的方法调用是非常高效的)。而在动态语言(如Groovy)中,调用的方法是在运行时选择的。这也是造成动态语言比静态语言慢的重要原因之一。
举个例子来说明,譬如要调用“a.call(1)”。
如果是Java的话,在编译期就会选择好调用的方法,在这个例子中,就是选择a对象声明的类(注意,不是a对象真正的类,因为真正的类要到运行时 才能知道)中,名字为call、有一个参数、参数类型为int的方法(实际情况要复杂很多,譬如还要考虑boxing和变参等情况),如果找不到的话则编 译不通过,否则进行方法绑定。反汇编这个方法调用的话可以看到如“invokevirtual #4; //Method call:(I)V”的指令,表明方法是绑定好的,包括方法名字“call”,参数类型“I”(int),返回值“V”(void)。
如果是Groovy的话,这些都是由Groovy运行时完成的,Groovy对代码进行编译时并不会检查到底有没有一个方法能匹配这个调用。用 Groovy 1.5.7进行编译,再反编译为Java代码之后,可以看到如 “ScriptBytecodeAdapter.invokeMethodN(class1, a, "call", new Object[] { new Integer(1) })”的语句,由此看出Groovy在编译时并没有真正的选择调用的方法,而是交由运行时决定。

Call Site
根据wikipedia的定义(http://en.wikipedia.org/wiki/Call_site),Call Site是一行方法的调用,譬如:
= sqr(b);
= sqr(b);
是两个Call Site。

Call Site优化
在Groovy 1.6之前,对于同一个Call Site来说,调用该方法n次,则会进行n次的方法选择,譬如:
for (i in 1..3) {
    a.call(i)
}
这里,Groovy对call方法就进行了3次的选择,即使3次选择的结果都是一样的。
Groovy 1.6引入的Call Site优化,则是把同一个Call Site的方法选择结果缓存起来,如果下一次调用时的参数类型一样,则调用该缓存起来的方法,否则重新选择。这就是Call Site优化的基本思想。

代码分析
考虑以下的Groovy代码:
class A {
    def a() {}
    def b() {}
    def b(
int i) {}
}

class B {
    def a 
= new A()
    def c() {
        a.a()
        d()
    }
    def d() {
        a.a()
        a.b()
        a.b(
1)
    }
}
我们先用Groovy 1.6对这段代码进行编译,然后再用jad对编译后的class文件进行反编译。因为A类中的方法都是空的,所以我们只看B类的反编译结果。下面是B类中的c()和d()方法:
    public Object c()
    {
        CallSite acallsite[] 
= $getCallSiteArray();
        acallsite[
1].call(a);
        
return acallsite[2].callCurrent(this);
    }

    
public Object d()
    {
        CallSite acallsite[] 
= $getCallSiteArray();
        acallsite[
3].call(a);
        acallsite[
4].call(a);
        
return acallsite[5].call(a, $const$0); // $const$0就是常量1
    }
我们来看看$getCallSiteArray():
    private static CallSiteArray $createCallSiteArray()
    {
        
return new CallSiteArray($ownClass, new String[] {
            
"<$constructor$>""a""d""a""b""b" // 每个Call Site的方法名字
        });
    }

    
private static CallSite[] $getCallSiteArray()
    {
        CallSiteArray callsitearray;
        
if($callSiteArray == null || (callsitearray = (CallSiteArray)$callSiteArray.get()) == null)
        {
            callsitearray 
= $createCallSiteArray();
            $callSiteArray 
= new SoftReference(callsitearray);
        }
        
return callsitearray.array;
    }
$getCallSiteArray()实际上就是对$callSiteArray的lazy创建。
我们可以看到,“acallsite[1].call(a);”就是对方法名为"a"的CallSite进行调用,而“acallsite[2].callCurrent(this);”则是对方法名为“d”的CallSite进行调用,如此类推。
我们再来看看CallSiteArray的构造函数里做些什么:
    public CallSiteArray(Class owner, String [] names) {
        
this.owner = owner;
        array 
= new CallSite[names.length];
        
for (int i = 0; i < array.length; i++) {
            array[i] 
= new AbstractCallSite(this, i, names[i]);
        }
    }
所以,第一次调用“acallsite[1].call(a);“时,就是调用AbstractCallSite类的call方法。下面是该方法的代码:
    public Object call(Object receiver, Object[] args) throws Throwable {
        
return CallSiteArray.defaultCall(this, receiver, args);
    }
再看看CallSiteArray.defaultCall()的代码:
    public static Object defaultCall(CallSite callSite, Object receiver, Object[] args) throws Throwable {
        
return createCallSite(callSite, receiver, args).call(receiver, args);
    }
    
    
private static CallSite createCallSite(CallSite callSite, Object receiver, Object[] args) {
        CallSite site;
        
if (receiver == null)
          
return new NullCallSite(callSite);

        
if (receiver instanceof Class)
          site 
= createCallStaticSite(callSite, (Class) receiver, args);
        
else if (receiver instanceof GroovyObject) {
            site 
= createPogoSite(callSite, receiver, args); // 我们只考虑这种情况
        } else {
            site 
= createPojoSite(callSite, receiver, args);
        }

        replaceCallSite(callSite, site); 
// 替换CallSite
        return site;
    }

    
private static void replaceCallSite(CallSite oldSite, CallSite newSite) {
        oldSite.getArray().array [oldSite.getIndex()] 
= newSite;
    }
可以看到createCallSite()最后通过调用replaceCallSite()把旧的CallSite替换为新的CallSite,因此第二次 调用“acallsite[1].call(a);”时就是直接调用新的CallSite,也就是说该CallSite被缓存起来了。
我们在这里只考虑POGO的情况,即createPogoSite()方法。而POJO的情况稍微复杂一点,因为涉及到POJO per-instance metaclass的情况(我将在下一篇文章中分析它的实现)。下面是createPogoSite()的代码:
    private static CallSite createPogoSite(CallSite callSite, Object receiver, Object[] args) {
        
if (receiver instanceof GroovyInterceptable)
          
return new PogoInterceptableSite(callSite);

        MetaClass metaClass 
= ((GroovyObject)receiver).getMetaClass();
        
if (metaClass instanceof MetaClassImpl) {
            
return ((MetaClassImpl)metaClass).createPogoCallSite(callSite, args); // 我们只考虑这种情况
        }

        
return new PogoMetaClassSite(callSite, metaClass);
    }
我们只考虑对象的metaclass是MetaClassImpl的情况(这也是Groovy对象的默认情况)。下面是MetaClassImpl.createPogoCallSite()的代码:
    public CallSite createPogoCallSite(CallSite site, Object[] args) {
        
if (site.getUsage().get() == 0 && !(this instanceof AdaptingMetaClass)) {
            Class [] params 
= MetaClassHelper.convertToTypeArray(args); // 获取参数的类型
            MetaMethod metaMethod = getMethodWithCachingInternal(theClass, site, params); // 选择方法
            if (metaMethod != null)
               
return PogoMetaMethodSite.createPogoMetaMethodSite(site, this, metaMethod, params, args); // 如果找到匹配的方法,则创建一个PogoMetaMethodSite,并把找到的方法绑定其中
        }
        
return new PogoMetaClassSite(site, this); //否则创建一个PogoMetaClassSite
    }
PogoMetaMethodSite.createPogoMetaMethodSite()就是用来根据不同的情况创建PogoMetaMethodSite或它的子类的一个实例。我们最后来看看PogoMetaMethodSite.call()方法:
    public Object call(Object receiver, Object[] args) throws Throwable {
        
if(checkCall(receiver, args)) { // 如果参数类型相同,则调用绑定的方法
            try {
                
return invoke(receiver,args); // 调用绑定的方法
            } catch (GroovyRuntimeException gre) {
                
throw ScriptBytecodeAdapter.unwrap(gre);
            }
        } 
else { // 否则创建新的CallSite,即再次进行方法查找
            return CallSiteArray.defaultCall(this, receiver, args);
        }
    }

    
protected boolean checkCall(Object receiver, Object[] args) {
        
try {
            
return usage.get() == 0
               
&& ((GroovyObject)receiver).getMetaClass() == metaClass // metaClass still be valid
               && MetaClassHelper.sameClasses(params, args); // 检查参数类型是否一样
        }
        
catch (NullPointerException e) {
            
if (receiver == null)
              
return false;
            
throw e;
        }
        
catch (ClassCastException e) {
            
if (!(receiver instanceof GroovyObject))
              
return false;
            
throw e;
        }
    }

最后,我们来再次总结这个过程:
第一次调用“acallsite[1].call(a)“时,通过CallSiteArray.createCallSite()方法创建了 PogoMetaMethodSite类的一个新CallSite,并把默认的AbstractCallSite覆盖掉。在创建 PogoMetaMethodSite的过程中,将进行方法的选择,并把找到的方法绑定到PogoMetaMethodSite中。最后就是调用该方法:
当第二次调用“acallsite[1].call(a)“时,就是直接调用PogoMetaMethodSite.call(),这时候 PogoMetaMethodSite.call()就会检查传入的参数类型是否与绑定的方法(即上次找到的方法)的参数类型相同,相同则调用该绑定的方 法,否则将再次调用CallSiteArray.createCallSite()方法,创建一个新的CallSite对象,并重新进行方法选择。

除了普通的方法调用的情况外,还有调用当前对象方法、获取/设置属性、调用构造函数、调用静态函数的情况,在此不再做详细分析,有兴趣的可以直接查阅Groovy的源代码。

以上分析有不当之处敬请指出,谢谢大家的阅读。

posted on 2009-03-16 09:39 Johnny Jian 阅读(2335) 评论(1)  编辑  收藏 所属分类: Groovy

评论

# re: Groovy深入探索——Call Site分析  回复  更多评论   

写得很好 :)
2009-03-16 20:22 | 山风小子

只有注册用户登录后才能发表评论。


网站导航: