该文章是对前一篇 OC底层原理01-alloc流程探索 中cls->instanceSize(计算内存大小)分支的一个拓展和深入

一、查看内存地址

1.1 下断点

image.png

1.2 用x 打印地址，既可以x该对象，也可以x该对象的指针地址

image.png

1.3 上面打印的一串16进制就是内存地址了，前面八位就是存的isa，但是因为iOS是小端储存方式，所以应该倒着读，那isa的地址实际为：

image.png

1.4 为了方便好看我们优化一下打印命令指令：x/4gx，按照每8位的格式打印4组

image.png

1.5 那我们来po一下看看他里面到底存的什么东西

image.png

1.6 原来我们赋值的属性存到这里的，证明我们确实找到了他的存储位置，那么为什么第一行第二组全是0呢？

image.png

1.7 原来是因为还有age,height,char1,char2没赋值，为了验证，我们将他们都赋值打印看看情况

image.png

1.8 我们发现当所有属性都赋值过后，没有出现0x000000000000的情况了，证明我们上面的猜想正确。那我们的age,char1,char2，去哪了呢？是在0x0000001200004241中吗？但是他又是一串乱码数字，接下来就是见证奇迹的时刻

image.png

1.9 为什么A变成了65，B变成了66呢？聪明的你肯定猜到了，因为字符会以ASCII码的形式存在内存，那么问题又来了:

对象是以16字节对齐的方式开辟空间，它真正需要的内存是8字节对齐，那为什么age,char1,char2被存到了一组8字节的内存里面了呢？

结论：系统进行了内存优化，重排，类的本质是结构体，引入我们下一个探讨话题

二、结构体中的内存对齐

2.1 C/OC 中各种数据类型的大小

2.2 探究结构体的内存大小

2.2.1 创建两个结构体，并打印它的内存大小

struct GomuStruct1 {
    double a;
    char b;
    int c;
    short d;
} struct1;

struct GomuStruct2 {
    double a;
    int c;
    char b;
    short d;
} struct2;
NSLog(@"%lu - %lu",sizeof(struct1),sizeof(struct2)); 
//: log: 24 - 16

• 为什么只是交换了c，b的位置，结构体的大小就变了，24显然也不是16的倍数，说明结构体字节对齐和对象的字节对齐规则不相同

2.2.2 结构体的内存对齐规则一：

结构体/联合体中，第一个数据成员以offset为0的地方开始，长度为成员大小，结束位置如果是第二个成员大小的整数倍，那么第二个数据成员就以此位置开始，长度为成员大小，若非第二个成员大小的整数倍，往后推移，直到该数字是第二个成员大小的整数倍，作为第二个成员的开始位置，第三个以此内推。

2.2.3 结构体的内存对齐规则二：

结构体的最终大小，也就是sizeof的结果，必须是其内部最大成员大小的整数倍，不足就要补齐。

//: 通过上面规则一计算结构体内存大小，与打印一致
struct GomuStruct1 {
    double a; // 8 (0~7)
    char b;   // 1 （8）[1,8],8是1的整数倍
    int c;    // 4 （12~15）[4,9],9不是4的整数倍，往后推移到 10，11，12
    short d;  // 2 （16~17）[2,16],16是2的整数倍
} struct1;

// 内部需要的大小为：18（0~17）
// 最大属性：a 8字节
// 结构体整数倍：8的整数倍：24（18不足补位）[通过上面规则二得出]

//: 通过上面规则一计算结构体内存大小，与打印一致
struct GomuStruct2 {
    double a; // 8 (0~7)
    int c;    // 4 (8~11),[4,8],8是4的整数倍
    char b;   // 1 (11~12),[1,12],12是1的整数倍
    short d;  // 2 (14~15),[2,13],13不是2的整数倍，往后推移到 14
} struct2;

// 内部需要的大小为：16（0~15）
// 最大属性：a 8字节
// 结构体整数倍：8的整数倍：16（16是8的整数倍）[通过上面规则二得出]

注意：结构体指针的内存大小8字节，而结构体内部的内存大小是根据内部成员来进行开辟的。

2.2.4 结构体的内存对齐规则三：（针对嵌套结构体）

结构体中嵌套结构体，结构体成员要从其内部最大元素大小的整数倍地址开始存储。

struct GomuStruct2 {
    double a; // 8 (0~7)
    int c;    // 4 (8~11),[4,8],8是4的整数倍
    char b;   // 1 (12),[1,12],12是1的整数倍
    short d;  // 2 (14~15),[2,13],13不是2的整数倍，往后推移到 14
} struct2;

struct GomuStruct3 {
    double a; // 8 (0~7)
    int c;    // 4 (8~11),[4,8],8是4的整数倍
    char b;   // 1 (12),[1,12],12是1的整数倍
    short d;  // 2 (14~15),[2,13],13不是2的整数倍，往后推移到 14
    struct GomuStruct2 struct2; // 8 (16,31),[8,16],16是8的整数倍，往后推移到struct2的大小16的位置：31
} struct3; // (0~31) 32，32是最大8的整数倍，所以为32

2.2.5 结构体的内存对齐规则四：（针对嵌套结构体）

如果把结构体成员放在第一位，那它依然遵守结构体内存规则，从offset为0的地方开始

struct GomuStruct2 {
    double a; // 8 (0~7)
    int c;    // 4 (8~11),[4,8],8是4的整数倍
    char b;   // 1 (12),[1,12],12是1的整数倍
    short d;  // 2 (14~15),[2,13],13不是2的整数倍，往后推移到 14
} struct2;

struct GomuStruct3 {
    struct GomuStruct2 struct2; // 8 (0~15)
    char b; // 1 (16)
} struct3; // (0~16) 17，17不是最大8的整数倍，补齐所以为24

2.2.6 结构体的内存对齐规则五：（针对嵌套结构体）

结构体中嵌套结构体，最后结构体的大小不是结构体成员大小的整数倍，而是结构体成员中的成员（即嵌套结构体中的最大成员）的大小/结构体中的最大成员（结构体中除去嵌套结构体的最大成员）的大小的整数倍。如上面，24是struct3 的大小，16是struct2 的大小，24不是16的整数倍，他是struct2中 double a 的大小8的整数倍

2.2.7 根据结构体内存对齐规则画出struct1的内存图如下：

image.png

为什么要这么分配？
以空间换时间，方便读取。

2.2.8 结构体内存读取步骤：

• 以最大成员大小 这里的struct1 是 8 字节为尺度读取，分成三段，0~7，8~15，16~23。
• 然后再在每个尺度中按照该尺度的最大成员去读取，如第一段(0~7)，最大是8，则直接读出a(0~7)，第二段(8~15)，最大是4，读出8~11，12~15，读出c(12~15)。
• 再在8~11中取最大1，则读出b:(8)。
• 以此类推，也可以读出d

三、类的内存开辟规则

3.1 分别打印sizeof,class_getInstanceSize,malloc_size

GomuPerson *person = [GomuPerson alloc];
person.name = @"Gomu";
person.nickName = @"iOS";
NSLog(@"%@ - %lu - %lu - %lu",person,sizeof(person),class_getInstanceSize([GomuPerson class]),malloc_size((__bridge const void *)(person)));
//: <GomuPerson: 0x10050ca10> - 8 - 40 - 48

• sizeof打印的是person这个指针所占的内存大小：8
• class_getInstanceSize打印的是GomuPerson对象所需要的真正内存：40
• malloc_size打印的则是系统给person开辟的内存：48
• 成员变量、方法不占用对象内存。

3.2 class_getInstanceSize中的内存开辟规则

3.2.1 进入objc4-781.2源码，搜索class_getInstanceSize

image.png

3.2.2 进入class_getInstanceSize方法

size_t class_getInstanceSize(Class cls)
{
    if (!cls) return 0;
    return cls->alignedInstanceSize();
}

3.2.3 进入alignedInstanceSize方法

uint32_t alignedInstanceSize() const {
        return word_align(unalignedInstanceSize());
    }

3.2.3 进入word_align方法

#   define WORD_MASK 7UL
static inline uint32_t word_align(uint32_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}
// 举例  x 为 2
// x + WORD_MASK 2 + 7 = 9
// 转换成2进制                      0000 1001
// WORD_MASK = 7 转换成二级制       0000 0111
// ~WORD_MASK                     1111 1000
// (x + WORD_MASK) & ~WORD_MASK
// 0000 1001
// 1111 1000
// 0000 1000 //因为7取反后，后三位肯定是0，与任何值&运算，后三位都为0
// 所以该算法的结果必然是8的倍数

• WORD_MASK这个宏是7。
• (x + WORD_MASK) & ~WORD_MASK 这是一个取8的倍数的算法。
• 对象中真正的对齐方式是8字节对齐。

3.3 alloc初始化三部曲中，第一步cls->instanceSize(extraBytes) 中的内存开辟规则

//: cls->instanceSize(extraBytes)，该方法最终会来到`align16 `方法
//: 该算法在前一篇中已经讲解，这里就不过多赘述
static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

• cls->instanceSize(extraBytes)方法是取16的倍数的一个算法。
• alloc初始化三部曲中，第一步就是上述方法，计算对象的内存空间。
• 系统给对象分配内存的方式是16字节对齐。

3.4 alloc初始化三部曲中，第二步calloc中的内存开辟规则

3.4.1 由符号断点得出，calloc在libsystem_malloc.dylib库中

image.png

3.4.2 由于当前源码在libobjc.A.dylib中，所以我们无法进入源码调试calloc，为了研究calloc，配置了一份libsystem_malloc.dylib的可编译源码

libsystem_malloc可编译源码

3.4.3 开始调式，创建一个calloc对象

void *p = calloc(1, 32); //: 在这里打个断点开始调试

3.4.4 进入calloc(size_t num_items, size_t size)

void *
calloc(size_t num_items, size_t size)
{
    void *retval;
    retval = malloc_zone_calloc(default_zone, num_items, size);
    if (retval == NULL) {
        errno = ENOMEM;
    }
    return retval;
}

• 重点：default_zone，（下回分解）

3.4.5 进入malloc_zone_calloc(default_zone, num_items, size)

void *
malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size)
{
    MALLOC_TRACE(TRACE_calloc | DBG_FUNC_START, (uintptr_t)zone, num_items, size, 0);

    void *ptr;
    if (malloc_check_start && (malloc_check_counter++ >= malloc_check_start)) {
        internal_check();
    }

    ptr = zone->calloc(zone, num_items, size);
    
    if (malloc_logger) {
        malloc_logger(MALLOC_LOG_TYPE_ALLOCATE | MALLOC_LOG_TYPE_HAS_ZONE | MALLOC_LOG_TYPE_CLEARED, (uintptr_t)zone,
                (uintptr_t)(num_items * size), 0, (uintptr_t)ptr, 0);
    }

    MALLOC_TRACE(TRACE_calloc | DBG_FUNC_END, (uintptr_t)zone, num_items, size, (uintptr_t)ptr);
    return ptr;
}

3.4.6 到zone->calloc(zone, num_items, size)这里就没了

image.png

• 当不能再进入的时候，在zone->calloc(zone, num_items, size)处加个断点
  
  image.png
• 执行po zone->calloc，拿到下个流程default_zone_calloc

3.4.7 进入default_zone_calloc

static void *
default_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size)
{
    zone = runtime_default_zone();
    return zone->calloc(zone, num_items, size);
}

• 又出现zone->calloc(zone, num_items, size)，同样的方法我们拿到下一个流程nano_calloc

3.4.8 进入nano_calloc

static void *
nano_calloc(nanozone_t *nanozone, size_t num_items, size_t size)
{
    size_t total_bytes;

    if (calloc_get_size(num_items, size, 0, &total_bytes)) {
        return NULL;
    }

    if (total_bytes <= NANO_MAX_SIZE) {
        void *p = _nano_malloc_check_clear(nanozone, total_bytes, 1);
        if (p) {
            return p;
        } else {
            /* FALLTHROUGH to helper zone */
        }
    }
    malloc_zone_t *zone = (malloc_zone_t *)(nanozone->helper_zone);
    return zone->calloc(zone, 1, total_bytes);
}

• 定位到关键代码void *p = _nano_malloc_check_clear(nanozone, total_bytes, 1);

3.4.9 进入_nano_malloc_check_clear

static void *
_nano_malloc_check_clear(nanozone_t *nanozone, size_t size, boolean_t cleared_requested)
{
    MALLOC_TRACE(TRACE_nano_malloc, (uintptr_t)nanozone, size, cleared_requested, 0);

    void *ptr;
    size_t slot_key;
    size_t slot_bytes = segregated_size_to_fit(nanozone, size, &slot_key); // Note slot_key is set here
    mag_index_t mag_index = nano_mag_index(nanozone);

    nano_meta_admin_t pMeta = &(nanozone->meta_data[mag_index][slot_key]);

    ptr = OSAtomicDequeue(&(pMeta->slot_LIFO), offsetof(struct chained_block_s, next));
    if (ptr) {... 该部分代码省略}else {
        ptr = segregated_next_block(nanozone, pMeta, slot_bytes, mag_index);
    }

    if (cleared_requested && ptr) {
        memset(ptr, 0, slot_bytes); // TODO: Needs a memory barrier after memset to ensure zeroes land first?
    }
    return ptr;
}

• 别忘了我们的目的，探索calloc开辟内存的规则，所以抓住size不放，得到核心方法segregated_size_to_fit

3.4.10 进入核心方法segregated_size_to_fit

#define SHIFT_NANO_QUANTUM      4
#define NANO_REGIME_QUANTA_SIZE (1 << SHIFT_NANO_QUANTUM)   // 16
static MALLOC_INLINE size_t
segregated_size_to_fit(nanozone_t *nanozone, size_t size, size_t *pKey)
{
    size_t k, slot_bytes;

    if (0 == size) {
        size = NANO_REGIME_QUANTA_SIZE; // Historical behavior
    }
    k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM; // round up and shift for number of quanta
    slot_bytes = k << SHIFT_NANO_QUANTUM;                           // multiply by power of two quanta size
    *pKey = k - 1;                                                  // Zero-based!

    return slot_bytes;
}

• SHIFT_NANO_QUANTUM 的值是4
• NANO_REGIME_QUANTA_SIZE (1 << SHIFT_NANO_QUANTUM) 这个的值1往左移4位，即 0000 0001 -> 0001 0000 ，所以他的值是16
• 第一步，如果size为0，给size赋值16
• 第二步，size+NANO_REGIME_QUANTA_SIZE - 1，即 先 + 15 ，然后往右移 4 位
• 第三步，再往左移 4 位

//: 举例：假如 size = 4
//: 4+15 = 21 ,  二进制为：           0001 0101
//: 右移4位：                        0000 0001
//: 做移4位：                        0001 0000 
//: 结果为16
//: 左移4位，再右移4位，即对后4位置0，那得到的结果必然为16的倍数

• 这个算法和(x + size_t(15)) & ~size_t(15)这个作用一样。
• 探索calloc再次说明，开辟内存的时候，系统是以16字节对齐进行开辟。

四、拓展

4.1 sizeof

• sizeof 是一个运算符，并不是一个函数。
• 用于计算参数的类型大小，而不是参数值

int a = 1;
double b = 2.0;
GomuPerson *person = [GomuPerson alloc];
        
NSLog(@"%lu - %lu - %lu",sizeof(a),sizeof(b),sizeof(person));
NSLog(@"%lu - %lu - %lu",sizeof(int),sizeof(double),sizeof(void *));
//: 打印都为 ： 4 - 8 - 8
//: sizeof(a) 等价于 sizeof(int)
//: sizeof(b) 等价于 sizeof(double)
//: sizeof(person)  等价于 sizeof(void *) person 是一个结构体指针

4.2 LLDB 调试常用指令

(lldb) po person
<GomuPerson: 0x10108e740>
(lldb) p person
(GomuPerson *) $24 = 0x000000010108e740
(lldb) x person
0x10108e740: b5 23 00 00 01 80 1d 00 00 00 00 00 00 00 00 00  .#..............
0x10108e750: 10 10 00 00 01 00 00 00 30 10 00 00 01 00 00 00  ........0.......
(lldb) memory read person
0x10108e740: b5 23 00 00 01 80 1d 00 00 00 00 00 00 00 00 00  .#..............
0x10108e750: 10 10 00 00 01 00 00 00 30 10 00 00 01 00 00 00  ........0.......
(lldb) x/4gx person
0x10108e740: 0x001d8001000023b5 0x0000000000000000
0x10108e750: 0x0000000100001010 0x0000000100001030
(lldb) x/4gw person
0x10108e740: 0x000023b5 0x001d8001 0x00000000 0x00000000
(lldb) p/t 15
(int) $29 = 0b00000000000000000000000000001111
(lldb) p/x 15
(int) $30 = 0x0000000f
(lldb) 

• po：打印对象
• p: 打印基本数据类型
• x 和 memory read : 以16进制的方式，打印对象的内存情况
• x/4gx ：以16进制的方式，打印4段8字节的内存地址
• x/4gw ：以16进制的方式，打印4段4字节的内存地址
• p/t : 转换成2进制打印
• p/x : 转换成16进制打印

4.3 double/float 在内存的存储方式

• double/float 会转成16进制存，直接po不出来

//: person.height = 180.1; 给height定义成double
(lldb) x/6gx person
0x10182b960: 0x001d8001000033c5 0x0000001200000000
0x10182b970: 0x0000000100002010 0x0000000100002030
0x10182b980: 0x4066833333333333 0x0000000000000000
(lldb) po 0x4066833333333333
4640540721977439027
(lldb) p/x 180.1
(double) $13 = 0x4066833333333333