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是一行方法的调用,譬如:
a = sqr(b);
c = sqr(b);
是两个Call Site。
Call Site优化
在Groovy 1.6之前,对于同一个Call Site来说,调用该方法n次,则会进行n次的方法选择,譬如:
for (i in 1..3) {
a.call(i)
}
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的源代码。
以上分析有不当之处敬请指出,谢谢大家的阅读。