Python 源码剖析(五)【DICT对象】
五、DICT对象
1、散列表概述
2、PyDictObject
3、PyDictObject的创建与维护
4、PyDictObject 对象缓冲池
5、Hack PyDictObject
这篇篇幅较长,难点在字典搜索。
1、散列表概述
python中的dict并没有采用map中的红黑树结构做关联,而是使用效率更高的散列表。
散列表通过一个函数将键值映射为一个整数,再将整数作为索引值访问内存。用于映射的函数称为散列函数,映射后的值为散列值。散列会发生冲突,解决散列冲突的方法有很多,python使用的是开放定址法,当发生冲突再次探测可用位置,形成探测链,探测链如果要删掉中间一个元素,会使用伪删除处理,防止链断开搜索失败。
2、PyDictObject
后面将把关联容器中的一个(key, value)元素对称为一个entry或slot。一个entry定义:
[dictobject.h] typedef struct { long me_hash; /* cached hash code of me_key */ PyObject *me_key; PyObject *me_value; } PyDictEntry;
me_hash域 存储me_key的散列值,entry分为三种状态:Unused态、Active态、Dummy态,切换如下:
PyDictObject实际是一堆entry的集合:
[dictobject.h] #define PyDict_MINSIZE 8 typedef struct _dictobject PyDictObject; struct _dictobject { PyObject_HEAD int ma_fill; /* # Active + # Dummy */ int ma_used; /* # Active */ int ma_mask; PyDictEntry *ma_table; PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash); PyDictEntry ma_smalltable[PyDict_MINSIZE]; };
ma_fill 维护处于Active态和Dummy态的entry数;
ma_used维护处于Active态的entry数;
ma_mask指PyDictObject中所有entry数;
ma_table域 指向PyDictObject中的entry,当其数量小于等于PyDict_MINSIZE(8)时,指向ma_smalltable,否者申请内存指向该内存;
ma_lookup后面说;
3、PyDictObject的创建与维护
3.1.1、PyDictObject对象创建
[dictobject.c]
typedef PyDictEntry dictentry;
typedef PyDictObject dictobject;
#define INIT_NONZERO_DICT_SLOTS(mp) do { \ (mp)->ma_table = (mp)->ma_smalltable; \ (mp)->ma_mask = PyDict_MINSIZE - 1; \ } while(0)
memset((mp)->ma_smalltable, 0, sizeof((mp)->ma_smalltable)); \ (mp)->ma_used = (mp)->ma_fill = 0; \ INIT_NONZERO_DICT_SLOTS(mp); \ } while(0)
PyObject* PyDict_New(void) { register dictobject *mp; if (dummy == NULL) { /* Auto-initialize dummy */ dummy = PyString_FromString("<dummy key>"); if (dummy == NULL) return NULL; } if (num_free_dicts) { …… //使用缓冲池 } else { mp = PyObject_GC_New(dictobject, &PyDict_Type); if (mp == NULL) return NULL; EMPTY_TO_MINSIZE(mp); } mp->ma_lookup = lookdict_string; _PyObject_GC_TRACK(mp); return (PyObject *)mp; }
创建PyDictObject时,会先创建一个字符串对象dummy,用作指示标志,表面entry曾被使用,也用于探测序列;
num_free_dicts是dict的缓冲池,后面讲;
然后开始创建,将ma_smalltable、ma_used、ma_fill清0,然后ma_table指向ma_smalltable,设置ma_mash,最后将lookdict_string 赋予 ma_lookup。
3.1.2、元素搜索
PyDictObject有两种搜索策略,lookdict和lookdict_string,lookdict_string是lookdict对PyStringObject的特化。其中lookdict_string:
[dictobject.c] static dictentry* lookdict_string(dictobject *mp, PyObject *key, register long hash) { register int i; register unsigned int perturb; register dictentry *freeslot; register unsigned int mask = mp->ma_mask; dictentry *ep0 = mp->ma_table; register dictentry *ep; if (!PyString_CheckExact(key)) { mp->ma_lookup = lookdict; return lookdict(mp, key, hash); } //[1] i = hash & mask; ep = &ep0[i]; //[2] //if NULL or interned if (ep->me_key == NULL || ep->me_key == key) return ep; //[3] if (ep->me_key == dummy) freeslot = ep; else { //[4] if (ep->me_hash == hash && _PyString_Eq(ep->me_key, key)) { return ep; } freeslot = NULL; } /* In the loop, me_key == dummy is by far (factor of 100s) the least likely outcome, so test for that last. */ for (perturb = hash; ; perturb >>= PERTURB_SHIFT) { i = (i << 2) + i + perturb + 1; ep = &ep0[i & mask]; if (ep->me_key == NULL) return freeslot == NULL ? ep : freeslot; if (ep->me_key == key || (ep->me_hash == hash && ep->me_key != dummy && _PyString_Eq(ep->me_key, key))) return ep; if (ep->me_key == dummy && freeslot == NULL) freeslot = ep; } }
其中关键步骤标注[1][2][3][4],后面讲。
lookdict_string是在key为PyStringObject的情况下使用,否则使用lookdict:
[dictobject.c] static dictentry* lookdict(dictobject *mp, PyObject *key, register long hash) { register int i; register unsigned int perturb; register dictentry *freeslot; register unsigned int mask = mp->ma_mask; dictentry *ep0 = mp->ma_table; register dictentry *ep; register int restore_error; register int checked_error; register int cmp; PyObject *err_type, *err_value, *err_tb; PyObject *startkey; //[1] i = hash & mask; ep = &ep0[i]; //[2] if (ep->me_key == NULL || ep->me_key == key) return ep; //[3] if (ep->me_key == dummy) freeslot = ep; else { //[4] if (ep->me_hash == hash) { startkey = ep->me_key; cmp = PyObject_RichCompareBool(startkey, key, Py_EQ); if (cmp < 0) PyErr_Clear(); if (ep0 == mp->ma_table && ep->me_key == startkey) { //只有key相等才会返回已有位置,否者会寻找下一个位置 if (cmp > 0) goto Done; } else {
/* The compare did major nasty stuff to the
* dict: start over.
* XXX A clever adversary could prevent this
* XXX from terminating.
*/
ep = lookdict(mp, key, hash); goto Done; } } freeslot = NULL; } 。。。。。。 Done: return ep; }
由于PyDictObject中维护dict数量是有限的(ma_table的长度),而计算出的hash值可能超过此范围,故需要与ma_mask进行与操作获得下标,因此ma_mask 名字 不是 ma_size。
其中freeslot用来指向第一次搜索序列中的Dummy态entry,如果搜索失败返回freeslot指向的Dummy态entry,如果没有Dummy态entry,返回Unused态entry(都可指示搜索失败)。
下面是lookdict中进行第一次检查时需要注意的动作:
[1]:根据hash值获得entry的序号。
[2]:如果ep->me_key为NULL,且与key相同,搜索失败。
[3]:若当前entry处于Dummy态,设置freeslot。
[4]:检查当前Active的entry中的key与待查找的key是否相同,如果相同,则立即返回,搜索成功。
在[4]中,需要注意那个PyObject_RichCompareBool,它的函数原形为:
int PyObject_RichCompareBool(PyObject *v, PyObject *w, int op)
当(v op w)成立时,返回1;当(v op w)不成立时,返回0;如果在比较中发生错误,则返回-1。
在lookdict中,当第一次hash值获得的entry与待查找元素比较发现不一样时,会继续在探测序列上查找:
[dictobject.c] static dictentry* lookdict(dictobject *mp, PyObject *key, register long hash) { register int i; register unsigned int perturb; register dictentry *freeslot; register unsigned int mask = mp->ma_mask; dictentry *ep0 = mp->ma_table; register dictentry *ep; register int restore_error; register int checked_error; register int cmp; PyObject *err_type, *err_value, *err_tb; PyObject *startkey; 。。。。。。 for (perturb = hash; ; perturb >>= PERTURB_SHIFT) { //[5] i = (i << 2) + i + perturb + 1; ep = &ep0[i & mask]; //[6] if (ep->me_key == NULL) { if (freeslot != NULL) ep = freeslot; break; } if (ep->me_key == key)//[7] break; if (ep->me_hash == hash && ep->me_key != dummy) { startkey = ep->me_key; cmp = PyObject_RichCompareBool(startkey, key, Py_EQ); if (cmp < 0) PyErr_Clear(); if (ep0 == mp->ma_table && ep->me_key == startkey) { if (cmp > 0) break; } else { ep = lookdict(mp, key, hash); break; } } //[8] else if (ep->me_key == dummy && freeslot == NULL) freeslot = ep; } Done: return ep; }
[5]:获得探测序列中的下一个待探测的entry。
[6]:ep到达一个Unused态entry,表明搜索结束。这是如果freeslot不为空,则返回freeslot所指entry。
[7]:entry与待查找的key匹配,搜索成功。
[8]:在探测序列中发现Dummy态entry,设置freeslot。
比较lookdict_string与lookdict可发现,lookdict_string是lookdict针对PyStringObject的简化版,而且效率要高很多。Python自身也大量使用PyDictObject对象,大都使用PyStringObject作为key,故lookdict_string对Python整理运行效率都有重要影响。
搜索部分内容比较多,代码比较长,有兴趣好好琢磨。lookdict_string相当于在hash值相同的探索链上找,调用一次可以找到;lookdict差不多,不过里面key对象不一定是PyStringObject,所以多了一些检查、判断函数,还多了一个递归找的逻辑(判断逻辑:只有key相等才返回已有位置,否者会寻找下一个位置)。
***标记一下有一点不太理解:
if (ep0 == mp->ma_table && ep->me_key == startkey)
啥意思。。
***
3.1.3、插入与删除
PyDictObject插入建立在搜索上:
[dictobject.c] static void insertdict(register dictobject *mp, PyObject *key, long hash, PyObject *value) { PyObject *old_value; register dictentry *ep; ep = mp->ma_lookup(mp, key, hash); //[1] if (ep->me_value != NULL) { old_value = ep->me_value; ep->me_value = value; Py_DECREF(old_value); /* which **CAN** re-enter */ Py_DECREF(key); } //[2] else { if (ep->me_key == NULL) mp->ma_fill++; else Py_DECREF(ep->me_key); ep->me_key = key; ep->me_hash = hash; ep->me_value = value; mp->ma_used++; } }
搜索结果可能是Active态的entry,也可能是Dummy或Unused态的entry;对于前者只需替换me_value,对于后者要设置其他值:
[1] :搜索成功,返回处于Active的entry,直接替换me_value。
[2] :搜索失败,返回Unused或Dummy的entry,完整设置me_key,me_hash和me_value。
在调用insertdict前会调用PyDict_SetItem:
[dictobject.c] int PyDict_SetItem(register PyObject *op, PyObject *key, PyObject *value) { register dictobject *mp; register long hash; register int n_used; mp = (dictobject *)op; //计算hash值 if (PyString_CheckExact(key)) { hash = ((PyStringObject *)key)->ob_shash; if (hash == -1) hash = PyObject_Hash(key); } else { hash = PyObject_Hash(key); if (hash == -1) return -1; } n_used = mp->ma_used; Py_INCREF(value); Py_INCREF(key); insertdict(mp, key, hash, value); if (!(mp->ma_used > n_used && mp->ma_fill*3 >= (mp->ma_mask+1)*2)) return 0; return dictresize(mp, mp->ma_used*(mp->ma_used>50000 ? 2 : 4)); }
首先会获得key的hash值,在插入元素后会判断是否需要改变ma_table大小。判断条件为装载率大于2/3((mp->ma_fill)/(mp->ma_mask+1) >= 2/3)而且使用了Unused态的entry(mp->ma_used > n_used)。在改变table时可能是增加也可能是减少,新增大小为table中Active态的entry数的2或4倍(看数量是否超过50000)。
改变table大小则由dictresize负责:
[dictobject.c] static int dictresize(dictobject *mp, int minused) { int newsize; dictentry *oldtable, *newtable, *ep; int i; int is_oldtable_malloced; dictentry small_copy[PyDict_MINSIZE]; //[1] for(newsize = PyDict_MINSIZE; newsize <= minused && newsize > 0; newsize <<= 1) ; oldtable = mp->ma_table; assert(oldtable != NULL); is_oldtable_malloced = oldtable != mp->ma_smalltable; //[2] if (newsize == PyDict_MINSIZE) { newtable = mp->ma_smalltable; if (newtable == oldtable) { if (mp->ma_fill == mp->ma_used) { //没有任何Dummy态entry,直接返回 return 0; } //将oldtable拷贝,进行备份 assert(mp->ma_fill > mp->ma_used); memcpy(small_copy, oldtable, sizeof(small_copy)); oldtable = small_copy; } } else { newtable = PyMem_NEW(dictentry, newsize); } //[3] assert(newtable != oldtable); mp->ma_table = newtable; mp->ma_mask = newsize - 1; memset(newtable, 0, sizeof(dictentry) * newsize); mp->ma_used = 0; i = mp->ma_fill; mp->ma_fill = 0; //[4] for (ep = oldtable; i > 0; ep++) { if (ep->me_value != NULL) { /* active entry */ --i; insertdict(mp, ep->me_key, ep->me_hash, ep->me_value); } else if (ep->me_key != NULL) { /* dummy entry */ --i; assert(ep->me_key == dummy); Py_DECREF(ep->me_key); } } if (is_oldtable_malloced) PyMem_DEL(oldtable); return 0; }
[1] :dictresize首先会确定新的table的大小,很显然,这个大小一定要大于传入的参数minused,这也是在原来的table中处于Active态的entry的数量。dictresize从8开始,以指数方式增加大小,直到超过了minused为止。所以实际上新的table的大小在大多数情况下至少是原来table中Active态entry数量的4倍。
[2] :如果在[1]中获得的新的table大小为8,则不需要在堆上分配空间,直接使用ma_smalltable就可以了;否则,则需要在堆上分配空间。
[3] :对新的table进行初始化,并调整原来PyDictObject对象中用于维护table使用情况的变量。
[4] :对原来table中的非Unused态entry进行处理。对于Active态entry,显然需要将其插入到新的table中,这个动作由前面考察过的insertdict完成;而对于Dummy态的entry,则略过,不做任何处理,因为我们知道Dummy态entry存在的唯一理由就是为了不使搜索时的探测序列中断。现在所有Active态的entry都重新依次插入新的table中,它们会形成一条新的探测序列,不再需要这些Dummy态的entry了。
从PyDictObject中删除一个元素:
[dictobject.c] int PyDict_DelItem(PyObject *op, PyObject *key) { register dictobject *mp; register long hash; register dictentry *ep; PyObject *old_value, *old_key; //获得hash值 if (!PyString_CheckExact(key) || (hash = ((PyStringObject *) key)->ob_shash) == -1) { hash = PyObject_Hash(key); if (hash == -1) return -1; } //搜索entry mp = (dictobject *)op; ep = (mp->ma_lookup)(mp, key, hash); //删除entry所维护的元素 old_key = ep->me_key; Py_INCREF(dummy); ep->me_key = dummy; old_value = ep->me_value; ep->me_value = NULL; mp->ma_used--; Py_DECREF(old_value); Py_DECREF(old_key); return 0; }
先获取hash值,取到entry后将entry从Active态转为Dummy态,再调整相关变量。
4、PyDictObject 对象缓冲池
PyDictObject和PyListObject一样也使用缓冲池技术:
[dictobject.c] #define MAXFREEDICTS 80 static PyDictObject *free_dicts[MAXFREEDICTS]; static int num_free_dicts = 0;
而且和PyListObject的缓冲池类似,在PyDictObject对象被销毁时才把内存加入缓冲池:
[dictobject.c] static void dict_dealloc(register dictobject *mp) { register dictentry *ep; int fill = mp->ma_fill; PyObject_GC_UnTrack(mp); Py_TRASHCAN_SAFE_BEGIN(mp) //调整dict中对象的引用计数 for (ep = mp->ma_table; fill > 0; ep++) { if (ep->me_key) { --fill; Py_DECREF(ep->me_key); Py_XDECREF(ep->me_value); } } //向系统归还从堆上申请的空间 if (mp->ma_table != mp->ma_smalltable) PyMem_DEL(mp->ma_table); //将被销毁的PyDictObject对象放入缓冲池 if (num_free_dicts < MAXFREEDICTS && mp->ob_type == &PyDict_Type) free_dicts[num_free_dicts++] = mp; else mp->ob_type->tp_free((PyObject *)mp); Py_TRASHCAN_SAFE_END(mp) }
缓冲池中只保留了PyDictObject对象,里面从堆上申请的table则会被销毁,归还系统。如果被销毁的PyDictObject对象只是用了固有的ma_smalltable,那只需调整ma_smalltable中对象的引用计数。
在创建PyDictObject对象时,缓冲池有则直接从缓冲池取:
[dictobject.c] PyObject* PyDict_New(void) { register dictobject *mp; ………… if (num_free_dicts) { mp = free_dicts[--num_free_dicts]; _Py_NewReference((PyObject *)mp); if (mp->ma_fill) { EMPTY_TO_MINSIZE(mp); } } ………… }
5、Hack PyDictObject
python内部大量使用PyDictObject,每个小小调用都会对insertdict频繁调用,故打印的话可用特征串,打印:
static void ShowDictObject(dictobject* dictObject) { dictentry* entry = dictObject->ma_table; int count = dictObject->ma_mask+1; int i; for(i = 0; i < count; ++i) { PyObject* key = entry->me_key; PyObject* value = entry->me_value; if(key == NULL) { printf("NULL"); } else { (key->ob_type)->tp_print(key, stdout, 0); } printf("\t"); if(value == NULL) { printf("NULL"); } else { (key->ob_type)->tp_print(value, stdout, 0); } printf("\n"); ++entry; } } static void insertdict(register dictobject *mp, PyObject *key, long hash, PyObject *value) { …… { dictentry *p; long strHash; PyObject* str = PyString_FromString("Python_Robert"); strHash = PyObject_Hash(str); p = mp->ma_lookup(mp, str, strHash); if(p->me_value != NULL && (key->ob_type)->tp_name[0] == 'i') { PyIntObject* intObject = (PyIntObject*)key; printf("insert %d\n", intObject->ob_ival); ShowDictObject(mp); } } }
调用print的时候也会调用到dealloc,所以num_free_dicts的值变化可能和想象的不一样。