内存对齐原理

Study_Min
515 阅读11分钟

iOS 底层原理 文章汇总

在探讨内存对齐原理之前，首先介绍下iOS中获取内存大小的三种方式

获取内存大小的三种方式

获取内存大小的三种方式分别是：

  • sizeof
  • class_getInstanceSize
  • malloc_size

sizeof

  • 1、sizeof是一个操作符，不是函数
  • 2、我们一般用sizeof计算内存大小时，传入的主要对象是数据类型，这个在编译器的编译阶段(即编译时)就会确定大小而不是在运行时确定。
  • 3、sizeof最终得到的结果是该数据类型占用空间的大小

class_getInstanceSize

这个方法在alloc & init & new 源码分析分析时就已经分析了，是runtime提供的api，用于获取类的实例对象所占用的内存大小，并返回具体的字节数，其本质就是获取实例对象中成员变量的内存大小

malloc_size

这个函数是获取系统实际分配的内存大小

可以通过下面代码的输出结果来验证我们上面的结果

image.png

总结

  • sizeof：计算类型占用的内存大小，其中可以放 基本数据类型、对象、指针

    • 对于类似于int这样的基本数据而言，sizeof获取的就是数据类型占用的内存大小，不同的数据类型所占用的内存大小是不一样的
    • 而对于类似于NSObject定义的实例对象而言，其对象类型的本质就是一个结构体（即 struct objc_object）的指针，所以sizeof(objc)打印的是对象objc的指针大小，我们知道一个指针的内存大小是8，所以sizeof(objc) 打印是 8。注意：这里的8字节与isa指针一点关系都没有！！！）。
    • 对于指针而言，sizeof打印的就是8，因为一个指针的内存大小是8，

  • class_getInstanceSize：计算对象实际占用的内存大小，这个需要依据类的属性而变化，如果自定义类没有自定义属性，仅仅只是继承自NSObject，则类的实例对象实际占用的内存大小是8，可以简单理解为8字节对齐。

  • malloc_size：计算对象实际分配的内存大小，这个是由系统完成的，可以从上面的打印结果看出，实际分配的和实际占用的内存大小并不相等，这个问题可以通过alloc & init & new 源码分析中的16字节对齐算法来解释这个问题。

结构体内存对齐

接下来，我们首先定义两个结构体，分别计算他们的内存大小，以此来引入今天的正题：内存对齐原理。

image.png

输出结果如下

image.png

从打印结果我们可以看出一个问题，两个结构体乍一看，没什么区别，其中定义的变量 和 变量类型都是一致的，唯一的区别只是在于定义变量的顺序不一致，那为什么他们做占用的内存大小不相等呢？其实这就是iOS中的内存字节对齐现象

内存对齐规则

每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。在ios中，Xcode默认为#pragma pack(8)，即8字节对齐

一般内存对齐的原则主要有3点，可以回看alloc & init & new中的说明。 可以将内存对齐原则可以理解为以下两点：

  • 【原则一】 数据成员的对齐规则可以理解为min(m, n) 的公式, 其中 m表示当前成员的开始位置, n表示当前成员所需要的位数。如果满足条件 m 整除 n （即 m % n == 0）,  n 从 m 位置开始存储, 反之继续检查 m+1 能否整除 n, 直到可以整除, 从而就确定了当前成员的开始位置。

  • 【原则二】数据成员为结构体：当结构体嵌套了结构体时，作为数据成员的结构体的自身长度作为外部结构体的最大成员的内存大小，比如结构体a嵌套结构体b，b中有char、int、double等，则b的自身长度为8

  • 【原则三】最后结构体的内存大小必须是结构体中最大成员内存大小的整数倍，不足的需要补齐。

验证对齐规则

下表是各种数据类型在ios中的占用内存大小，根据对应类型来计算结构体中内存大小。

2251862-19673aeab7ce44b2.jpg

我们可以通过下图图来说明下为什么两个结构体LGStruct1 & LGStruct2的内存大小打印不一致的情况，如图所示

结构体LGStruct1 未命名文件-4.png

结构体LGStruct2 未命名文件-5.png

结构体LGStruct1 内存大小计算

根据内存对齐规则计算LGStruct1的内存大小，详解过程如下：

  • 变量a：占8个字节，从0开始，此时min（0，7），从0开始，即 0-7 存储 a
  • 变量b：占1个字节，从8开始，此时min（8，1），即 8 存储 b
  • 变量c：占4个字节，从9开始，此时min（9，4），9不能整除4，继续往后移动，直到min（12，4），从12开始，即 12-15 存储 c
  • 变量d：占2个字节，从16开始，此时min(16, 2)，即16-17 存储 d

因此LGStruct1的需要的内存大小为 15字节，而LGStruct1中最大变量的字节数为8，所以 LGStruct1 实际的内存大小必须是 8 的整数倍，17向上取整到24，主要是因为24是8的整数倍，所以 sizeof(LGStruct1) 的结果是 24。

结构体LGStruct2 内存大小计算

根据内存对齐规则计算LGStruct2的内存大小，详解过程如下：

  • 变量a：占8个字节，从0开始，此时min（0，7），从0开始，即 0-7 存储 a。
  • 变量b：占4个字节，从9开始，此时min（8，4），从8开始，即 8-11 存储 b，
  • 变量c：占1个字节，从8开始，此时min（12，1），即 12 存储 c
  • 变量d：占2个字节，从13开始，此时min（13，2），13不能整除2，继续往后移动，直到min（14，2），从14开始，即 14-15 存储 d

因此LGStruct2的需要的内存大小为 15字节，而LGStruct2中最大变量的字节数为8，所以 LGStruct2 实际的内存大小必须是 8 的整数倍，15向上取整到16，主要是因为16是8的整数倍，所以 sizeof(LGStruct2) 的结果是 16

结构体嵌套结构体

上面的两个结构体只是简单的定义数据成员，下面来一个比较复杂的，结构体中嵌套结构体的内存大小计算情况

  • 首先定义一个结构体 LGStruct3，在LGStruct3中嵌套LGStruct1，如下所示

image.png

打印 的结果如下所示

image.png

分析LGStruct3的内存计算
根据内存对齐规则，来一步一步分析LGStruct3内存大小的计算过程

  • 变量a：占8个字节，从0开始，此时min（0，8），即 0-7 存储 a
  • 变量b：占4个字节，从8开始，此时min（8，4），即 8-11 存储 b
  • 变量c：占1个字节，d12开始，此时min(12, 1)，即12 存储 c
  • 变量d：占2个字节，从13开始，此时min（13，2），13不能被2整除，后移即 14-15 存储 d
  • 变量e：占4个字节，从16开始，此时min（16，4），即 16-19 存储 e
  • 结构体成员str：str是一个结构体，根据内存对齐原则二，结构体成员要从其内部最大成员大小的整数倍开始存储，而LGStruct1中最大的成员大小为8，所以str要从8的整数倍开始，当前是从20开始，所以不符合要求，需要往后移动到24，24是8的整数倍，符合内存对齐原则，所以 24-47 存储 str

因此LGStruct3的需要的内存大小为 47字节，而LGStruct3中最大变量为str, 其最大成员内存字节数为8，根据内存对齐原则，所以 LGStruct3 实际的内存大小必须是 8 的整数倍，取整48，正好是8的整数倍，所以 sizeof(LGStruct3) 的结果是 48

内存优化（属性重排）

LGStruct1 通过内存字节对齐原则，增加了9个字节，而LGStruct2通过内存字节对齐原则，只需要补齐一个字节即可满足字节对齐规则，这里得出一个结论结构体内存大小与结构体成员内存大小的顺序有关

  • 如果是结构体中数据成员是根据内存从小到大的顺序定义的，根据内存对齐规则来计算结构体内存大小，需要增加有较大的内存padding即内存占位符，才能满足内存对齐规则，比较浪费内存
  • 如果是结构体中数据成员是根据内存从大到小的顺序定义的，根据内存对齐规则来计算结构体内存大小，我们只需要补齐少量内存padding即可满足堆存对齐规则，这种方式就是苹果中采用的，利用空间换时间，将类中的属性进行重排，来达到优化内存的目的

以下面这个例子来进行说明 苹果中属性重排，即内存优化

  • 定义一个自定义LGPerson类，并定义几个属性，

image.png

  • 在main中创建LGPerson的实例对象，并对其中的几个属性赋值

image.png

  • 断点调试person，根据LGPerson的对象地址，查找出属性的值
  • 通过地址找出 name & nickName

image.png

当我们向通过0x0000001200006261地址找出age等数据时，发现是乱码，这里无法找出值的原因是苹果中针对age、c1、c2属性的内存进行了重排，因为age类型占4个字节，c1和c2类型char分别占1个字节，通过4+1+1的方式，按照8字节对齐，不足补齐的方式存储在同一块内存中，

image.png

下图是LGPerson的内存分布情况

未命名文件-6.png

注意：
1、char类型的数据读取出来是以ASCII码的形式显示
2、图片中地址为0x0000000000000000,表示person中还有属性未赋值

总结

所以，这里可以总结下苹果中的内存对齐思想：

  • 大部分的内存都是通过固定的内存块进行读取
  • 尽管我们在内存中采用了内存对齐的方式，但并不是所有的内存都可以进行浪费的，苹果会自动对属性进行重排，以此来优化内存

字节对齐到底采用多少字节对齐？

到目前为止，我们在前文既提到了8字节对齐，也提及了16字节对齐，那我们到底采用哪种字节对齐呢？

我们可以通过objc4中class_getInstanceSize的源码来进行分析

/** 
 * Returns the size of instances of a class.
 * 
 * @param cls A class object.
 * 
 * @return The size in bytes of instances of the class \e cls, or \c 0 if \e cls is \c Nil.
 */
OBJC_EXPORT size_t
class_getInstanceSize(Class _Nullable cls) 
    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);

⬇️

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

⬇️

// Class's ivar size rounded up to a pointer-size boundary.
uint32_t alignedInstanceSize() const {
    return word_align(unalignedInstanceSize());
}

⬇️

static inline uint32_t word_align(uint32_t x) {
    //x+7 & (~7) --> 8字节对齐
    return (x + WORD_MASK) & ~WORD_MASK;
}


//其中 WORD_MASK 为
#   define WORD_MASK 7UL

通过源码可知：

  • 对于一个对象来说，其真正的对齐方式 是 8字节对齐，8字节对齐已经足够满足对象的需求了
  • apple系统为了防止一切的容错，采用的是16字节对齐的内存，主要是因为采用8字节对齐时，两个对象的内存会紧挨着，显得比较紧凑，而16字节比较宽松，利于苹果以后的扩展。

总结
综合前文提及的获取内存大小的方式

  • class_getInstanceSize：是采用8字节对齐，参照的对象的属性内存大小
  • malloc_size：采用16字节对齐，参照的整个对象的内存大小，对象实际分配的内存大小必须是16的整数倍

内存对齐算法

目前已知的16字节内存对齐算法有两种

  • alloc源码分析中的align16：
  • malloc源码分析中的segregated_size_to_fit

align16： 16字节对齐算法

这个算法的思想已经在alloc & init & new中有所提及

static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

segregated_size_to_fit： 16字节对齐算法

#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;
}

算法原理：k + 15 >> 4 << 4 ，其中 右移4 + 左移4相当于将后4位抹零，跟 k/16 * 16一样 ，是16字节对齐算法，小于16就成0了

以 k = 2为例，如下图所示

2251862-31c989bcdfeb6725.png

avatar
文章
阅读
粉丝