作者:糊涂小蜗牛
链接:https://www.jianshu.com/p/42d7d0b82708
来源:简书
lua表分为数组和散列表部分,数组部分从 1 开始作为第一个索引,散列表部分要求键值不能为 nil。因为表包括散列表和数组两部分数据,所以一个以正整数作为键值的数据写入lua表时不确定是写入了数组还是散列表中。接下来讨论这部分的操作原理。
虽然正整数作为键值的数据写入lua表时不确定是写入了数组还是散列表中,但 0 和 负数做 key 时是肯定放在散列表中。
查找
如果输入的 key 是一个正整数,并且它的值 > 0 && <= 数组大小
尝试在数组部分查找
否则尝试在散列表部分查找:
计算出该 key 的散列值,根据此散列值访问 Node 数组得到散列值所在的位置
遍历该散列桶下的所有键表元素,直到找到该 key 为止
可以看到,即使是一个正整数的key,其存储部分也不见得会一定落在数组部分,这完全取决于它的大小是否落在了当前数组可容纳的空间范围内。
新增
添加新元素的流程比较复杂,因为涉及重新分配表中数组和散列表部分的流程。
散列表部分的数据组织是,首先计算数据的key所在的桶数组位置,这个位置称为 mainposition。相同mainposition的数据以链表形式组织。当找不到对应的key时,则会调用内部的newkey
函数分配一个新的key来返回:
(ltable.c)
/*
** inserts a new key into a hash table; first, check whether key's main
** position is free. If not, check whether colliding node is in its main
** position or not: if it is not, move colliding node to an empty place and
** put new key in its main position; otherwise (colliding node is in its main
** position), new key goes to an empty position.
*/
TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
Node *mp;
TValue aux;
if (ttisnil(key)) luaG_runerror(L, "table index is nil");
else if (ttisfloat(key)) {
lua_Integer k;
if (luaV_tointeger(key, &k, 0)) { /* does index fit in an integer? */
setivalue(&aux, k);
key = &aux; /* insert it as an integer */
}
else if (luai_numisnan(fltvalue(key)))
luaG_runerror(L, "table index is NaN");
}
mp = mainposition(t, key);
if (!ttisnil(gval(mp)) || isdummy(t)) { /* main position is taken? */
Node *othern;
Node *f = getfreepos(t); /* get a free place */
if (f == NULL) { /* cannot find a free place? */
rehash(L, t, key); /* grow table */
/* whatever called 'newkey' takes care of TM cache */
return luaH_set(L, t, key); /* insert key into grown table */
}
lua_assert(!isdummy(t));
othern = mainposition(t, gkey(mp));
if (othern != mp) { /* is colliding node out of its main position? */
/* yes; move colliding node into free position */
while (othern + gnext(othern) != mp) /* find previous */
othern += gnext(othern);
gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */
*f = *mp; /* copy colliding node into free pos. (mp->next also goes) */
if (gnext(mp) != 0) {
gnext(f) += cast_int(mp - f); /* correct 'next' */
gnext(mp) = 0; /* now 'mp' is free */
}
setnilvalue(gval(mp));
}
else { /* colliding node is in its own main position */
/* new node will go into free position */
if (gnext(mp) != 0)
gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */
else lua_assert(gnext(f) == 0);
gnext(mp) = cast_int(f - mp);
mp = f;
}
}
setnodekey(L, &mp->i_key, key);
luaC_barrierback(L, t, key);
lua_assert(ttisnil(gval(mp)));
return gval(mp);
}
这个函数的操作流程如下
1、如果该mainposition上已经有其他数据或者第一次插入情况:
(1)首先获得lastfree指向的空间,若找不到空闲位置放置新键值,则调用rehash
函数,增加或减少哈希表的大小,重新插入元素。
(2)若该mp被占了,检查占领该位置的node的mp是不是在这个地方,若不在这个地方,则移动该node到一个新的位置,并且把要插入的元素插入到相应的位置;若在这个地方(即占领该位置的node的mp就是要插入的位置),则把要插入的元素插入到一个新的空node中。
2、如果该mp为空,则直接把相应的元素插入到这个node中。
以上操作涉及重新对表空间进行分配的情况。这一部分比较复杂,入口函数是rehash
,顾名思义,这个函数的作用就是为了做重新散列操作:
/*
** nums[i] = number of keys 'k' where 2^(i - 1) < k <= 2^i
*/
static void rehash (lua_State *L, Table *t, const TValue *ek) {
unsigned int asize; /* optimal size for array part */
unsigned int na; /* number of keys in the array part */
unsigned int nums[MAXABITS + 1];
int i;
int totaluse;
for (i = 0; i <= MAXABITS; i++) nums[i] = 0; /* reset counts */
na = numusearray(t, nums); /* count keys in array part */
totaluse = na; /* all those keys are integer keys */
totaluse += numusehash(t, nums, &na); /* count keys in hash part */
/* count extra key */
na += countint(ek, nums);
totaluse++;
/* compute new size for array part */
asize = computesizes(nums, &na);
/* resize the table to new computed sizes */
luaH_resize(L, t, asize, totaluse - na);
}
它的主要操作如下所示。
(1) 分配一个位图nums
,将其中的所有位置0。这个位图的意义在于:nums
数组中第i个元素存放的是 key
在 2^(i-1) 和 2^i 之间的元素数量。
(2) 遍历Lua表中的数组部分,计算其中的元素数量,更新对应的nums
数组中的元素数量(numusearray
函数)。
(3) 遍历lua表中的散列桶部分,因为其中也可能存放了正整数,需要根据这里的正整数数量更新对应的nums
数组元素数量(numusehash
函数)。
(4) 此时nums
数组已经有了当前这个Table中所有正整数的分配统计,逐个遍历nums
数组,获得其范围区间内所包含的整数数量大于50%的最大索引,作为重新散列之后的数组大小,超过这个范围的正整数,就分配到散列桶部分了(computesizes
函数) 。
(5) 根据上面计算得到的调整后的数组和散列桶大小调整表(resize
函数)。
Lua的设计思想是,简单高效,并且还要尽量节省内存资源。
在重新散列的过程中,除了增大Lua表的大小以容纳新的数据之外,还希望能借此机会对原有的数组和散列桶部分进行调整,让两部分都尽可能发挥其存储的最高容纳效率。那么,这里的标准是什么呢?希望在调整过后,数组在每一个2次方位置容纳的元素数量都超过该范围的50%。能达到这个目标的话,我们就认为这个数组范围发挥了最大的效率。
设想一个场景来模拟前面的算法流程。假设现在有一个Lua表,经过一些变化之后,它的数组有以下key的元素:1, 2, 3, 20。首先,算法将计算这些key被分配到了哪些区间。
在这个算法里,我们使用数组来保存落在每个范围内的数据数量,其中每个元素存放的是 key 在 2^(i-1) 和 2^i 之间的元素数量。
前面关于数字键值的统计跑完之后,得到的结果是:
nums[0] = 1(1落在此区间)
nums[1] = 1(2落在此区间)
nums[2] = 1(3落在此区间)
nums[3] = 0
nums[4] = 0
nums[5] = 1(20落在此区间)
nums[6] = 0
...
nums[n] = 0(其中n > 5 且 n <= MAXBITS)
计算完毕后,我们得到了这个数组每个元素的数据,也就是得到了落在每个范围内的数据数量。接着,我们来计算怎样才能最大限度地使用这部分空间。这个算法由函数computesizes
实现:
/*
** Compute the optimal size for the array part of table 't'. 'nums' is a
** "count array" where 'nums[i]' is the number of integers in the table
** between 2^(i - 1) + 1 and 2^i. 'pna' enters with the total number of
** integer keys in the table and leaves with the number of keys that
** will go to the array part; return the optimal size.
*/
static unsigned int computesizes (unsigned int nums[], unsigned int *pna) {
int i;
unsigned int twotoi; /* 2^i (candidate for optimal size) */
unsigned int a = 0; /* number of elements smaller than 2^i */
unsigned int na = 0; /* number of elements to go to array part */
unsigned int optimal = 0; /* optimal size for array part */
/* loop while keys can fill more than half of total size */
for (i = 0, twotoi = 1;
twotoi > 0 && *pna > twotoi / 2;
i++, twotoi *= 2) {
if (nums[i] > 0) {
a += nums[i];
if (a > twotoi/2) { /* more than half elements present? */
optimal = twotoi; /* optimal size (till now) */
na = a; /* all elements up to 'optimal' will go to array part */
}
}
}
lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal);
*pna = na;
return optimal;
}
这个函数的输入参数nums
是前面已经计算好的计数数组。pna
存放的是前面计算得到的数字键值的数量,这是一个指针,说明会在这个函数中被修改,最后作为重新散列操作时数组部分的大小。这个函数的原理就是循环遍历数字键值部分,找到满足前面提到的条件的最大值:该范围内的数据满足大于50%的值。结合前面的测试数据来“试运行”一下这个函数。此时传入的 pna
参数是 4,也就是目前数组部分的数据数量。
首先,初始值,twotoi为1,i为0,a在循环初始时为0,它表示的是循环到目前为止数据小于2^i的数据数量。
i = 0,twotoi = 1,满足(twotoi > 0 && *pna > twotoi / 2),nums[i] = 1 > 0成立,a += nums[i], a = 1,满足a > twotoi/2,也就是满足这个范围内数组利用率大于50%的原则,此时记录下这个范围,也就是 optimal = twotoi = 1,到目前为止的数据数量 na = a = 1
i = 1,twotoi = 2,满足(twotoi > 0 && *pna > twotoi / 2),nums[i] = 1 > 0成立,a += nums[i], a = 2,满足a > twotoi/2,记录下这个范围,也就是 optimal = twotoi = 2,到目前为止的数据数量 na = a = 2
i = 2,twotoi = 4,满足(twotoi > 0 && *pna > twotoi / 2),nums[i] = 1 > 0成立,a += nums[i], a = 3,此时满足a > twotoi/2,记录下这个范围,也就是 optimal = twotoi = 4,到目前为止的数据数量 na = a = 3
i = 3,twotoi = 8,不满足(twotoi > 0 && *pna > twotoi / 2),结束,返回 optimal 为4。
得到数组的大小是4,也就是说key为1、2、3这三个元素落在了数组部分,而20则落在了散列桶部分。这个过程可以看出,一个整数的key在同一个表中不同的阶段可能被分配到数组或者散列桶部分,而这一点是很多人经常忽视的。
另外,从上面的分析可以看到,Lua解释器背着我们会对表进行重新散列的动作,而这个操作的代价是挺大的,如下面的代码:
local a = {}
for i=1,3 do
a[i] = true
end
在这段代码中,主要做了如下工作。
(1) 最开始,Lua创建了一个空表a
。
(2) 在第一次迭代中,a[1]
为true
触发了一次重新散列操作,Lua将数组部分的长度设置为2^0,即1,散列表部分仍为空。
(3) 在第二次迭代中,a[2]
为true
再次触发了重新散列操作,将数组部分长度设为2^1,即2。
(4) 最后一次迭代又触发了一次重新散列操作,将数组部分长度设为2^2,即4。
只有三个元素的表会执行三次重新散列操作,然而有100万个元素的表仅仅只会执行20次重新散列操作而已,因为2^20 = 1048576 > 1000000。但是,如果创建了非常多的长度很小的表,这可能会造成巨大的影响。
如果你有很多很小的表需要创建,就可以预先填充以避免重新散列操作。比如:{true, true, true}
,Lua知道这个表有3个元素,所以直接创建了3个元素的数组。类似地,{x=1, y=2, z=3}
,Lua创建长度为3散列部分。
这里对比以下两段代码,首先看没有使用预填充技术的代码:
a = os.clock()
for i = 1,2000000 do
local a = {}
a[1] = 1; a[2] = 2; a[3] = 3
end
b = os.clock()
print(b-a)
再看使用了预填充技术的代码:
a = os.clock()
for i = 1,2000000 do
local a = {1,2,3}
a[1] = 1; a[2] = 2; a[3] = 3
end
b = os.clock()
print(b-a)
测试得到,使用了预填充技术的代码比没有使用这个优化的代码的速度提高了多倍。所以,当需要创建非常多的小表时,应预先填充好表的大小,减少解释器被动地进行重新散列操作的过程。
文章浏览阅读568次。Low直接输入1、查看服务器端源代码<?phpif( isset( $_POST[ 'btnSign' ] ) ) { // Get input $message = trim( $_POST[ 'mtxMessage' ] ); $name = trim( $_POST[ 'txtName' ] ); // Sanitize message..._xss(stored) dvwa
文章浏览阅读723次。http://gem5.org/ARM_Linux_KernelPrerequisitesThese instructions are for running headless systems. That is a more "server" style system where there is no frame-buffer. The description has b_`build/x86/gem5.opt' is up to date.
文章浏览阅读2.9k次,点赞4次,收藏21次。回环检测回环校正(二):回环校正原理一、回环校正概述参考:[1]徐宽. 融合IMU信息的双目视觉SLAM研究[D].哈尔滨工业大学,2018.回环校正所要做的事是如何利用回环信息消除累计的误差。回环校正主要分为两个步骤:1、首先,进行回环融合,回环融合就是将回环检测匹配到的特征点所相关联的地图点融合,将重复的地图点剔除。2、然后进行当前帧位姿校正,利用回环检测得到的基础矩阵算出当前帧和回..._回环检测怎么修正轨迹
该文章是关于Ubuntu中使用nginx时无法显示index.html页面的问题。文章提供了一个配置文件的示例,说明如何在nginx.conf文件中配置服务器监听的端口和服务。然后,文章介绍了如何重启nginx服务,并在浏览器中测试是否能够成功显示index.html页面。
文章浏览阅读605次。一,步进电机的几个概念1,步进电机普遍存在发热的情况二,28BYJ-48步进电机介绍1,28BYJ-48步进电机自带减速器,四相五线(减速器不是用来减速的,注意和刹车的区别)_28byj步进电机发烫
文章浏览阅读2.3k次。ARM架构概览_arm架构
文章浏览阅读4.9k次。1、写上对应的表单select$type = $id ? User::where('id',$id)->value('intro_type') : 1;$form->select('intro_type','介绍类型')->options(['1'=>'上传图片','2'=>'链接地址'])->default($type);2、加上对应的js代码A..._laravel form::select
文章浏览阅读2.2w次,点赞14次,收藏91次。在粒子群算法中,所谓惯性权重w即粒子能保持前一时刻运动状态的能力,在粒子群算法中格外重要。这里介绍两种常用的惯性权重算法:1.典型线性递减策略;2.线性微分递减策略。其中,算法所要解决典型线性递减策略的w计算公式如下:..._粒子群算法惯性权重取值
文章浏览阅读669次。脚本#!/bin/bashread -p "请输入要查询的用户名:" Aecho "-----------------------------"n=`cat /etc/passwd | awk -F: '$1~/^'$A'$/{print}' | wc -l`if [ $n -eq 0 ];then echo "该用户不存在" echo "-----------------------------" exitfiecho "该用户的用户名:$A"echo "该用户的UID:`cat _两个不通身份的人使用一个登录系统,如何根据用户名查询
文章浏览阅读7.3k次,点赞2次,收藏3次。背景:国庆之后满心欢喜将MacBook升级到Catalina,发现IDEA中的项目启动报错。emm…查看之后发现是因为项目无法在根目录下找到之前创建的日志文件夹,打开一看,如果没了。@~@明明之前存在的啊,emm…升级有风险。后来在Shared账户中发现了Previously Relocated Items文件夹。意思是重新定位的项目。打开一看,文件中出现了苹果工程师给你的信。以及你曾经的项..._previously relocated items
文章浏览阅读2.1w次,点赞28次,收藏148次。事出有因因为现在做的一个项目是全程全屏显示的。因此不同屏幕分辨率对程序界面的影响太大。而UI设计的时候又没有过多的考虑自动布局这方面的事。虽然在刚开始做界面的时候已经尽量利用自动布局来做,但是有些控件提供的图片大小不太合适,在做的时候只能给控件设置固定大小。在测试不同分辨率的时候发现界面展现的效果不同。于是就开始想办法做分辨率适配。偶然事件具体忘记当时在搜索什么东西了,大概应该是高分屏适配的问题。在qt的一篇官方文档中发现了这个好东西:QT_SCALE_FACTOR [numeric] defi_qt_scale_factor
文章浏览阅读921次。构建触发器指的是在什么条件下或者是什么时候去触发项目的构建,在前面我们都是手动点击Build Now去构架项目。而事实上Jenkins内置了4种构建触发器,可以让我们自动或者说半自动的去触发项目的构建,4种构建触发器分别是:触发远程构建其它工程构建后触发定时构建轮询SCM1. 触发远程构建触发远程构建是指通过一个远程地址来触发项目的构建,通常用于在另一个系统通过链接来远程发起项目的构建。触发远程构建需要一个身份验证令牌,比如我们这里写成remote-build。那么我们就可以通过htt_jenkins支持哪几种触发方式