内存对齐

知识点概要

OC对象内存对齐
结构体内存对齐

OC对象内存对齐

计算内存大小的三种方式

1.sizeof：系统提供的一个操作符，传入类型，计算该类型所占用的内存大小
2.class_getInstanceSize：运行时API，计算实际占用的内存大小。低层实际调用函数如下：

#ifdef __LP64__
#   define WORD_SHIFT 3UL
#   define WORD_MASK 7UL
#   define WORD_BITS 64
#else
#   define WORD_SHIFT 2UL
#   define WORD_MASK 3UL
#   define WORD_BITS 32

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) {
    return (x + WORD_MASK) & ~WORD_MASK;
}

通过word_align可以看到，其内部是按照8字节对齐的。

3.malloc_size：系统实际分配的内存大小，按照16字节对齐

获取大小的例子

@interface Person : NSObject
//isa                                        8
@property (nonatomic, copy) NSString *name;//8
@property (nonatomic, copy) NSString *nickName;//8
@property (nonatomic, assign) int age;//8
@property (nonatomic, assign) long height;//8

@end

Person *person = [Person alloc];
person.name      = @"www";
person.nickName  = @"kkk";
NSLog(@"%@ - %lu - %lu - %lu",person,sizeof(person),class_getInstanceSize([Person class]),malloc_size((__bridge const void *)(person)));

输出结果：<Person: 0x100468c00> - 8 - 40 - 48

没有属性的对象内存大小

没有属性的对象，会默认有isa，占8字节，但是为啥结果是16呢？我们看代码分析：

size_t instanceSize(size_t extraBytes) const {
    if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
        //代码会走到这里
        return cache.fastInstanceSize(extraBytes);
    }

    size_t size = alignedInstanceSize() + extraBytes;
    // CF requires all objects be at least 16 bytes.
    if (size < 16) size = 16;
        return size;
}

size_t fastInstanceSize(size_t extra) const
{
    ASSERT(hasFastInstanceSize(extra));

    if (__builtin_constant_p(extra) && extra == 0) {
        return _flags & FAST_CACHE_ALLOC_MASK16;
    } else {
        size_t size = _flags & FAST_CACHE_ALLOC_MASK;
        // remove the FAST_CACHE_ALLOC_DELTA16 that was added
        // by setFastInstanceSize
       return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
    }
}

static inline size_t align16(size_t x) {
    //可以看到，进行16字节对齐
    return (x + size_t(15)) & ~size_t(15);
}

结论：一个没有属性的对象占用16字节，原因是在开辟内存空间时，进行了16字节对齐

一会是8字节对齐，一会是16字节对齐，到底是多少字节对齐

1.从对象实际占用内存大小来看，实际是按照8字节对齐。所以，一个对象按照8字节对齐是够的
2.8字节对齐，是的对象一个挨着一个，非常紧促，访问时，很容易越界。所以，分配内存时，进行了16字节对齐，预留了一些空间。这样，访问不易越界，同时，便于后期扩展。

结论：分配的内存是按照16字节对齐，实际占用的内存按照8字节对齐

结构体内存对齐

结构体内存对齐规则

：struct 或者 union 的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如数据、结构体等）的整数倍开始（例如int在32位机中是4字节，则要从4的整数倍地址开始存储）
：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（例如：struct a里面存有struct b，b里面有char、int、double等元素，则b应该从8的整数倍开始存储）
：结构体的总大小，即sizeof的结果，必须是其内部做大成员的整数倍，不足的要补齐

普通结构体内存对齐

有了规则，就好办了，接下来进行验证，首先，看看各种类型占用内存的大小：

不同类型占用大小.png

进行代码验证

struct Struct1 {
    double a;   // 8，需要8字节，按照规则：(0-7)
    char b;     // 1，第8个位置是该成员的整数倍： (8)
    int c;      // 4，第9个位置不是该成员的整数倍，往后找到是给成员大小整数倍的位置： (12 13 14 15)
    short d;    // 2，16是2的整数倍： (16 17)
}struct1;
//根据规则：结构体的总大小，必须是其内部做大成员的整数倍。struct1实际大小是17字节，最大成员是8字节，必须是8的倍数。所以，结构体struct1的大小是24。

struct Struct2 {
    double a;   //8， (0-7)
    int b;      //4，(8 9 10 11)
    char c;     //1，(12)
    short d;    //2，(14 15)
}struct2;

//根据规则：结构体的总大小，必须是其内部做大成员的整数倍。struct2实际大小是15字节，最大成员是8字节，必须是8的倍数。所以，结构体struct2的大小是16。

//验证
int main(int argc, char * argv[]) {
    NSLog(@"%lu-%lu",sizeof(struct1),sizeof(struct2));
}

输出结果：

结构体内存对齐结果.png

总结：定义结构体成员，从大到小依次定义，可以达到减小内存空间的效果

结构体嵌套内存对齐

struct Struct1 {
    double a;   // 8，需要8字节，按照规则：(0-7)
    char b;     // 1，第8个位置是该成员的整数倍： (8)
    int c;      // 4，第9个位置不是该成员的整数倍，往后找到是给成员大小整数倍的位置： (12 13 14 15)
    short d;    // 2，16是2的整数倍： (16 17)
}struct1;

//有之前的验证，struct1大小是24.

struct Struct2 {
    double a;   //8， (0-7)
    int b;      //4，(8 9 10 11)
    char c;     //1，(12)
    short d;    //2，(14 15)
    struct Struct1 s1; //24，s1中最大成员是占用8字节。所以，存储位置必须是8的倍数，第16个位置刚好是8的倍数：（16-39）
}struct2;
//根据规则：结构体的总大小，必须是其内部做大成员的整数倍。struct2实际大小是39字节，最大成员是8字节，必须是8的倍数。所以，结构体struct2的大小是40。

//验证：
int main(int argc, char * argv[]) {
    NSLog(@"%lu-%lu",sizeof(struct1),sizeof(struct2));
}

验证结果截图：

image.png

内存优化

在这之前得到一个结论，就是按照从大到小一次定义成员，会减少内存的占用。那么，在OC对象中，我们随意定义属性，是按照我们定义的顺序存储的吗？不一定，在编译期，苹果会帮我们进行重排。

@interface Person : NSObject
@property(nonatomic,copy)NSString *name;
@property(nonatomic, assign)NSInteger age;
@property(nonatomic,copy)NSString *add;
@property(nonatomic, assign)NSInteger height;
@end
//此时是顺序排列，因为每一个都占8字节

image.png

换一种方式：

@interface Person : NSObject
@property(nonatomic,copy)NSString *name;
@property(nonatomic, assign)int age;
@property(nonatomic,copy)NSString *add;
@property(nonatomic, assign)int height;
@end

image.png

我们发现age和height放在了一起，存储在紧挨isa的位置，为什么？因为，苹果进行了重排，连个各占4字节，内部是按照8字节为一个存储块，刚好可以放下age和height，节省了空间