alloc底层原理探索

准备工作

下载 objc4-781 源码，选择mac电脑进行编译。

编译源码，可参考iOS-底层原理 03：objc4-781 源码编译 & 调试。

alloc 源码探索

整体的源码流程探索如下：

image

首先我们用xcode运行项目，建立好相关的符号断点。

image

【第一步】根据main函数的XXPersion类的alloc方法进入具体源码的实现。

//alloc源码分析

+(id)alloc{return_objc_rootAlloc(self);}

【第二步】跳进return_objc_rootAlloc()方法查看源码实现。

//cls就是上面说的XXPersion类
id _objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
//注意第一次会进入这个方法，调用callAlloc
id objc_alloc(Class cls)
{
    return callAlloc(cls, true/*checkNil*/, false/*allocWithZone*/);
}

【第三步】跳进callAlloc方法查看源码实现。

 重磅提示 这里是核心方法
static ALWAYS_INLINE id callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
    if (slowpath(checkNil && !cls)) return nil;
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {
        return _objc_rootAllocWithZone(cls, nil);
    }
#endif
    if (allocWithZone) {
        return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
    }
    return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}

注意：经过调试发现先走objc_msgSend方法，向XXPersion类发送alloc消息然后走到了第一步alloc方法，然后执行_objc_rootAlloc方法，最后进入_objc_rootAllocWithZone方法。那么为什么这样子走两次呢？带着疑问往下走，哈哈~~~~

//第二次进入，调起`callAlloc`方法，走到第三部的流程。
id _objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

slowpath & fastpath
其中关于是slowpath和fastpath这里需要简要说明下，这两个都是objc源码中定义的宏，其定义如下:

//x很可能为真， fastpath 可以简称为 真值判断
#define fastpath(x) (__builtin_expect(bool(x), 1)) 
//x很可能为假，slowpath 可以简称为 假值判断
#define slowpath(x) (__builtin_expect(bool(x), 0)) 

其中的__builtin_expect指令是由gcc引入的，
1、目的：编译器可以对代码进行优化，以减少指令跳转带来的性能下降。即性能优化
2、作用：允许程序员将最有可能执行的分支告诉编译器。
3、指令的写法为：__builtin_expect(EXP, N)。表示 EXP==N的概率很大。
4、fastpath定义中__builtin_expect((x),1)表示x的值为真的可能性更大；即 执行if 里面语句的机会更大
5、slowpath定义中的__builtin_expect((x),0)表示 x 的值为假的可能性更大。即执行else 里面语句的机会更大
6、在日常的开发中，也可以通过设置来优化编译器，达到性能优化的目的，设置的路径为：Build Setting --> Optimization Level --> Debug --> 将None 改为 fastest 或者 smallest

cls->ISA()->hasCustomAWZ()

其中fastpath中的 cls->ISA()->hasCustomAWZ() 表示判断一个类是否有自定义的 +allocWithZone 实现，这里通过断点调试，是没有自定义的实现，所以会执行到 if 里面的代码，即走到_objc_rootAllocWithZone。
【第四步】进入_objc_rootAllocWithZone方法，其源码实现如下：

id _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
    // allocWithZone under __OBJC2__ ignores the zone parameter
    //zone 参数不再使用 类创建实例内存空间
    return _class_createInstanceFromZone(cls, 0, nil,
                                         OBJECT_CONSTRUCT_CALL_BADALLOC);
}

【第五步】进入_class_createInstanceFromZone方法，这是alloc源码的核心操作，大致可以分为一下的三部分：

• cls->instanceSize：计算需要开辟的内存空间大小
• calloc：申请内存，返回地址指针
• obj->initInstanceIsa：将 类 与 isa 关联

static ALWAYS_INLINE id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
                              int construct_flags = OBJECT_CONSTRUCT_NONE,
                              bool cxxConstruct = true,
                              size_t *outAllocatedSize = nil)// alloc 源码 第五步
{
    ASSERT(cls->isRealized()); //检查是否已经实现

    // Read class's info bits all at once for performance
    //一次性读取类的位信息以提高性能
    bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocNonpointer();
    size_t size;

    //计算需要开辟的内存大小，传入的extraBytes 为 0
    size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        //申请内存
        obj = (id)calloc(1, size);
    }
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }
    if (!zone && fast) {
        //将 cls类 与 obj指针（即isa） 关联
        obj->initInstanceIsa(cls, hasCxxDtor);
    } else {
        // Use raw pointer isa on the assumption that they might be
        // doing something weird with the zone or RR.
        obj->initIsa(cls);
    }

    if (fastpath(!hasCxxCtor)) {
        return obj;
    }

    construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
    return object_cxxConstructFromClass(obj, cls, construct_flags)

根据以上的源码分析，得出以下的流程图

image.png

重点：calloc方法

cls->instanceSize：计算所需内存大小
开辟内存大小过程如下：

image.png
如果fastpath为true，跳转到instanceSize方法：

ize_t instanceSize(size_t extraBytes) const {
    //编译器快速计算内存大小
    if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
        return cache.fastInstanceSize(extraBytes);
    }
    // 计算类中所有属性的大小 + 额外的字节数0
    size_t size = alignedInstanceSize() + extraBytes;
    // CF requires all objects be at least 16 bytes.
    //如果size 小于 16，最小取16
    if (size < 16) size = 16;
    return size;
}

然后跳转到fastInstanceSize，源码实现：

size_t fastInstanceSize(size_t extra) const
{
    ASSERT(hasFastInstanceSize(extra));
    //Gcc的内建函数 __builtin_constant_p 用于判断一个值是否为编译时常数，如果参数EXP 的值是常数，函数返回 1，否则返回 0
    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
        //删除由setFastInstanceSize添加的FAST_CACHE_ALLOC_DELTA16 8个字节
        return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
    }
}

然后跳转到alight16，这是一个16进制对齐的算法，源码如下：

//16字节对齐算法
static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

内存对齐规则

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

1.数据成员对齐规则：struct 或 union （以下统称结构体）的数据成员，第一个数据成员A放在偏移为 0 的地方，以后每个数据成员B的偏移为(#pragma pack(指定的数n) 与 该数据成员（也就是 B）的自身长度中较小那个数的整数倍，不够整数倍的补齐。

2.数据成员为结构体：如果结构体的数据成员还为结构体，则该数据成员的“自身长度”为其内部最大元素的大小。(struct a 里存有 struct b，b 里有char,int,double等元素，那 b “自身长度”为 8)

3.结构体的整体对齐规则：在数据成员按照上述第一步完成各自对齐之后，结构体本身也要进行对齐。对齐会将结构体的大小调整为(#pragma pack(指定的数n) 与 结构体中的最大长度的数据成员中较小那个的整数倍，不够的补齐。

为什么要进行16字节对齐

• 通常内存是由一个个字节组成的，cpu在存取数据时，并不是以字节为单位存储，而是以块为单位存取，块的大小为内存存取力度。频繁存取字节未对齐的数据，会极大降低cpu的性能，所以可以通过减少存取次数来降低cpu的开销
• 16字节对齐，是由于在一个对象中，第一个属性isa占8字节，当然一个对象肯定还有其他属性，当无属性时，会预留8字节，即16字节对齐，如果不预留，相当于这个对象的isa和其他对象的isa紧挨着，容易造成访问混乱
• 16字节对齐后，可以加快CPU读取速度，同时使访问更安全，不会产生访问混乱的情况。
  16字节对齐算法的计算过程
  image.png
• 首先将原始的内存 8 与size_t(15)相加，得到 8 + 15 = 23
• 将 size_t(15) 即 15进行~（取反）操作，~（取反）的规则是：1变为0，0变为1
• 最后将 23 与 15的取反结果 进行 &（与）操作，&（与）的规则是：都是1为1，反之为0，最后的结果为 16，即内存的大小是以16的倍数增加的
  calloc：申请内存，返回地址指针
  通过instanceSIze计算内存的大小，向内存申请为size大小的内存，拿到赋值给obj，obj是指向内存地址的指针。

obj = (id)calloc(1, size);

注意：未执行calloc时候obj返回的是nil，执行完calloc之后返回一个16进制的地址。在平时开发中，一个对象的打印的格式都是类似于这样的<XXPerson: 0x01111111f>（是一个指针）,而obj打印的是一个地址，只要是因为还没有传入cls的关联，同时印证了alloc的根本作用就是开辟内存。
obj->initInstanceIsa：类与isa关联
当calloc完成之后，内存空间就申请好了。然后就进行isa的关联，流程图如下：

image.png
这个过程主要是初始化一个isa指针，并将isa指针指向申请的内存地址，将指针与cls（XXPersion类）进行关联。

总结

• 通过对alloc源码的系统学习，可以知道alloc主要目的就是开辟内存，开辟内存需要16字节对齐算法，开辟的内存大小基本上都是16的整数倍。
• 开辟内存的核心步骤：计算------申请------关联。

上面的疑点：为什么第三步会走两次

通过llvm源码得知在编译的过程中，alloc方法被hook成上面说的objc_alloc方法，这样做的目的就是标记一个receiver，在标记完这个类为receiver之后都会进入普通的消息发送判断（即第二次进入的alloc方法），这样做的目的其实就是间接符号的绑定。