源码下载

在类结构探索中我们对类在底层的表现形式以及类属性/成员变量/实例对象/方法的存储有了初步的认识，这篇我们来分析一下cache_t。

1、源码跟踪

以下源码来自objc源码的objc-runtime-new.h文件：

struct cache_t {
    struct bucket_t *_buckets;
    mask_t _mask;
    mask_t _occupied;

public:
    struct bucket_t *buckets();
    mask_t mask();
    mask_t occupied();
    void incrementOccupied();
    void setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask);
    void initializeToEmpty();

    mask_t capacity();
    bool isConstantEmptyCache();
    bool canBeFreed();

    static size_t bytesForCapacity(uint32_t cap);
    static struct bucket_t * endMarker(struct bucket_t *b, uint32_t cap);

    void expand();
    void reallocate(mask_t oldCapacity, mask_t newCapacity);
    struct bucket_t * find(cache_key_t key, id receiver);

    static void bad_cache(id receiver, SEL sel, Class isa) __attribute__((noreturn));
};

• 我们来回顾一下方法的普通查找流程：
  1）obj -> isa -> obj的Class对象 -> method_array_t methods -> 对该表进行遍历查找，找到就调用，没找到继续往下走
  2）obj的Class对象 -> superclass父类 -> method_array_t methods -> 对父类的方法列表进行遍历查找，找到就调用，找不到就重复本步骤
  3）找到就调用，没找到就重复流程
  4）直到根类NSObject -> isa -> NSObject的Class对象 -> method_array_t methods
  5）到这里依然没找到就会走各种判断，抛出异常等。

• OC中的方法调用本质上是消息转发，但是每次都去遍历查找是很耗时的操作，这就解释了cache_t存在的意义了。

• cache_t顾名思义是缓存，其底层是通过一个哈希表来实现读取的，调用过的方法会直接从cache_t缓存中读取，大大提升了查找速度。

2、成员分析

_buckets：用来缓存方法的哈希表。
_mask：散列表的长度 - 1 (缓存池的最大容量)
_occupied：表示已经缓存方法的数量。

我们来看一下_buckets的结构：

struct bucket_t {
private:
    // IMP-first is better for arm64e ptrauth and no worse for arm64.
    // SEL-first is better for armv7* and i386 and x86_64.
#if __arm64__
    MethodCacheIMP _imp;
    cache_key_t _key;
#else
    cache_key_t _key;
    MethodCacheIMP _imp;
#endif

public:
    inline cache_key_t key() const { return _key; }
    inline IMP imp() const { return (IMP)_imp; }
    inline void setKey(cache_key_t newKey) { _key = newKey; }
    inline void setImp(IMP newImp) { _imp = newImp; }

    void set(cache_key_t newKey, IMP newImp);
};

以上可以看到bucket_t中有两个属性SEL和IMP，如果把SEL比作目录，那么IMP就是对应的具体页码/内容。

这里SEL保存的是方法编号，IMP中保存了方法地址。实际就是SEL寻找IMP的过程，然后通过IMP找到函数实现。

3、LLDB方式验证

承接上文，如果对lldb打印中有不理解的地方，不妨先去了解一下。

断点在NSLog处：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *person = [[Person alloc] init];
        Class pClass = [Person class];
        [person sayHello];
        NSLog(@"---");
}

先取到cache_t：

(lldb) x/4gx pClass
0x100001308: 0x001d8001000012e1 0x0000000100b36140
0x100001318: 0x0000000101a7a9c0 0x0000000200000003
(lldb) p (cache_t *)0x100001318
(cache_t *) $1 = 0x0000000100001318
(lldb) p *$1
(cache_t) $2 = {
  _buckets = 0x0000000101a7a9c0
  _mask = 3
  _occupied = 2
}

以上可以看到_mask为3，_occupied为2，即散列表的长度为3，且已经缓存方法的数量为2。那我们来挨个取一下，到这里可以看到sayHello以及init方法都已经被缓存了。

(lldb) p $2._buckets
(bucket_t *) $3 = 0x0000000101a7a9c0
(lldb) p $3[1]
(bucket_t) $5 = {
  _key = 4294971009
  _imp = 0x0000000100000c50 (Test`-[Person sayHello] at Person.m:13)
}
(lldb) p $3[2]
(bucket_t) $6 = {
  _key = 4309539970
  _imp = 0x00000001003cc2e0 (libobjc.A.dylib`::-[NSObject init]() at NSObject.mm:2308)
}

接下来我们再增加两个方法[person sayCode]和[person sayNB]再尝试一下看是不是所有的方法都会被缓存？

(lldb) x/4gx pClass
0x1000012e8: 0x001d8001000012c1 0x0000000100b36140
0x1000012f8: 0x0000000101f00510 0x0000000100000007
(lldb) p (cache_t *)0x1000012f8
(cache_t *) $1 = 0x00000001000012f8
(lldb) p *$1
(cache_t) $2 = {
  _buckets = 0x0000000101f00510
  _mask = 7
  _occupied = 1
}

这里就有问题了，_mask为7，但是_occupied为1，按照之前的逻辑，_occupied也应该对应增加才对，那这是为什么呢？

这就需要我们继续跟踪源码来找答案了，在cache_t源码中不知道大家有没有注意到expand()方法，字面意思不难看出是扩展的意思，来点进去看一下源码：

enum {
    INIT_CACHE_SIZE_LOG2 = 2,
    INIT_CACHE_SIZE      = (1 << INIT_CACHE_SIZE_LOG2)
};

void cache_t::expand()
{
    cacheUpdateLock.assertLocked();
    
    uint32_t oldCapacity = capacity();
    uint32_t newCapacity = oldCapacity ? oldCapacity*2 : INIT_CACHE_SIZE;

    if ((uint32_t)(mask_t)newCapacity != newCapacity) {
        // mask overflow - can't grow further
        // fixme this wastes one bit of mask
        newCapacity = oldCapacity;
    }

    reallocate(oldCapacity, newCapacity);
}

三目运算uint32_t newCapacity = oldCapacity ? oldCapacity*2 : INIT_CACHE_SIZE;的意思是如果oldCapacity不存在(值为0)就用INIT_CACHE_SIZE(1<<2的值是4)初始化，如果存在则走oldCapacity*2。

最后调用reallocate ()方法进行缓存大小的重置。

1）缓存策略

接下来是一个上帝视角，缓存的入口是cache_fill_nolock()方法，我们来看一下源码：

static void cache_fill_nolock(Class cls, SEL sel, IMP imp, id receiver)
{
    cacheUpdateLock.assertLocked();

    // Never cache before +initialize is done
    if (!cls->isInitialized()) return;

    // Make sure the entry wasn't added to the cache by some other thread 
    // before we grabbed the cacheUpdateLock.
    if (cache_getImp(cls, sel)) return;

    cache_t *cache = getCache(cls);
    cache_key_t key = getKey(sel);

    // Use the cache as-is if it is less than 3/4 full
    mask_t newOccupied = cache->occupied() + 1;
    mask_t capacity = cache->capacity();
    if (cache->isConstantEmptyCache()) {
        // Cache is read-only. Replace it.
        cache->reallocate(capacity, capacity ?: INIT_CACHE_SIZE);
    }
    else if (newOccupied <= capacity / 4 * 3) {
        // Cache is less than 3/4 full. Use it as-is.
    }
    else {
        // Cache is too full. Expand it.
        cache->expand();
    }

    // Scan for the first unused slot and insert there.
    // There is guaranteed to be an empty slot because the 
    // minimum size is 4 and we resized at 3/4 full.
    bucket_t *bucket = cache->find(key, receiver);
    if (bucket->key() == 0) cache->incrementOccupied();
    bucket->set(key, imp);
}

这段就是缓存策略的核心了，我们来重点分析一下：

• if (!cls->isInitialized()) return;判断类是否被初始化，如果没有就直接return。
• if (cache_getImp(cls, sel)) return;判断当前cls下的sel是否已经被缓存，如果已经缓存则直接return。
• cache_t *cache = getCache(cls);获取cls的方法缓存。
• cache_key_t key = getKey(sel);取到缓存的key。
• mask_t newOccupied = cache->occupied() + 1;旧的占用数加1。
• mask_t capacity = cache->capacity();取出缓存中的容量值。

if分支

 if (cache->isConstantEmptyCache()) {
        // Cache is read-only. Replace it.
        cache->reallocate(capacity, capacity ?: INIT_CACHE_SIZE);
    }

• 如果cache为空，则重新申请缓存内存并覆盖之前的缓存。

else if (newOccupied <= capacity / 4 * 3) {
        // Cache is less than 3/4 full. Use it as-is.
    }

• 如果新的缓存占用小于等于总容量的3/4，则走缓存流程。

else {
        // Cache is too full. Expand it.
        cache->expand();
    }

• 如果以上条件都不满足，则需要进行扩容操作。

到这里cache_fill_nolock方法中的整个缓存策略就走完了，我们说存取通常是一起出现的，有存就有取，那么接下来我们分析find ()缓存查找策略。

2）缓存查找

惯例先看一段源代码

bucket_t * cache_t::find(cache_key_t k, id receiver)
{
    assert(k != 0);

    bucket_t *b = buckets();
    mask_t m = mask();
    mask_t begin = cache_hash(k, m);
    mask_t i = begin;
    do {
        if (b[i].key() == 0  ||  b[i].key() == k) {
            return &b[i];
        }
    } while ((i = cache_next(i, m)) != begin);
    
    // 这一步其实相当于 i = i-1,回到上面do循环里面，相当于查找散列表上一个单元格里面的元素，再次进行key值 k的比较，

    Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
    cache_t::bad_cache(receiver, (SEL)k, cls);
}

• 通过cache_hash函数begin = k & m计算出key值k对应的 index值begin，用来记录查询起始索引。
• 用i从散列表取值，如果取出来的bucket_t的 key = k，则查询成功，返回该bucket_t，
• 如果key = 0，说明在索引i的位置上还没有缓存过方法，同样需要返回该bucket_t，用于中止缓存查询。
• 当i=0时，也就是i指向散列表最首个元素索引的时候重新将mask赋值给i，使其指向散列表最后一个元素，重新开始反向遍历散列表，
• 如果此时还没有找到key对应的bucket_t，或者是空的bucket_t，则循环结束，说明查找失败，调用bad_cache方法。

4、总结

到此我们本篇的内容就结束了，最后来总结一下cache_t的流程：

• 在底层消息发送objc_msgSend过程中，先通过缓存查找imp，如果找到就调用，如果没有就走普通查找流程，找到后进行缓存。
• 在缓存中使用了动态扩容方法，当容量达到最大值的3/4时，进行2倍扩容，扩容时会创建新的buckets来代替旧的buckets，并且旧的buckets会被完全抹除，之后把最近一次临界的imp和sel缓存进来。

以上
如有不当，欢迎指正，感谢。