Jemalloc 初始化(二) index2size和size2index解析

最新推荐文章于 2023-05-12 16:06:02 发布
最新推荐文章于 2023-05-12 16:06:02 发布
阅读量2.6k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/deusomax/article/details/69567003
版权

前面没有分析完 Jemalloc 初始化，是因为遇到了一个表不得其解，所以停下来分析，这是一个精妙的算法，通过index可以算出size，通过size也可以算出index。

我是从size推算index开始研究的

注释的数是在以下推导的基础上填的
#define    SIZE_CLASSES \
  /* index, lg_grp, lg_delta, ndelta, bin, lg_delta_lookup */ \
    SC(  0,      3,        3,      0, yes,  3) \ 1-8
    SC(  1,      3,        3,      1, yes,  3) \ 9-16
    SC(  2,      3,        3,      2, yes,  3) \ 17-24
    SC(  3,      3,        3,      3, yes,  3) \ 25-32
                                               \---------------------分割线以下适合用公式
    SC(  4,      5,        3,      1, yes,  3) \ 33-40
    SC(  5,      5,        3,      2, yes,  3) \ 41-48
    SC(  6,      5,        3,      3, yes,  3) \ 49-56
    SC(  7,      5,        3,      4, yes,  3) \ 57-64
                                               \
    SC(  8,      6,        4,      1, yes,  4) \ 65-80 size
    SC(  9,      6,        4,      2, yes,  4) \ 81-96 size
    SC( 10,      6,        4,      3, yes,  4) \ 97-112
    SC( 11,      6,        4,      4, yes,  4) \ 113-128
                                               \
    SC( 12,      7,        5,      1, yes,  5) \ 129-160
    SC( 13,      7,        5,      2, yes,  5) \ 161-192
    SC( 14,      7,        5,      3, yes,  5) \ 193-224
    SC( 15,      7,        5,      4, yes,  5) \ 225-256
                                               \
    SC( 16,      8,        6,      1, yes,  6) \
    SC( 17,      8,        6,      2, yes,  6) \
    SC( 18,      8,        6,      3, yes,  6) \
    SC( 19,      8,        6,      4, yes,  6) \
                                               \
    SC( 20,      9,        7,      1, yes,  7) \
    SC( 21,      9,        7,      2, yes,  7) \
    SC( 22,      9,        7,      3, yes,  7) \
    SC( 23,      9,        7,      4, yes,  7) \
                                               \
    SC( 24,     10,        8,      1, yes,  8) \
    SC( 25,     10,        8,      2, yes,  8) \
    SC( 26,     10,        8,      3, yes,  8) \
    SC( 27,     10,        8,      4, yes,  8) \
                                               \
    SC( 28,     11,        9,      1, yes,  9) \
    SC( 29,     11,        9,      2, yes,  9) \
    SC( 30,     11,        9,      3, yes,  9) \
    SC( 31,     11,        9,      4, yes,  9) \
                                               \
    SC( 32,     12,       10,      1, yes, no) \
    SC( 33,     12,       10,      2, yes, no) \
    SC( 34,     12,       10,      3, yes, no) \
    SC( 35,     12,       10,      4, yes, no) \
                                               \
    SC( 36,     13,       11,      1, yes, no) \ 2^13 + 1，2^13 + 1 + 2^11-1=2^13 + 2^11
    SC( 37,     13,       11,      2, yes, no) \ 2^13 + 2^11 + 1, 2^13 + 2^11 + 1 + 2^11 - 1 = 2^13 + 2*2^11
    SC( 38,     13,       11,      3, yes, no) \ 2^13 + 2*2^11 + 1, 2^13 + 3*2^11
    SC( 39,     13,       11,      4,  no, no) \ 2^13 + 3*2^11 +1, 2^13 + 4*2^11 = 2^14

size2index

LOOKUP_MAXCLASS = 4096，4096以内的size才能直接在这个表里查找，否则就是计算
size2index_tab总数是8 +  4*2 + 4*2*2 + ... + 4*2^6 = 512
const uint8_t size2index_tab[] = {
(1,2,...7)
(8,8, 9,9, ..., 11,11)
(12,12,12,12, ...., 15,15,15,15)
...
(64个28, ..., 64个31)
}

size_t ret = ((size_t)(size2index_tab[(size-1) >> LG_TINY_MIN]));
索引(size-1) >> LG_TINY_MIN = (size-1) >> 3最大不会超过512

/* sizeof(void *) == 2^LG_SIZEOF_PTR. */ 3 = log2(8) 2 = log2(4)
#define LG_SIZEOF_PTR 3

/*
 * Minimum allocation alignment is 2^LG_QUANTUM bytes (ignoring tiny size
 * classes).
 */
#define LG_QUANTUM 3

size2index_compute(size_t size)
    size_t x = unlikely(ZI(size) < 0) ? ((size<<1) ?
            (ZU(1)<<(LG_SIZEOF_PTR+3)) : ((ZU(1)<<(LG_SIZEOF_PTR+3))-1))
            : lg_floor((size<<1)-1);
        size的二进制表示最高位1是第几位，x的含义就是grp
    size_t shift = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM) ? 0 :
            x - (LG_SIZE_CLASS_GROUP + LG_QUANTUM);
        x = 4是个分界点, x = 4能代表的最大数是5个1，即2^5 - 1 = 31
        即如果size < 32, shift = 0,否则shift = x - 5，32 < size <= 64, shift = 1
    size_t grp = shift << LG_SIZE_CLASS_GROUP;
        如果size = 33~64，x = 6，shift = 1，grp = 2^2
        如果size = 65~128，x = 7，shift = 2，grp = 2 * 2^2
        如果size = 129~256，x = 8，shift = 3，grp = 3 * 2^2
    size_t lg_delta = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM + 1)
            ? LG_QUANTUM : x - LG_SIZE_CLASS_GROUP - 1;
        size <= 32, lg_delta = 3
        size <= 64，x = 6, lg_delta = 3
        size <= 128, x = 7, lg_delta = 4
        size <= 256, x = 8, lg_delta = 5
    size_t delta_inverse_mask = ZI(-1) << lg_delta;
    size_t mod = ((((size-1) & delta_inverse_mask) >> lg_delta)) &
        ((ZU(1) << LG_SIZE_CLASS_GROUP) - 1);
        size = 64，lg_delta = 3, 减一去掉低(3, 4, 5...)位并右移，只取低2位，3
        size = 65，lg_delta = 4, 减一去掉低(3, 4, 5...)位并右移，只取低2位，0
        ...
    size_t index = NTBINS + grp + mod;
        NTBINS = 0, 实际index = grp + mod
        size = 64，4 + 3 = 7
        size = 65, 8 + 0 = 8, 66, 8 +0 = 8,...,80, 8 + 0 = 8, [65-80] 这16个数共享8这个index
        [81-96]这16个数共享9，[65-128]总共64，分成4组，共享4个index    
        [129-256]有128个数，划分成每份32，也是4组，[129-160]共享12，依次类推

结合上面的表可知各字段的含义
index：表中的索引
lg_grp：size-1的最高位1是第几位，从右往左数，从0开始
lg_delta：2^lg_delta个数共享1个index
ndelta：组内几个偏移单位

通过size可以计算出grp和mod，加和为index

size2index分析结束

下面分析index2size

通过index计算size也有一张表，他里面的size是代表这个index的最大size(结合上面表中添加的注释可以知道)
index2size_tab = {8, 16, 24, 32, 40, 48, 56, 64, 80, 96, ...
计算方法((ZU(1)<<lg_grp) + (ZU(ndelta)<<lg_delta))，即2^lg_grp + ndelta * 2^lg_delta
但这是知道lg_grp和lg_delta，以及ndelta的前提下可以快速计算的，通过一个index能不能计算呢

通过index，不查表，也可以计算出grp和mod
因为index的后两位是mod，前面的是grp
size_t reduced_index = index - NTBINS;
size_t grp = reduced_index >> LG_SIZE_CLASS_GROUP; 这里的grp是上面的shift
size_t mod = reduced_index & ((ZU(1) << LG_SIZE_CLASS_GROUP) - 1);
index= 0,grp=0,mod=0
index= 1,grp=0,mod=1
index= 2,grp=0,mod=2
index= 3,grp=0,mod=3

index= 4,grp=1,mod=0
index= 5,grp=1,mod=1
index= 6,grp=1,mod=2
index= 7,grp=1,mod=3

index= 8,grp=2,mod=0
index= 9,grp=2,mod=1
....

size_t grp_size_mask = ~((!!grp)-1);
size_t grp_size = ((ZU(1) << (LG_QUANTUM + (LG_SIZE_CLASS_GROUP-1))) << grp) & grp_size_mask;
index= 0,grp_size_mask=0x0, grp_size= 0
index= 1,grp_size_mask=0x0, grp_size= 0
index= 2,grp_size_mask=0x0, grp_size= 0
index= 3,grp_size_mask=0x0, grp_size= 0

index= 4,grp_size_mask=0xffffffff, grp_size= 32
index= 5,grp_size_mask=0xffffffff, grp_size= 32
index= 6,grp_size_mask=0xffffffff, grp_size= 32
index= 7,grp_size_mask=0xffffffff, grp_size= 32

index= 8,grp_size_mask=0xffffffff, grp_size= 64
index= 9,grp_size_mask=0xffffffff, grp_size= 64
....

size_t shift = (grp == 0) ? 1 : grp;
size_t lg_delta = shift + (LG_QUANTUM-1);
size_t mod_size = (mod+1) << lg_delta;

index= 0,shift=1, lg_delta=3 , mod_size=8
index= 1,shift=1, lg_delta=3 , mod_size=16
index= 2,shift=1, lg_delta=3 , mod_size=24
index= 3,shift=1, lg_delta=3 , mod_size=32

index= 4,shift=1, lg_delta=3 , mod_size=8
index= 5,shift=1, lg_delta=3 , mod_size=16
index= 6,shift=1, lg_delta=3 , mod_size=24
index= 7,shift=1, lg_delta=3 , mod_size=32

index= 8,shift=2, lg_delta=4 , mod_size=16
index= 9,shift=2, lg_delta=4 , mod_size=32
....

size_t usize = grp_size + mod_size;
index= 0,size=8
index= 1,size=16
index= 2,size=24
index= 3,size=32

index= 4,size=32 + 8=40
index= 5,size=32 + 16 = 48
index= 6,size=32 + 24 = 56
index= 7,size=32 + 32 = 64

index= 8,size=64 + 16 = 80
index= 9,size=64 + 32 = 96
....


还有个函数s2u_compute，他的结果是index2size_lookup的结果，即一个分组的内部分组的最大值
s2u_compute(35584)
size_t x = unlikely(ZI(size) < 0) ? ((size<<1) ?
            (ZU(1)<<(LG_SIZEOF_PTR+3)) : ((ZU(1)<<(LG_SIZEOF_PTR+3))-1))
            : lg_floor((size<<1)-1); //16
size_t lg_delta = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM + 1)
    ?  LG_QUANTUM : x - LG_SIZE_CLASS_GROUP - 1; //13
size_t delta = ZU(1) << lg_delta;
size_t delta_mask = delta - 1; //13个1
size_t usize = (size + delta_mask) & ~delta_mask; // 13位对齐，2^13大小对齐
return (usize);

以下面这组数据为例
SC(  4,      5,        3,      1, yes,  3) \ 33-40，33-39都让它变成40（按8字节对齐）
SC(  5,      5,        3,      2, yes,  3) \ 41-48
SC(  6,      5,        3,      3, yes,  3) \ 49-56
SC(  7,      5,        3,      4, yes,  3) \ 57-64

deusomax
关注
jemalloc 深入分析 之Region size 设计以及和 index 对应关系
ip5108的博客
02-02 1299
Region size 设计以及和 index 对应关系 6.1. Region size步长的设计 下图是对于从reg_size=64开始的增加规则，可以看出步长增加规则是每次在相邻幂次数位加1，得到下一个reg_size值。 6.2. Region相关的参数定义（anrdoid 64bits） 以下配置是对应于如下的系统参数： (LG_SIZEOF_PTR == 3 &amp;amp;amp;&amp;amp;amp;...
Redis的介绍和使用
ywn0601的博客
04-07 612
1. NoSQL 数据库简介 1.1. 技术发展 就不讲了 1.2. NoSQL数据库 1.2.1. NoSQL数据库概述 NoSQL(NoSQL = Not Only SQL )，意即“不仅仅是SQL”，泛指非关系型的数据库。 NoSQL 不依赖业务逻辑方式存储，而以简单的key-value模式存储。因此大大的增加了数据库的扩展能力。 1. 不遵循SQL标准。 2. 不支持ACID。 3. 远超于SQL的性能。 1.2.2. NoSQL适用场景 1. 对数据高并发的读写 2. 海量数据的读写 3. 对数据
Jemalloc 初始化
deusomax的专栏
04-07 4284
因为redis用到了jemalloc，所以有幸研究jemalloc的源代码，我们熟悉的内存管理函数无非就两个，一个是malloc，一个是free，它们内部是如何工作的，平时很少有机会得知，因为这两个函数被编译在glibc中，编译glibc都是很难的事，更何况去debug它，不debug源代码，仅靠文档知识，也只是一知半解，人云亦云。所以决定彻底的debug一遍jemalloc的代码。 debug
java.lang.IndexOutOfBoundsException: Index: 2, Size: 2
ruiguang21的博客
09-29 2万+
你的数组长度小于你的代码指定的长度嘛 这个简单啊 判断下你的数组长度，如果长度小于你指定的下标，那么就不要访问这个下标指定的位置就可以了 比如： if(list.size() > 2){ list.get(2); }
MYBATIS数组越界错INDEXOUTOFBOUND INDEX2, SIZE 2
NYANYOUNG的博客
07-08 897
因为是一个内连接sql语句，所以一直想多了，越界的点在于返回结果封装的对象，构造方法不对，，，，， 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/qaqpbp/article/details/115324998 ———————————————— 版权声明：本文为CSDN博主「比加」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blo
indexsize查询
viviliving的专栏
08-15 307
indexsize查询
Redis-字符串
最新发布
fade_away_py的博客
05-12 173
Redis 中的字符串类型使用的是 sds，也就是 “simple dynamic string”。sds 是 Redis 自己实现的一种字符串类型，它比 C 语言中的原始字符串类型 char[] 更为高效、安全，并提供了一些额外的功能。sds 实际上是通过一个固定结构的 sdshdr 来实现的，其中 sdshdr 是 sds 的实际存储数据结构，包含字符串长度、可用空间、引用计数等信息。
Redis 总结[安装、持久化、主从复制、哨兵、分片集群、内存淘汰策略、内存模型、缓存风险]
weixin_44266223的博客
03-07 3776
文章目录说明Redis 简介由来为什么Redis效率那么高Nosql数据库对比1.性能2.便利性3.存储空间4.可用性5.可靠性6.一致性各个Nosql数据库的优缺点1.Redis2.Memcache3.MongoDB安装Redis 3.01.安装所需依赖2.创建目录，下载或上传安装包3.解压4.编译安装5.启动持久化机制（AOF和RDB）1.什么是持久化2.AOF1.概述2.开启AOF持久化方式3.三种写入策略1.always2.everysec3. no4.AOF重写1.两种重写方式5.AOF文件损坏6
Android NE问题分析方法介绍
东哥日记
11-30 4711
文章目录简介Native内存布局NE问题常见类型常用调试工具tombstone抓取流程实例分析tombstone文件内容举例 简介 NE，全称Native Exception，在Android中主要指在用户空间运行的native程序或者natvie库发生异常。NE问题通常带来程序奔溃现象，导致功能模块不稳定。 本文主要介绍有关NE的基本知识、NE问题出现后的基本分析方法、常见的NE问题和常用调试工具。 Native内存布局 这里主要介绍Native进程的虚拟地址空间，分32bit和64bit进程，camer
ssdb源码初探之libnet库
0cool
03-26 2194
关于ssdb的介绍就不多说了，自行百度去了解下。因为工作上用到了ssdb，正好看看源码也可以学习下作者的设计思路。ssdb的作者在自己的博客上也写了不少关于它的文章，但说的很浅不够深入，借这个机会看看它的内在究竟是怎样的。我下的版本是1.8.0，直接从github上clone过来的。由于本人道行很浅，说的不对的地方还请大家不吝指正。
percona-toolkit常用工具的使用
qq_41401214的博客
08-23 2611
percona-toolkit工具的使用 文章目录percona-toolkit工具的使用说明安装具体工具介绍工具原理与使用pt-online-schema-change功能基本原理流程图用法使用示例pt-heartbeat功能基本原理流程图用法使用示例pt-table-checksum功能基本原理工作过程流程图用法使用示例pt-kill功能基本原理流程图用法使用示例pt-duplicate-key-checker功能基本原理用法使用示例pt-deadlock-logger功能基本原理用法使用示例pt-ta
jemalloc 3.6.0源码详解—[5]分配及实现
杏林小轩
12-27 3200
转载自：vector033 分配3.1 概览在2.3.2节中得知, jemalloc将size class划分成small, large, huge三种类型. 分配时这三种类型分别按照不同的算法执行. 后面的章节也将按照这个类型顺序描述.总体来说, jemalloc分配函数从je_malloc入口开始, 经过,je_malloc -> imalloc_body -> imalloc -> imall
java.lang.IndexOutOfBoundsException: Index: 1, Size: 2
zx19899891的专栏
02-26 1万+
在日常使用ArrayList时，相信大家都有遇到过IndexOutOfBoundsException 这样的错误，但是往往遇到的情况是index 大于或者等于 Size的情况，而今天我这里说的却是Index 小于 Size的情况，这是在手机使用过程中突然出现了异常而导致了手机重启，具体报错堆栈如下： java.lang.IndexOutOfBoundsException: Index: 1, S...
Index: 4, Size: 4
m0_49874395的博客
04-16 1496
我遇到这个问题原因是：for循环的时候粗心大意，循环的长度写错了。 如：下述则报此错 for (int i = 1; i < newsList.size(); i++) { }
服务器处理发生异常:Index: 0, Size: 0
Recently祝祝的博客
03-20 1万+
查询数据后你用的是List接收出参，然而你的List里边没有值，你却取了里边的值就报这个错。
报错 index:1，size:1 或 index：0，size:0
热门推荐
monica1_1的博客
09-26 2万+
实现功能：前提：confMember是sysUser的子集。 实现：1、将confMember中的人员的isChecked=true； 2、将除了conMember的sysUser数据拼装到； 3、将拼装的参数对应到conMember中，返回拼装好的conMemberList。 报错代码：index:1，size:1 或 index：0，size:0 //商户获取的部门人员列表:作对...
【Java集合 从源码透析，月薪上万不是梦】简单理解
qq_44682003的博客
04-28 327
集合源码解析一、前言二、List集合（一）ArrayList（二）ArrayList方法（三）ArrayList底层源码实现和解析 一、前言 上图是java集合框架图，我们可以看到java集合类主要由三个接口派生而出，即Collection和Map接口和Iterator java有三种集合，包括Set、List和Map，它们都处于java.util包中，Set、List和Map都是接口，它们有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值