Unity中SLua、Tolua、XLua和ILRuntime效率评测

Unity脚本效率评测

对SLua、Tolua、XLua和ILRuntime四个脚本插件进行效率测试，对框架脚本进行选型。

本文项目:https://github.com/cateatcatx/UnityScriptPTest

tolua:https://github.com/topameng/tolua

slua:https://github.com/pangweiwei/slua

xlua:https://github.com/Tencent/xLua

ILRuntime:https://github.com/Ourpalm/ILRuntime

用例版本

Unity5.6.0p3

SLua 1.3.2

Tolua# github 2017/4/25 19:08:37

XLua 2.1.7

ILRuntime 1.11

Lua: luajit-2.1.0-beta2

测试环境

Smartian T2、Win7(64bit)

实验方案

总共设计了17个Test，分别从以下3个方面来考察脚本效率（JIT和非JIT），实验结果取10次的平均值，时间单位为ms。通过实验数据简单分析原因（Lua插件会横向对比，ILRuntime会单独考虑，因为毕竟C#和Lua本身差别较大）。

1. Mono -> Script，Mono调用脚本


2. Script -> Mono，脚本调用Mono


3. Script自身，脚本自身执行效率

Mono -> Script

Test11 Test12 Test13 Test14 Test15 Test16 Sum

Tolua 186 449 598 407 577 759 2978

SLua 315 751 901 757 1253 1883 5863

XLua 145 924 1010 573 1507 1929 6091

ILRuntime 711 422 368 379 397 393 2672

Tolua(JIT) 168 454 592 416 578 826 3037

SLua(JIT) 384 842 956 824 1328 3439 7775

XLua(JIT) 189 957 1047 608 1540 1700 6043

ILRuntime(JIT) 1232 892 903 969 1175 1102 6275

Lua分析：

– Test11

function EmptyFunc()

_V0 = _V0 + 1

end

_V0 = 1 – Test12

_V1 = “12345” – Test13

_V2 = GameObject.New() – Test14

_V3 = Vector3.New(1, 2, 3) – Test15

_V4 = {1, 2, 3} – Test16

Test11为Mono调用脚本中空方法，Test12~16为测试Mono到脚本中取变量（ILRuntime代码类似，访问类的static函数与变量）。ILRuntime因为没有变量类型的转换所以效率最为优秀（JIT模式下使用的是Mono的反射取值所以会更慢，ILRuntime内部可能对类型变量有缓存，所以比反射快很多），Lua中可以看到Tolua的综合性能尤为突出（所有测试均好于其他Lua）。

对比Tolua和SLua的实现发现，Tolua会尽量减少与C++通信的次数，因为c#与c++通信会有一定效率损耗（参数的Marshaling等），虽然是Mono与Lua通信，但是其中还夹着一层C++，所以Mono与Lua通信的主要优化思路就是减少与C++的通信，从实验数据来看Tolua的这种优化效果是很明显的。

// SLua的函数调用

public bool pcall(int nArgs, int errfunc)

{

if (!state.isMainThread())


{


    Logger.LogError("Can't call lua function in bg thread");


    return false;


}





LuaDLL.lua_getref(L, valueref);





if (!LuaDLL.lua_isfunction(L, -1))


{


    LuaDLL.lua_pop(L, 1);


    throw new Exception("Call invalid function.");


}





LuaDLL.lua_insert(L, -nArgs - 1);


if (LuaDLL.lua_pcall(L, nArgs, -1, errfunc) != 0)


{


    LuaDLL.lua_pop(L, 1);


    return false;


}


return true;

}

// Tolua的函数调用

public void Call()

{

 BeginPCall();


 PCall();


 EndPCall();

}

public int BeginPCall(int reference)

{

return LuaDLL.tolua_beginpcall(L, reference);

}

public int LuaPCall(int nArgs, int nResults, int errfunc)

{

return LuaDLL.lua_pcall(L, nArgs, nResults, errfunc);

}

public void LuaSetTop(int newTop)

{

LuaDLL.lua_settop(L, newTop);

}

对比SLua和Tolua代码的函数调用部分，发现SLua的C++调用多余Tolua两倍左右，所以效率高下立见。变量读取读者可以自行对比，总结就是Tolua通过减少C++调用的方式来优化效率，后期对Lua的进一步优化也要遵循这个思路。

ILRuntime分析：

实验发现解释执行下，ILRuntime的获取变量的效率要明显好于Lua，主要是因为都是C#对象，不需要进行类型转换。ILRuntime的JIT模式其实是用的Mono的，效率反而比解释执行更低，猜测是因为JIT下主要采用反射调用函数和取变量，而ILRuntime的解释器可能内部有缓存（因为没看过实现，都是不负责任猜测）。

Script->Mono

Test0 Test1 Test2 Test3 Test4 Test5 Test6 Test7 Test10 Sum

Tolua 675 797 1410 354 839 343 407 1681 915 7426

SLua 768 640 2305 466 1110 408 394 3379 1299 10774

XLua 590 648 8504 450 775 1213 695 1267 845 14989

ILRuntime 1152 1054 4012 315 998 437 1026 3272 1434 13703

Tolua(JIT) 612 701 7.4 357 823 318 37 128 884 3871

SLua(JIT) 732 679 5.4 465 1197 411 10 165 1307 4974

XLua(JIT) 636 668 8312 438 767 1303 734 1340 911 15113

ILRuntime(JIT) 72 197 84 260 402 33 219 303 77 1651

Lua分析：

function Test0(transform)

local t = os.clock()





for i = 1,200000 do


    transform.position = transform.position


end





return os.clock() - t

end

function Test1(transform)

local t = os.clock()


for i = 1,200000 do


    transform:Rotate(up, 1) 


end





return os.clock() - t

end

function Test2()

local t = os.clock()





for i = 1, 2000000 do


    local v = Vector3.New(i, i, i)


    local x,y,z = v.x, v.y, v.z


end





return os.clock() - t

end

function Test3()

local t = os.clock()    





for i = 1,20000 do              


    GameObject.New()


end





return os.clock() - t

end

function Test4()

local t = os.clock()


local tp = typeof(SkinnedMeshRenderer)





for i = 1,20000 do              


    local go = GameObject.New()


    go:AddComponent(tp)


    local c = go:GetComponent(tp)


    c.receiveShadows=false


end





return os.clock() - t

end

function Test5()

local t = os.clock()





for i = 1,200000 do     


    local p = Input.mousePosition


    --Physics.RayCast


end





return os.clock() - t

end

function Test6()

local Vector3 = Vector3 


local t = os.clock()





for i = 1, 200000 do


    local v = Vector3.New(i,i,i)


    Vector3.Normalize(v)


end





return os.clock() - t

end

function Test7()

local Quaternion = Quaternion


local t = os.clock()





for i=1,200000 do


    local q1 = Quaternion.Euler(i, i, i)        


    local q2 = Quaternion.Euler(i * 2, i * 2, i * 2)


    Quaternion.Slerp(Quaternion.identity, q1, 0.5)      


end





return os.clock() - t

end

function Test10(trans)

local t = os.clock()





for i = 1, 200000 do


    UserClass.TestFunc1(1, "123", trans.position, trans)


end 





return os.clock() - t

end

总体效率还是Tolua胜出，其中XLua在Test2中较比SLua、Tolua差出不止一个数量级，主要是因为Tolua和SLua对于Unity的值类型变量做了lua的实现，这种值类型SLua和Tolua中是一个table，而在XLua中是一个Userdata，所以SLua和Tolua在做Test2的时候并没有跟Unity交互（从JIT结果也能看出来，JIT不能处理C函数，所以JIT后Test2效果提升明显），而XLua需要频繁和Unity交互，效率消耗明显。对于对象类型的变量，3种lua处理机制是雷同的，只是内部实现细节不一样而已，细节不再本文讨论范围内，从实验数据上来看，还是Tolua的内部实现更加效率。用好lua+unity，让性能飞起来——lua与c#交互篇，这篇文章对C#与Lua的交互原来有非常详细的说明，虽然插件后续有改进，但是核心思想还是不变的。

ILRuntime分析：

数据上来看ILRuntime解释器的效率还是很高的并不比lua慢太多，但是对于Vector3这种Unity值类型的处理跟lua差距比较大（主要是因为SLua和Tolua中的Unity值类型其实就是table，等于没有跟Unity交互）。ILRuntime还是一个很有潜力的Unity热更解决方案的，毕竟C#配合VS的开发效率还是比Lua高不少的。其中的JIT部分是Mono层的，跟本身的C#代码是没有区别的，不参与对比。

Script自身

Test8 Test9 Sum

Tolua 254 4246 4500

SLua 255 4766 5022

XLua 311 4506 4817

ILRuntime 852 79048 79900

Tolua(JIT) 46 371 417

SLua(JIT) 48 414 463

XLua(JIT) 40 469 510

ILRuntime(JIT) 222 313 536

function Test8()

local total = 0


local t = os.clock()





for i = 0, 1000000, 1 do


    total = total + i - (i/2) * (i + 3) / (i + 5)


end





return os.clock() - t

end

function Test9()

local array = {}





for i = 1, 1024 do


    array[i] = i


end





local total = 0


local t = os.clock()





for j = 1, 100000 do


    for i = 1, 1024 do


        total = total + array[i]


    end         


end





return os.clock() - t

end

因为Lua全部使用的是LuaJIT2.1.0B2版本，所以其实脚本自身的效率理论上应该是一致的，从数据上看也差不多。实验结果上主要体现了Lua解释器的速度要明显好于ILRuntime（语言内部实现不一样，勉强对比在一块，毕竟lua是c写的），并且发现LuaJIT对效率的提升也是好几个数量级，虽然LuaJIT很多坑，但是如果能用好还是个优化利器。

总结

综合来看Tolua是现在效率较好的Unity Lua解决方案，后续会对Tolua的内部实现做进一步剖析，从来做进一步的效率优化。

————————————————

原文链接：https://blog.csdn.net/u011467512/article/details/72716376/

内容目录