绑定完请刷新页面
取消
刷新

分享好友

×
取消 复制
继承对属性访问速度的影响
2019-12-12 11:17:39

在华蟒用户组中有人发邮件问道:

网上看到文章介绍“Method Resolution Order”,说是Python访问对象成员是,先检查当前类的__dict__,查看成员是否存在,如果当前不存在,则查找父类的__dict__。有点类似javascript的原型链查找。这么一来岂不是,一旦对象继承链比较长,访问基类的成员性能会很差?

测试属性访问速度

那么先来测试一下速度吧。

classBase(object):defget_x(self):return10defget_y(self):return100deftest(self):return0# 一个很大的属性字典fromstringimportascii_lowercaseimportitertoolsd={}forcinitertools.product(ascii_lowercase,ascii_lowercase):d["".join(c)]=c# 继承1000次,所有创建的子类都复制一份属性字典classes=[Base]foriinxrange(1000):classes.append(type("C%d"%i,(classes[-1],),d.copy()))c0=Basec1=classes[-1]

上面的程序先创建一个基类Base,然后通过循环调用type()创建1000层子类。下面我们查看c1.mro()的长度,c1的确是第1001层子类。

len(c1.mro())

1002

下面我们测试通过基类c0和底层子类c1访问get_x的速度:

%timeitc0.get_x%timeitc1.get_x

10000000 loops, best of 3: 171 ns per loop

10000000 loops, best of 3: 175 ns per loop

令人感到吃惊的是,通过子类几乎看不到任何速度损失,Python一定做了什么优化。于是我又做了下面的测试:

%timeitc0.get_x,c0.get_y%timeitc1.get_x,c1.get_y

1000000 loops, best of 3: 715 ns per loop

1000 loops, best of 3: 283 us per loop

如果交替访问get_x和get_y,子类的访问速度一下子就降下来了。是不是Python会保存近访问的那次属性呢?于是又做了如下测试:

%timeitc0.get_x,c0.test%timeitc1.get_x,c1.test

1000000 loops, best of 3: 388 ns per loop

1000000 loops, best of 3: 406 ns per loop

我又随便测试了其它一些属性组合,只有get_x和get_y一起访问时,会降低访问速度,那么get_x和get_y有什么特殊的地方呢?

hash("get_x"),hash("get_y")

(1461240580, 1461240581)

我们看到二者的hash值只相差1,这也许就是它们一起访问速度慢的原因吧。至于具体原因何在,只有查看Python的源代码了。

源码分析

关于从object继承的新类的代码,可以在typeobject.c中找到。在该文件的开头就可以看到有关属性缓存的说明和代码:

/* Support type attribute cache *//* The cache can keep references to the names alive for longer than they normally would. This is why the maximum size is limited to MCACHE_MAX_ATTR_SIZE, since it might be a problem if very large strings are used as attribute names. */#defineMCACHE_MAX_ATTR_SIZE100#defineMCACHE_SIZE_EXP10#defineMCACHE_HASH(version,name_hash)\(((unsignedint)(version)*(unsignedint)(name_hash))\>>(8*sizeof(unsignedint)-MCACHE_SIZE_EXP))#defineMCACHE_HASH_METHOD(type,name)\MCACHE_HASH((type)->tp_version_tag,\((PyStringObject*)(name))->ob_shash)#defineMCACHE_CACHEABLE_NAME(name)\PyString_CheckExact(name)&&\PyString_GET_SIZE(name)<=MCACHE_MAX_ATTR_SIZEstructmethod_cache_entry{unsignedintversion;PyObject*name;/* reference to exactly a str or None */PyObject*value;/* borrowed */};staticstructmethod_cache_entrymethod_cache[1<<MCACHE_SIZE_EXP];staticunsignedintnext_version_tag=0;

由上面的代码不难看出,Python使用全局数组method_cache对 1<<10=1024 条属性进行缓存。而在接下来的_PyType_Lookup()中我们可以看到如何使用改数组进行缓存查询:

PyObject*_PyType_Lookup(PyTypeObject*type,PyObject*name){Py_ssize_ti,n;PyObject*mro,*res,*base,*dict;unsignedinth;if(MCACHE_CACHEABLE_NAME(name)&&PyType_HasFeature(type,Py_TPFLAGS_VALID_VERSION_TAG)){/*fastpath*/h=MCACHE_HASH_METHOD(type,name);if(method_cache[h].version==type->tp_version_tag&&method_cache[h].name==name)returnmethod_cache[h].value;}

它通过MCACHE_HASH_METHOD从类和属性名计算出一个下标h,然后检测method_cache[h]中缓存的内容是否和要查询类和属性名的一致,如果一致的话就直接返回属性值,而无须通过继承树往上层搜索属性。下面让我们再一次查看MCACHE_HASH_METHOD的代码:

#define MCACHE_HASH(version, name_hash) \(((unsignedint)(version)*(unsignedint)(name_hash))\>>(8*sizeof(unsignedint)-MCACHE_SIZE_EXP))#define MCACHE_HASH_METHOD(type, name) \MCACHE_HASH((type)->tp_version_tag,\((PyStringObject*)(name))->ob_shash)

它计算下标的方式就是取类的版本标签tp_version_tag与属性名的hash值的乘积的高10位bit。当类相同,hash值只相差1时,通过MCACHE_HASH计算出来的下标相同,于是前面的测试中,c1.get_x和c1.get_y被缓存到同一位置,交替访问它们只能每次都通过继承树搜索属性,从而降低了属性的访问速度。

为什么取高位

对于get_x和get_y来说,如果取低位作为下标就不会出现下标冲突问题了。那么Python是基于何种考虑取高位作为下标呢?在讨论组中Xidorn Quan给出了如下线索:

现在 Python 代码中使用的是这一个版本的 PyPy 的 hash 函数:Commit 6303969。这个提交将类似于我改的那个版本的 hash 函数替换为了现在我们看到的那个 hash 函数:

-MASK=(1<<space.config.objspace.std.methodcachesizeexp)-1-#method_hash=(id(version_tag)^position_hash^hash(name))&MASK-method_hash=((id(version_tag)>>3)^hash(name))&MASK+SHIFT=r_uint.BITS-space.config.objspace.std.methodcachesizeexp+method_hash=r_uint(intmask(id(version_tag)*hash(name)))>>SHIFT

理由是:Improve the hash function used by the method cache.Seems to give good speed-ups on some of our benchmarks.

当然我们无从得知这个 benchmark 到底是什么,不过它是这么说的……,PyPy 里面现在版本的 hash 算法也已经和这个不一样了,或许可以考虑测试一下。

结束语

Python的确需要通过继承树搜索属性,但是它会缓存近的1024个搜索结果,如果没有下标冲突问题,这样做能极大提高循环中对某几个属性的访问。但是如果存在下标冲突,则访问速度又降回到无缓存的情况,会有一定的速度损失。如果你真的很在乎属性访问速度,那么可以在进行大量循环之前,将所有要访问的属性用局域变量进行缓存,这应该是快捷的方案了。

分享好友

分享这个小栈给你的朋友们,一起进步吧。

星说
创建时间:2019-11-28 12:45:43
作为炎黄子孙,我们有很多知识渊博的祖人,这个祖人指的是在各领域登峰造极的学者论说,我们跟随强大基因的路线,学习,深化自己的知识体系,优化环境。
展开
订阅须知

• 所有用户可根据关注领域订阅专区或所有专区

• 付费订阅:虚拟交易,一经交易不退款;若特殊情况,可3日内客服咨询

• 专区发布评论属默认订阅所评论专区(除付费小栈外)

栈主、嘉宾

查看更多
  • unnamed persona
    栈主

小栈成员

查看更多
  • 外星人6
  • supergirlxu
  • unnamed person1
  • daxuesheng
戳我,来吐槽~