OC对象原理探索(中)-内存对齐

christopher-gower-m_HRfLhgABo-unsplash.jpg

什么是内存对齐

关于什么是内存对齐，我们通过下面一个例子来看一下

需引入#import #import

    //LMPerson 有两个成员变量：name gendar
    LMPerson *p = [LMPerson alloc];
    p.name = @"LM";
    p.gendar = @"男";
    NSLog(@"person---sizeof-------------%lu",sizeof(p));
    NSLog(@"person---instanceSize-------%lu",class_getInstanceSize([LMPerson class]));
    NSLog(@"person---malloc_size--------%lu",malloc_size((__bridge const void *)p));
    //LMStudent 有三个成员变量 name gendar isAdult
    LMStudent *student = [LMStudent alloc];
    student.name = @"小明";
    student.gendar = @"男";
    student.isAdult = YES;
    NSLog(@"student---sizeof-------------%lu",sizeof(student));
    NSLog(@"student---instanceSize-------%lu",class_getInstanceSize([LMStudent class]));
    NSLog(@"student---malloc_size--------%lu",malloc_size((__bridge const void *)student));

打印信息：

person---sizeof-------------8
person---instanceSize-------24
person---malloc_size--------32
student---sizeof-------------8
student---instanceSize-------32
student---malloc_size--------32

为了更好的看懂打印的结果，我们先了解下sizeof,class_getInstanceSize,malloc_size

sizeof是C/C++中的关键字,它是一个运算符,其作用是取得一个对象(数据类型或者数据对象)的长度(即占用内存的大小,以byte为单位)。
class_getInstanceSize计算对象及成员变量占用的内存空间
malloc_size 系统实际分配的内存大小
基础数据类型占用空间大小：

基础数据类型占用空间大小

我们来分析下打印的结果：

类的本质是一个结构体，这里的p和student就是一个结构体指针，结构体指针的大小是8字节，所以sizeof打印都为8
LMPerson 内有两个成员变量 name gendar 都是NSString类型，NSString类型占用8字节。
LMStudent内有三个成员变量name gendar isAdult,name gendar 为``NSString类型各占8字节，isAdult 为BOOL类型占1字节。
每个类里，苹果都设计包含一个isa,查看源码

typedef struct objc_class *Class;

/// Represents an instance of a class.
struct objc_object {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
};

发现isa是一个结构体指针，占用8个字节
对比我们发现LMStudent比LMPerson多一个BOOL类型的成员变量，内存居然相差了8个字节，说明内部进行了内存对齐，具体是不是这样，我们后面分析class_getInstanceSize探究结果
3.p实际的内存地址是24,为什么系统分配的内存是32呢? 这里malloc_size也进行了内存对齐对齐方式可以看出是16位对齐，具体是不是这样，我们后面分析malloc_size探究结果

在C/C++中，结构是一种复合数据类型，其构成元素既可以是基本数据类型（如int、long、float等）的变量，也可以是一些复合数据类型（如数组、结构、联合等）的数据单元。元素是按照定义顺序一个一个放到内存中去的，但并不是紧密排列的。这就是 内存对齐

为什么要内存对齐

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

内存对齐的规则

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

下面我们通过一个例子来分析结构体占用的实际内存大小

struct LGStruct1 {
    double a;       // 8     double 类型在64位上占8个字节，位置为[0 7]
    char b;         // 1     char 类型在64位上占1个字节 第8位是1的倍数，所以在[8]
    int c;          // 4     int 类型在64位上占4个字节，下面第9，10，11位都不是4的倍数，所以跳过从12位开始存放(9 10 11 [12 13 14 15]
    short d;        // 2     short类型在64位上占2个字节，第16位是2的倍数，所以从16位开始存放位置为 [16 17]，结构体内最大的占8个字节，结构体总大小要为8的倍数，所以结构体的总大小为 24
}struct1;

struct LGStruct2 {
    double a;       // 8    double 类型在64位上占8个字节，位置为[0 7]
    int b;          // 4    int 类型在64位上占4个字节，第8位是4的倍数，从第8位开始存放，位置为[8 9 10 11]
    char c;         // 1    char 类型在64位上占1个字节 第8位是1的倍数，所以位置为[12]
    short d;        // 2     short类型在64位上占2个字节，第13位不是2的倍数，所以从第14位开始存放(13 [14 15]，结构体内最大的占8个字节，结构体总大小要为8的倍数，所以结构体的总大小为 16
}struct2;
struct LGStruct3 {
    double a;      // 8    double 类型在64位上占8个字节，位置为[0 7]
    int b;            // 4    int 类型在64位上占4个字节，第8位是4的倍数，从第8位开始存放，位置为[8 9 10 11]
    char c;         // 1    char 类型在64位上占1个字节 第8位是1的倍数，所以位置为[12]
    short d;       // 2     short类型在64位上占2个字节，第13位不是2的倍数，所以从第14位开始存放(13 [14 15]
    int e;           //4     int 类型在64位上占4个字节，第16位是4的倍数，所以从第16位开始存放[16 17 18 19]
    struct LGStruct1 str;    //24   上面已经分析 LGStruct1 实际占用24，  第20位不是24的倍数，所以 从 24位开始 （20 21 22 23 [24...47]  结构体str内最大的占8个字节，结构体总大小要为8的倍数，所以结构体的总大小为 48
}struct3;
struct LGStruct4 {
    float a;   //4   [0 1 2 3]
    double b;  //8   (4 5 6 7 [8 9 10 11 12 13 14 15]
    int c;     //4   [16 17 18 19]
    char d;    //1   [20]
    struct LGStruct1 str1; // 24 (21 22 23 [24....47]
    struct LGStruct2 str2;  //16 [48 ...63]  64
}struct4;

打印验证一下：

NSLog(@"%lu-%lu-%lu",sizeof(struct1),sizeof(struct2),sizeof(struct3));

24-16-48

趁热打铁再分析几个：

struct LGStruct5 {
    float a;   //4   [0 1 2 3]
    double b;  //8   (4 5 6 7 [8 9 10 11 12 13 14 15]
    int c;     //4   [16 17 18 19]
    char d;    //1   [20]
    struct LGStruct2 str2;  //16 (21 ...[24.. 39]
    struct LGStruct1 str1;  //24 [40...63]   64
}struct5;
struct LGStruct6 {
    float a;   //4   [0 1 2 3]
    double b;  //8   (4 5 6 7 [8 9 10 11 12 13 14 15]
    int c;     //4   [16 17 18 19]
    char d;    //1   [20]
    struct LGStruct2 str2;  //16 (21 ...[24.. 39]
    short e;   //2   [40 41]
    struct LGStruct1 str1;  //24 [48...71]   72
}struct6;

class_getInstanceSize 源码分析

我们分下class_getInstanceSize源码确认是做了8字节对齐

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

走到alignedInstanceSize方法内

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

static inline size_t word_align(size_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}
//64位下
#   define WORD_MASK 7UL
比如 x=4 
4+7=13
0000 1101
7
0000 0111
~7
1111 1000
13 & ~7   0000 1101 & 1111 1000
= 0000 1000  即8

所以最终 class_getInstanceSize 以8字节对齐

`malloc_size` 源码分析

首先我们点击 malloc_size 发现源码在libmalloc，编译：

malloc_size

#import 
#import 

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //申请开辟40字节内存,系统最终开辟48字节
        void *p = calloc(1, 40);
        NSLog(@"系统分配的内存空间---%lu",malloc_size(p));
        //打印//系统分配的内存空间---48
    }
    return 0;
}

malloc_size是获取系统分配的内存大小 calloc是系统开辟内存,所以malloc_size底层流程其实是calloc
所以我们探究下calloc都做了什么

void *
calloc(size_t num_items, size_t size)
{
    return _malloc_zone_calloc(default_zone, num_items, size, MZ_POSIX);
}

static void *
_malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size,
        malloc_zone_options_t mzo)
{
    MALLOC_TRACE(TRACE_calloc | DBG_FUNC_START, (uintptr_t)zone, num_items, size, 0);

    void *ptr;
    if (malloc_check_start) {
        internal_check();
    }
//我们看到 return ptr;所以断定下面这行是关键代码
    ptr = zone->calloc(zone, num_items, size);

    if (os_unlikely(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);
    if (os_unlikely(ptr == NULL)) {
        malloc_set_errno_fast(mzo, ENOMEM);
    }
    return ptr;
}

到这里我们发现zone->calloc点不进去了，怎么办呢，我们可以采用之前查看汇编的方法：打断点然后Debug->Debug Workflow -> Always show Disassembly:

断点

zone->calloc所在位置

我们也可以使用LLDB打印的方法：

zone->calloc所在位置

我们接着看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);
}

这里同样可以通过汇编或者打印看下一步执行的步骤：

default_zone_calloc

nano_calloc

_nano_malloc_check_clear

因为我们只关心内存的变化，这里注意size_t 有一个segregated_size_to_fit操作。segregated_size_to_fit做了什么呢？我们接着往下看：

#define SHIFT_NANO_QUANTUM      4
#define NANO_REGIME_QUANTA_SIZE (1 << SHIFT_NANO_QUANTUM)   // 16

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  16
    }
    k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM; // round up and shift for number of quanta
    //k = (40 + 16 -1) >> 4
    slot_bytes = k << SHIFT_NANO_QUANTUM;                           // multiply by power of two quanta size
    //slot_bytes = (40 + 16 -1) >> 4 << 4
    *pKey = k - 1;                                                  // Zero-based!

    return slot_bytes;
}

经过对齐算法，按照16字节对齐之后40字节按48字节开辟空间

总结

内存对齐规则

数据成员对齐规则：从该成员大小或者成员的子成员大小整数倍开始。
结构体作为成员对齐规则：结构体成员要从其内部最大元素大小的整数倍地址开始存储。
结构体的总大小,也就是sizeof的结果,.必须是其内部最大成员的整数倍.不足的要补⻬。

内存对齐原因

提高cpu存取效率，保证数据读取安全

常见对齐

堆上的对象内存以16字节对齐
对象的成员变量内存以8字节对齐
对象与对象之间内存以16字节对齐