对象内存对齐

探讨的问题

1.什么是内存对齐?
2.为什么要做内存对齐?
3.结构体内存对齐规则
4.源码内存对齐算法

一.什么是内存对齐?

计算机内存都是以字节为单位划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但是实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数k(通常它为4或8的倍数)，这就是所谓的内存对齐。内存对齐是一种在计算机内存中排列数据（表现为变量的地址）、访问数据（表现为CPU读取数据）的一种方式。
内存对齐包含了两种相互独立又相互关联的部分：基本数据对齐和结构体数据对齐。

二.为什么要做内存对齐?

1.平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

三.结构体内存对齐规则

当我们定义一个 struct 的时候，它在内存中是怎么存储的？占用了多少字节的内存空间呢？

//1、定义两个结构体
struct Mystruct1{
    char a;     //1字节
    double b;   //8字节
    int c;      //4字节
    short d;    //2字节
}Mystruct1;

struct Mystruct2{
    double b;   //8字节
    int c;      //4字节
    short d;    //2字节
    char a;     //1字节
}Mystruct2;

//计算 结构体占用的内存大小
NSLog(@"%lu-%lu",sizeof(Mystruct1),sizeof(Mystruct2));

输出 24-16

从打印结果看出一个问题,结构体中变量相同,只是顺序不同,结果影响结构体占用内存大小,这就是iOS中内存对齐

内存对齐规则

1.数据成员对⻬规则:结构(struct)(或联合(union))的数据成员，第
一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要
从该成员大小或者成员的子成员大小(只要该成员有子成员，比如说是数组，
结构体等)的整数倍开始(比如int为4字节,则要从4的整数倍地址开始存
储。 min(当前开始的位置m,n) m=9 n=4 9 10 11 12
2.结构体作为成员:如果一个结构里有某些结构体成员,则结构体成员要从
其内部最大元素大小的整数倍地址开始存储.(struct a里存有struct b,b
里有char,int ,double等元素,那b应该从8的整数倍开始存储.)
3.收尾工作:结构体的总大小,也就是sizeof的结果,.必须是其内部最大
成员的整数倍.不足的要补⻬。

拿上面的两个结构体举例说明

struct Mystruct1{
    char a;     //1字节 从 0开始 1结束  min(0,1)
    double b;   //8字节 从 1开始 1不能整除8 从8开始 8到15 min(8,8)
    int c;      //4字节 从 16开始 能整除4 16到19
    short d;    //2字节 从 20开始 20能整除2 20到21
}Mystruct1;

最后 Mystruct1 中变量最大字节是8 Mystruct1 0-21 共22字节  22向上取整8的倍数 = 24, sizeof(Mystruct1)=24

struct Mystruct3{
    int a;              //4字节 min（0，4）--- （0，1，2，3）
    struct Mystruct4{  
     //从4开始，存储开始位置必须是最大的整数倍（最大成员为8），min（4，8）不满足, min(8,8)满          足，从8开始存储
        double b;       //8字节 min(8,8)  --- (8,9,10,11,12,13,14,15)
        short c;        //2字节,从16开始,min(6，2) -- （16,17,18）
        char d;          //1字节,从19开始,min(19,1) -- (19)
    }Mystruct4;
}Mystruct3;
 
Mystruct3 内存大小必须是 Mystruct4 中变量最大字节数即8的倍数 Mystruct3 0-19 共20个字节 20向上取整8的倍数=24

打印内存大小方法

sizeof 最终得到的结果是该数据类型占用空间的大小
class_getInstanceSize 获取类的实例对象所占用的内存大小
malloc_size 获取系统实际分配的内存大小

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSObject *objc = [[NSObject alloc] init];
        NSLog(@"objc对象类型占用的内存大小：%lu",sizeof(objc));
        NSLog(@"objc对象实际占用的内存大小：%lu",class_getInstanceSize([objc class]));
        NSLog(@"objc对象实际分配的内存大小：%lu",malloc_size((__bridge const void*)(objc)));
    }
    return 0;
}

打印 8 8 16

内存对齐算法

align16： 16字节对齐算法

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

#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了

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