未来的你，一定会感谢现在拼命的自己
前言
前面的文章我们讨论了类的底层实现和通过内存平移的到来 class_data_bits_t 这个结构，也引出了 cache_t 这个概念。那么今天就来探索一下这个 cache_t 到底是何方神圣。
准备一份如下的源码
@interface CDPerson : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, strong) NSString *nickName;
- (void)say1;
- (void)say2;
- (void)say3;
- (void)say4;
- (void)say5;
- (void)say6;
- (void)say7;
- (void)say8;
- (void)say9;
@end
源码分析&LLDB调试
- 首先我们看看
cache_t的结构体模型。
- cache_t 的成员变量，这个才是真正可以存值的东西
explicit_atomic<uintptr_t> _bucketsAndMaybeMask;
union {
struct {
explicit_atomic<mask_t> _maybeMask;
#if __LP64__
uint16_t _flags;
#endif
uint16_t _occupied;
};
explicit_atomic<preopt_cache_t *> _originalPreoptCache;
};
- 这里定义了各个系统的相关的常量
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
// _bucketsAndMaybeMask is a buckets_t pointer
// _maybeMask is the buckets mask
static constexpr uintptr_t bucketsMask = ~0ul;
// 这里是64 位的macos 或者是模拟器
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16_BIG_ADDRS
static constexpr uintptr_t maskShift = 48;
static constexpr uintptr_t maxMask = ((uintptr_t)1 << (64 - maskShift)) - 1;
static constexpr uintptr_t bucketsMask = ((uintptr_t)1 << maskShift) - 1;
static constexpr uintptr_t preoptBucketsMarker = 1ul;
static constexpr uintptr_t preoptBucketsMask = bucketsMask & ~preoptBucketsMarker;
// 这里是64 位的真机，这里面可以看到很多的 Shift 相关的变量。
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
// _bucketsAndMaybeMask is a buckets_t pointer in the low 48 bits
// _maybeMask is unused, the mask is stored in the top 16 bits.
/// 这里也说明了，_maybeMsk 没有使用，而是存放在高 16 位的。这种存储的方式就和 nonPointerIsa 一样的，通过位域的形式来存储更多的信息，目的就是优化内存。下面一些操作都是去获取 mask。
// 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;
#if CONFIG_USE_PREOPT_CACHES
static constexpr uintptr_t preoptBucketsMarker = 1ul;
#if __has_feature(ptrauth_calls)
// 63..60: hash_mask_shift
// 59..55: hash_shift
// 54.. 1: buckets ptr + auth
// 0: always 1
static constexpr uintptr_t preoptBucketsMask = 0x007ffffffffffffe;
static inline uintptr_t preoptBucketsHashParams(const preopt_cache_t *cache) {
uintptr_t value = (uintptr_t)cache->shift << 55;
// masks have 11 bits but can be 0, so we compute
// the right shift for 0x7fff rather than 0xffff
return value | ((objc::mask16ShiftBits(cache->mask) - 1) << 60);
}
#else
// 63..53: hash_mask
// 52..48: hash_shift
// 47.. 1: buckets ptr
// 0: always 1
static constexpr uintptr_t preoptBucketsMask = 0x0000fffffffffffe;
static inline uintptr_t preoptBucketsHashParams(const preopt_cache_t *cache) {
return (uintptr_t)cache->hash_params << 48;
}
#endif
#endif // CONFIG_USE_PREOPT_CACHES
- 相关的取值方法
unsigned capacity() const;
struct bucket_t *buckets() const;
Class cls() const;
mask_t occupied() const;
void initializeToEmpty();
- 然后再来看看 bucket_t 的结构体数据
#if __arm64__
explicit_atomic<uintptr_t> _imp;
explicit_atomic<SEL> _sel;
#else
explicit_atomic<SEL> _sel;
explicit_atomic<uintptr_t> _imp;
#endif
从数据结构可以知道，我们缓存里面存放的是sel 和 imp。
-
然后我们用LLDB 来看看 cache_t 的具体内存结构
LLDB打印cache_t结构
通过上面的源码我们可以看到里面有一个返回的 bucket_t 的结构体指针的方法 buckets()。
那么我们在打印一下这个
(lldb) p $2.buckets()
(bucket_t *) $3 = 0x00000001003690f0
(lldb) p *$3
(bucket_t) $4 = {
_imp = {
std::__1::atomic<unsigned long> = {
Value = 0
}
}
_sel = {
std::__1::atomic<objc_selector *> = (null) {
Value = nil
}
}
}
从结果可以发现，这里面什么都没有。那么我们运行一个方法后在看结果又是如何。
运行方法后的结果
然后打印具体的 sel 和 imp 也可以知道确实是我们刚才调用的。
(lldb) p $7.sel()
(SEL) $8 = "say1"
(lldb) p $7.imp(NULL, [CDPerson class])
(IMP) $9 = 0x00000001000039cc (CDCachetDemo`-[CDPerson say1])
- 小结：通过上面的流程我们得出了如下的结论
cache_t里面的数据全部缓存在buckets里面；
cache_t缓存的数据是方法，并不换成属性和成员变量；
可以通过内存平移的方法获取到下一个bucket
脱离源码调试
脱离源代码就是在不使用 objc 源代码的情况下调试，因为源代码一般下载下来都是没发遍一遍通过的，需要下载和调试相关的依赖库才可以。但是还是需要借助源代码来分析数据结构的，那么先准备一份如下的源码以便于调试。
typedef uint32_t mask_t; // x86_64 & arm64 asm are less efficient with 16-bits
struct cd_bucket_t {
SEL _sel;
IMP _imp;
};
struct cd_cache_t {
struct cd_bucket_t * _buckets;
mask_t _mask;
uint16_t _flags;
uint16_t _occupied;
};
struct cd_class_data_bits_t {
uintptr_t bits;
};
struct cd_objc_class {
Class ISA;
Class superclass;
struct cd_cache_t cache; // formerly cache pointer and vtable
struct cd_class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
};
然后实现如下的代码
脱离源代码测试
按照这个打印，可以得到如下的结果
看结果： 0x1000085d0 flags = 32804; occupied = 0; mask = 0; sizeof = 8。这里和我们之前的源码调试是一样的，没有任何缓存。-
然后放开61 行的注释，即调用 init 方法，打印的结果如下：
init 的缓存 -
然后单独放开 62 行的注释，级调用属性赋值 (即：setter 方法)，
setter 的缓存 -
然后单独放开 64 行，即调用成员方法。
成员方法的缓存 -
然后放掉 61～64 行的注释，即调用了多个方法：结果如下
调用了多个方法看缓存 -
最后过掉所有的注释，看结果又是如下：
通过上面的调试，我们知道了 init 、setter 、 method 会有缓存。
那么这里带来了几个问题。
_mask是什么？_occupied是什么？- 为什么
mask和occupied一会儿是1 、 3,一会儿又是2 、 7？- 为什么方法的缓存不是从0号位开始的？
- 为什么方法的缓存顺序是不和我调用的顺序一样？
- 为什么我在调用了4个方法后，缓存列表里面只有两个方法（
say1 、 setNickName）？
cache_t 源码分析
这里我们有个疑问，就是缓存是什么时候存进去的呢？发现源码里面有一个 insert方法（void insert(SEL sel, IMP imp, id receiver);）我们看看源码
void cache_t::insert(SEL sel, IMP imp, id receiver)
{
......
// Use the cache as-is if until we exceed our expected fill ratio.
mask_t newOccupied = occupied() + 1;
unsigned oldCapacity = capacity(), capacity = oldCapacity;
if (slowpath(isConstantEmptyCache())) {
// Cache is read-only. Replace it.
if (!capacity) capacity = INIT_CACHE_SIZE;
/// 1. 这里先判断是否是第一次执行，如果是就去开辟内存。
reallocate(oldCapacity, capacity, /* freeOld */false);
}
else if (fastpath(newOccupied + CACHE_END_MARKER <= cache_fill_ratio(capacity))) {
/// 2. 这里表示当前的buckets 的mask 数量大于 occupied，就不用开辟新的内存空间
}
#if CACHE_ALLOW_FULL_UTILIZATION
else if (capacity <= FULL_UTILIZATION_CACHE_SIZE && newOccupied + CACHE_END_MARKER <= capacity) {
// Allow 100% cache utilization for small buckets. Use it as-is.
}
#endif
else {
/// 3. 这里表示要插入的的bucket 没有了空间，需要扩容并且重新开辟新的内存，并且释放掉之前旧的内存空间。
/// 比如，当前有2个缓存，然后当要插入第 3 个缓存的时候，newOccupied = 3，newOccupied + CACHE_END_MARKER <= cache_fill_ratio(capacity) = 3 不成了，所以就会扩容。
/// 至于为什么要释放旧的内存空间，大概是为了优化内存，长时间没用的缓存就释放掉，等下一次调用的时候在重新缓存。
capacity = capacity ? capacity * 2 : INIT_CACHE_SIZE;
if (capacity > MAX_CACHE_SIZE) {
capacity = MAX_CACHE_SIZE; ///这里也限制了，最多可以有 2^16 个缓存
}
reallocate(oldCapacity, capacity, true);
}
bucket_t *b = buckets();
mask_t m = capacity - 1;
mask_t begin = cache_hash(sel, m); /// 采用哈希算法获取当前的bucket 需要存放的位置，
mask_t i = begin;
/// 4. 这里就是插入 bucket 到指定的缓存位置。
do {
if (fastpath(b[i].sel() == 0)) {
/// 如果当前的位置不存在数据，或者为一片空的内存空间，那么就插入这个bucket。并且让 _occupied 自增1。
incrementOccupied();
b[i].set<Atomic, Encoded>(b, sel, imp, cls());
return;
}
if (b[i].sel() == sel) {
/// 如果当前 bucket 里面的sel 和 将要存入的一样，则跳过。
return;
}
/// 这里是循环的终止条件，一直寻找下一个 i 直到找到了最初的位置，即处理hash 冲突
} while (fastpath((i = cache_next(i, m)) != begin));
bad_cache(receiver, (SEL)sel);
#endif // !DEBUG_TASK_THREADS
}
- 然后我们去查看开辟内存的方法：
void cache_t::reallocate(mask_t oldCapacity, mask_t newCapacity, bool freeOld)
{
bucket_t *oldBuckets = buckets();
bucket_t *newBuckets = allocateBuckets(newCapacity);
// 这里开辟新的 buckets。
.....
bucket_t *cache_t::allocateBuckets(mask_t newCapacity)
{
// Allocate one extra bucket to mark the end of the list.
// This can't overflow mask_t because newCapacity is a power of 2.
bucket_t *newBuckets = (bucket_t *)calloc(bytesForCapacity(newCapacity), 1);
// 这里开辟了一段连续的空间，用于存放 ‘newCapacity’ 个 ‘bucket_t’ 结构体。
......
void cache_t::setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask)
{
// ensure other threads see new buckets before new mask
_maybeMask.store(newMask, memory_order_release);
/// 通过这个方法，就重新设置里buckets * 和 maybeMask 这两个数据了
......
///通过这个方法，我们知道开辟的内存为大小为 newCapacity * sizeof(bucket) 的大小（即 16 的倍数），所以获取指定的 bucket_t 都可以通过内存平移的方式去寻找，因为这里开辟的内存是连续的，并且存放 bucket_t 数据。
小结：insert 方法就是缓存的插入事件
1.在这里面会判断当前有没有缓存
buckets如果没有，那么就调用reallocate -> allocateBuckets去开辟新的缓存内存空间；
2.如果有缓存空间并且空间的3/4足够插入当前要缓存的bucket那么就直接通过hash算法寻找对应的缓存下标去缓存对应的数据；
3.如果缓存空间的3/4不足一插入下一个bucket，那么就开辟新的扩容空间并且释放掉之前的空间，把当前的数据插入到指新的空间里面。
到此，我们缓存的插入算是完成了，那上面的疑问也有了答案。
_mask是什么？
_mask是当前缓存可以存放的缓存个数的大小，其值为常量capacity - 1
_occupied是什么？
_occupied是当前缓存的具体个数，比如当只有一个setter(setName)的时候，那么这个_occupied就是1，如果当调用了三个方法后，由于第低三个方法的加上1 大于 4*3/4 ，所以这时候扩容开辟新的内存，存储第三个方法。
- 为什么
mask和occupied一会儿是1 、 3,一会儿又是2 、 7？
由于mask在新的occupied + 1大于capacity *3/4，所以当内存扩容后capacity就变成了 8，mask=capacity - 1所以为7。
- 为什么方法的缓存不是从0号位开始的？
这个也不一定，因为是通过hash算法的得出的结果
- 为什么方法的缓存顺序是不和我调用的顺序一样？
因为是通过hash算法后去到的下标位置，如果有当前算处的位置存在bucket那么会处理hash冲突，计算一个新的下标位置。
- 为什么我在调用了4个方法后，缓存列表里面只有两个方法（
say1 、 setNickName）？
因为扩容后，清除了之前缓存buckets，所以缓存的是扩容后新的方法的调用。
