iOS中关于cache_t

之前的文章中，我们分析了Class结构中的isa和class_data_bits_t,今天我们就来分析一下cache_t

cache_t是什么

之前的文章中看到objc_class的内部有个cache_t类型的成员cache,那么他到底是干什么用的呢？今天我们就来探究一下。cache是用来缓存最近调用的方法集合，便于下次读取更加快速高效，提高性能。具体是怎么实现的呢？我们现在看下源码

cache_t的结构

struct cache_t {
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
	//explicit_atomic是将普通指针转换为原子指针的操作，为了线程安全。
    explicit_atomic<struct bucket_t *> _buckets;
    explicit_atomic<mask_t> _mask;
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
    explicit_atomic<uintptr_t> _maskAndBuckets;
    mask_t _mask_unused;
    
    // How much the mask is shifted by.
    static constexpr uintptr_t maskShift = 48;
    
    // Additional bits after the mask which must be zero. msgSend
    // takes advantage of these additional bits to construct the value
    // `mask << 4` from `_maskAndBuckets` in a single instruction.
    static constexpr uintptr_t maskZeroBits = 4;
    
    // The largest mask value we can store.
    static constexpr uintptr_t maxMask = ((uintptr_t)1 << (64 - maskShift)) - 1;
    
    // The mask applied to `_maskAndBuckets` to retrieve the buckets pointer.
    static constexpr uintptr_t bucketsMask = ((uintptr_t)1 << (maskShift - maskZeroBits)) - 1;
    
    // Ensure we have enough bits for the buckets pointer.
    static_assert(bucketsMask >= MACH_VM_MAX_ADDRESS, "Bucket field doesn't have enough bits for arbitrary pointers.");
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
    // _maskAndBuckets stores the mask shift in the low 4 bits, and
    // the buckets pointer in the remainder of the value. The mask
    // shift is the value where (0xffff >> shift) produces the correct
    // mask. This is equal to 16 - log2(cache_size).
    explicit_atomic<uintptr_t> _maskAndBuckets;
    mask_t _mask_unused;

    static constexpr uintptr_t maskBits = 4;
    static constexpr uintptr_t maskMask = (1 << maskBits) - 1;
    static constexpr uintptr_t bucketsMask = ~maskMask;
#else
#error Unknown cache mask storage type.
#endif
    
#if __LP64__
    uint16_t _flags;
#endif
    uint16_t _occupied;

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

    unsigned capacity();
    bool isConstantEmptyCache();
    bool canBeFreed();

#if __LP64__
    bool getBit(uint16_t flags) const {
        return _flags & flags;
    }
    void setBit(uint16_t set) {
        __c11_atomic_fetch_or((_Atomic(uint16_t) *)&_flags, set, __ATOMIC_RELAXED);
    }
    void clearBit(uint16_t clear) {
        __c11_atomic_fetch_and((_Atomic(uint16_t) *)&_flags, ~clear, __ATOMIC_RELAXED);
    }
#endif

#if FAST_CACHE_ALLOC_MASK
    bool hasFastInstanceSize(size_t extra) const
    {
        if (__builtin_constant_p(extra) && extra == 0) {
            return _flags & FAST_CACHE_ALLOC_MASK16;
        }
        return _flags & FAST_CACHE_ALLOC_MASK;
    }

    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);
        }
    }

    void setFastInstanceSize(size_t newSize)
    {
        // Set during realization or construction only. No locking needed.
        uint16_t newBits = _flags & ~FAST_CACHE_ALLOC_MASK;
        uint16_t sizeBits;

        // Adding FAST_CACHE_ALLOC_DELTA16 allows for FAST_CACHE_ALLOC_MASK16
        // to yield the proper 16byte aligned allocation size with a single mask
        sizeBits = word_align(newSize) + FAST_CACHE_ALLOC_DELTA16;
        sizeBits &= FAST_CACHE_ALLOC_MASK;
        if (newSize <= sizeBits) {
            newBits |= sizeBits;
        }
        _flags = newBits;
    }
#else
    bool hasFastInstanceSize(size_t extra) const {
        return false;
    }
    size_t fastInstanceSize(size_t extra) const {
        abort();
    }
    void setFastInstanceSize(size_t extra) {
        // nothing
    }
#endif

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

    void reallocate(mask_t oldCapacity, mask_t newCapacity, bool freeOld);
    void insert(Class cls, SEL sel, IMP imp, id receiver);

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

这里我们看到，里面的代码很多，根据不同的架构代码实现也不同， buckets是一个bucket_t结构体类型的集合，我们看下源码

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__
    explicit_atomic<uintptr_t> _imp;
    explicit_atomic<SEL> _sel;
#else
    explicit_atomic<SEL> _sel;
    explicit_atomic<uintptr_t> _imp;
#endif

    // Compute the ptrauth signing modifier from &_imp, newSel, and cls.
    uintptr_t modifierForSEL(SEL newSel, Class cls) const {
        return (uintptr_t)&_imp ^ (uintptr_t)newSel ^ (uintptr_t)cls;
    }
//省略部分......
public:
    inline SEL sel() const { return _sel.load(memory_order::memory_order_relaxed); }

    inline IMP imp(Class cls) const {
        uintptr_t imp = _imp.load(memory_order::memory_order_relaxed);
        if (!imp) return nil;

//省略部分......
    template <Atomicity, IMPEncoding>
    void set(SEL newSel, IMP newImp, Class cls);
};
}

这里我们看到arm64下和x86下结构体的顺序不一样，但作用都是一样的，我们通过提炼关键信息得到下图 其中cache_t中的含义如下：

• buckets 容器/存储
• mask 面具/掩码
• occupied 已占用的；实际使用中的大小
• capacity 已分配的容量大小

cache_t 的部分方法

• bucket() 获取缓存中所有的sel/imp信息
• capacity() 获取已分配的容量大小
• occupied() 获取已占用的实际大小
• incrementOccupied() 对实际占用空间加1
• reallocate() 开辟内存空间
• insect() 哈希表中插入sel/imp

buckets是一个bucket_t类型结构体，bucket_t中包含sel和imp

实操

接下来我们准备一些案例,首先我们创建一个Person类，如下

@interface Person : NSObject

- (void)sayHello;
- (void)sayHello1;
- (void)sayHello2;
- (void)sayHello3;
- (void)sayHello4;
- (void)sayHello5;

@end

@implementation Person
- (void)sayHello {
    NSLog(@"%s", __func__);
}

- (void)sayHello1 {
    NSLog(@"%s", __func__);
}

- (void)sayHello2 {
    NSLog(@"%s", __func__);
}

- (void)sayHello3 {
    NSLog(@"%s", __func__);
}

- (void)sayHello4 {
    NSLog(@"%s", __func__);
}

- (void)sayHello5 {
    NSLog(@"%s", __func__);
}

@end

main 函数中创建一个Person对象，并调用方法

   Person *person = [Person alloc];
   Class p = [Person class];
   [person sayHello];
   [person sayHello1];
   [person sayHello2];
   [person sayHello3];
   [person sayHello4];
   [person sayHello5];

然后运行程序，在调用方法之前打个断点 接下来我们探索下isa里面cache的奥秘，首先打印person类的地址

(lldb) p/x p

输出结果

(Class) $0 = 0x00000001000021b8 Person

接着通过偏移0x10也就是0x00000001000021c8找到cache

(lldb) p (cache_t *) 0x00000001000021c8

输出结果

(cache_t *) $1 = 0x00000001000021c8

打印下cache_t

(lldb) p *$1

输出结果

(cache_t) $2 = {
  _buckets = {
    std::__1::atomic<bucket_t *> = 0x000000010032e420 {
      _sel = {
        std::__1::atomic<objc_selector *> = (null)
      }
      _imp = {
        std::__1::atomic<unsigned long> = 0
      }
    }
  }
  _mask = {
    std::__1::atomic<unsigned int> = 0
  }
  _flags = 32784
  _occupied = 0
}

这里看到了_buckets、_mask、 _flags、_occupied ，_occupied是0。我们接着往下走一步执行sayHello方法 这个时候我们在打印下$1

(lldb) p *$1

输出结果

(cache_t) $3 = {
  _buckets = {
    std::__1::atomic<bucket_t *> = 0x0000000100692b60 {
      _sel = {
        std::__1::atomic<objc_selector *> = ""
      }
      _imp = {
        std::__1::atomic<unsigned long> = 11496
      }
    }
  }
  _mask = {
    std::__1::atomic<unsigned int> = 3
  }
  _flags = 32784
  _occupied = 1
}

这个时候我们看到 _occupied = 1，我们在调用下buckets方法，获取地址

(lldb) p $3.buckets()

输出结果

(bucket_t *) $4 = 0x0000000100692b60

读取$4 里面内容

(lldb) p *$4

输出结果

(bucket_t) $5 = {
  _sel = {
    std::__1::atomic<objc_selector *> = ""
  }
  _imp = {
    std::__1::atomic<unsigned long> = 11496
  }
}

通过之前的源码获取buckets中的sel

(lldb) p $5.sel()

输出结果

(SEL) $6 = "sayHello"

通过之前的源码获取buckets中的imp，这里需要传一个Person类的地址

(lldb) p $5.imp(p)

输出结果

(IMP) $7 = 0x0000000100000d50 (KCObjc`-[Person sayHello])

这里看到我们之前调用的方法已经缓存到cache中了， 接着上面的步骤，我们再次调用一个方法，这次我们想要获取第二个sel，其调试的lldb如下

(lldb) p *($4+1)

输出结果

(bucket_t) $8 = {
  _sel = {
    std::__1::atomic<objc_selector *> = ""
  }
  _imp = {
    std::__1::atomic<unsigned long> = 11304
  }
}

调用$8的sel和imp

(lldb) p $8.sel()
(SEL) $9 = "say666"
(lldb) p $8.imp(p)
(IMP) $10 = 0x0000000100000d90 (KCObjc`-[Person say666])

依次内推，找到其他的方法缓存,那如何确认我们打印出来的地址就是没有问题的呢，我们可以通过machOView 来验证一下 我们看到这里的say666方法和上面的地址一模一样。那系统底层是如果添加方法到cache里面的呢？我们来看下源码，我们找到cache_t的insert方法源码

#### cache_t源码以及插入流程
ALWAYS_INLINE
void cache_t::insert(Class cls, SEL sel, IMP imp, id receiver)
{
#if CONFIG_USE_CACHE_LOCK
    cacheUpdateLock.assertLocked();
#else
    runtimeLock.assertLocked();
#endif

    ASSERT(sel != 0 && cls->isInitialized());

    // Use the cache as-is if it is less than 3/4 full（当缓存实际使用大小小于3/4时）
    //occupied()默认为0，newOccupied每次+1
    mask_t newOccupied = occupied() + 1;
    unsigned oldCapacity = capacity(), capacity = oldCapacity;
    //slowpath编译器优化，小概率事件。当capacity()=0时，创建缓存
    if (slowpath(isConstantEmptyCache())) {
        // Cache is read-only. Replace it.capacity默认为4.INIT_CACHE_SIZE=（1<<2）
        if (!capacity) capacity = INIT_CACHE_SIZE;
        reallocate(oldCapacity, capacity, /* freeOld */false);
    }
    //小于3/4啥也不做
    else if (fastpath(newOccupied + CACHE_END_MARKER <= capacity / 4 * 3)) {
        // Cache is less than 3/4 full. Use it as-is.
    }
    else {
    //扩容capacity2倍，也就是 4、8、16...
        capacity = capacity ? capacity * 2 : INIT_CACHE_SIZE;
        if (capacity > MAX_CACHE_SIZE) {
            capacity = MAX_CACHE_SIZE;
        }
        //重新开辟一块新的空间，把上面的值传进去
        reallocate(oldCapacity, capacity, true);
    }

    bucket_t *b = buckets();
    mask_t m = capacity - 1;	//mask=capacity - 1
    mask_t begin = cache_hash(sel, m); //通过哈希算法函数计算sel的存储下标
   	//从下标还是往前遍历
    mask_t i = begin;

    // 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.
    do {
    	//如果当前下标没有sel说明当前下标没有存储sel
        if (fastpath(b[i].sel() == 0)) {
       		//occupied+1(实际占用大小)
            incrementOccupied();
            //存储sel/imp
            b[i].set<Atomic, Encoded>(sel, imp, cls);
            return;
        }
        //如果当前下标已经有sel,且等于将要插入sel直接返回
        if (b[i].sel() == sel) {
            // The entry was added to the cache by some other thread
            // before we grabbed the cacheUpdateLock.
            return;
        }
    } while (fastpath((i = cache_next(i, m)) != begin));//如果当前下标已经有sel且不等于将要插入的sel，下标往前一位，重新计划哈希值，得到新的下标

    cache_t::bad_cache(receiver, (SEL)sel, cls);
}

通过上面的源码。我们可以看到插入的时候主要分为几个步骤：

• 计算当前的占用空间

• 开辟空间或扩容

  如果没有开辟空间，开辟一个默认值为4的缓存空间。如果已经开辟过空间。看有没有超出3/4，如果超过3/4，那就重新开辟一个是之前一倍大小的空间，并把之前的赋值过去。把旧的buckets进行释放

• 查找存储位置

  通过哈希算法函数计算sel的哈希值，根据当前的下标查找，如果当前下标没有sel说明当前下标没有存储sel，执行set方法。如果当前下标已经有sel,且等于将要插入sel直接返回。如果当前下标已经有sel且不等于将要插入的sel，下标往前一位，重新计算哈希值，得到新的下标，重复上面的步骤

思考

接下来通过问题看看掌握的程度

1.什么时候存储到cache中？

objc_msgSend第一次发送消息会触发方法查找，找到方法后会调用cache_fill()方法把方法缓存到cache中

2.什么情况下会调用insect()方法？

init初始化对象、
属性get/set方法、
方法调用

3.bucket数据为什么会有丢失的情况？

原因是在扩容时，是将原有的内存全部清除了，再重新申请了内存导致的

4.方法缓存cache_t的方法实现方式?

散列表技术 key-value, 用散列表来缓存曾经调用过的方法，可以提高方法的查找速度

5.mask为什么要capacity - 1

这个数据缓存的位置的下标，也就是缓存方法的索引，这个下标经过位运算之后，一定会小于或者等于散列表的长度-1 ，就不会出现越界的情况了

到这里cache_t的大概原理就已经分析完了，这里没有贴完整的代码和实现，有兴趣可以下载源码自己玩玩。