lua中访问userdata中对象和访问table中对象的效率比较

NoiseFloor

做cocos2d-x开发的人可能有不少人在实现类时会利用cocos2d-x自己给出的类的实现，也即在luaBinding目录下extern.lua的文件中给出的实现：

1. --Create an class.
2. function class(classname, super)
3.     local superType = type(super)
4.     local cls
6.     if superType ~= "function" and superType ~= "table" then
7.         superType = nil
8.         super = nil
9.     end
11.     if superType == "function" or (super and super.__ctype == 1) then
12.         -- inherited from native C++ Object
13.         cls = {}
15.         if superType == "table" then
16.             -- copy fields from super
17.             for k,v in pairs(super) do cls[k] = v end
18.             cls.__create = super.__create
19.             cls.super    = super
20.         else
21.             cls.__create = super
22.         end
24.         cls.ctor    = function() end
25.         cls.__cname = classname
26.         cls.__ctype = 1
28.         function cls.new(...)
29.             local instance = cls.__create(...)
30.             -- copy fields from class to native object
31.             for k,v in pairs(cls) do instance[k] = v end
32.             instance.class = cls
33.             instance:ctor(...)
34.             return instance
35.         end
37.     else
38.         -- inherited from Lua Object
39.         if super then
40.             cls = clone(super)
41.             cls.super = super
42.         else
43.             cls = {ctor = function() end}
44.         end
46.         cls.__cname = classname
47.         cls.__ctype = 2 -- lua
48.         cls.__index = cls
50.         function cls.new(...)
51.             local instance = setmetatable({}, cls)
52.             instance.class = cls
53.             instance:ctor(...)
54.             return instance
55.         end
56.     end
58.     return cls
59. end

复制代码

这里是支持lua中类继承自cocos2d-x的类的，这样的继承机制下，实例化出来的对象，其类型是一个userdata，那么类中的所有对象（属性或方法）其实都是被拷贝在了obj这个userdata内，之后的访问也都是在userdata中找。  上面这样说是因为这里的做法：

1.         function cls.new(...)
2.             --instance是一个userdata
3.             local instance = cls.__create(...)
4.             -- copy fields from class to native object
5.             for k,v in pairs(cls) do instance[k] = v end
6.             instance.class = cls
7.             instance:ctor(...)
8.             return instance
9.         end

复制代码

那么这样作的话我们就得考虑一个问题，lua（或tolua++）的实现里，对userdata中的对象访问的速度够快吗？我们来做一个测试： ----------------------
测试代码1（o为table，val为table中变量）：

1.         local o = {}
2.         o.val = 1
4.         local t1 = os.clock()
5.         for i = 1, 10000000, 1 do
6.                 o.val = o.val + 1
7.         end
8.         local t2 = os.clock()
10.         print(t2 - t1)

复制代码

多次运行，打印纸稳定在0.01数量级。

----------------------
测试代码2（o为userdata，val为userdata中变量）：

1.         local o = cc.Node:create()
2.         o.val = 1
4.         local t1 = os.clock()
5.         for i = 1, 10000000, 1 do
6.                 o.val = o.val + 1
7.         end
8.         local t2 = os.clock()
10.         print(t2 - t1)

复制代码

多次运行，打印纸稳定在4.0数量级。  

******************
测试发现，前者的效率为后者的近400倍，也即在table中访问对象比在userdata中访问，速度有近400倍的提升。

因此，使用cocos2d-x给出的类的实现，虽然能做到支持继承cocos2d-x中的c++对象，但该机制的性能是值得注意的。
原因分析（这里只是猜测，因为暂未看lua及tolua++的实现）：

1.tolua++在访问userdata中属性或方法时，会不会是遍历了一边userdata中所有东西然后一个一个比较，得出最后访问的数据的如果是这样，就可以勉强解释这个现象，因为table中访问某对象，是通过对key值的做哈希来访问的，其速度自然比遍历要快多了。
2.在userdata上增加变量，是由lua层通知c层最终在c层增加的，然后每次访问都要经历一个lua层到c层的过程现在是直接在lua层增加，所以访问时不再需要lua层到c层的交互。