前言
这篇文章主要是分析cache_t流程。通过源码探索下类的cache_t主要缓存了哪些信息，又是怎么缓存的。
分析环境：arm64 构架，iPhone 真机 编译环境下。
cache的存储内容
我们先来看下cache_t的源码
struct cache_t {
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED//macOS、模拟器 -- 主要是架构区分
// explicit_atomic 显示原子性，目的是为了能够 保证 增删改查时 线程的安全性
//等价于 struct bucket_t * _buckets;
//_buckets 中放的是 sel imp
//_buckets的读取 有提供相应名称的方法 buckets()
explicit_atomic<struct bucket_t *> _buckets;
explicit_atomic<mask_t> _mask;
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16 //64位真机
explicit_atomic<uintptr_t> _maskAndBuckets;//写在一起的目的是为了优化
mask_t _mask_unused;
//以下都是掩码，即mask -- 类似于isa的掩码，即位域
// 掩码省略....
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4 //非64位 真机
explicit_atomic<uintptr_t> _maskAndBuckets;
mask_t _mask_unused;
//以下都是掩码，即mask -- 类似于isa的掩码，即位域
// 掩码省略....
#else
#error Unknown cache mask storage type.
#endif
#if __LP64__
uint16_t _flags;
#endif
uint16_t _occupied;
public: //对外公开可以调用的方法
static bucket_t *emptyBuckets(); // 清空buckets
struct bucket_t *buckets(); //这个方法的实现很简单就是_buckets对外的一个获取函数
mask_t mask(); //获取缓存容量_mask
mask_t occupied(); //获取已经占用的缓存个数_occupied
void incrementOccupied(); //增加缓存，_occupied自++
void setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask); //这个函数是设置一个新的Buckets
void initializeToEmpty();
unsigned capacity();
bool isConstantEmptyCache();
bool canBeFreed();
}
我们再来看下bucket_t的源码实现
struct bucket_t {
private:
#if __arm64__ //真机
//explicit_atomic 是加了原子性的保护
explicit_atomic<uintptr_t> _imp;
explicit_atomic<SEL> _sel;
#else //非真机
explicit_atomic<SEL> _sel;
explicit_atomic<uintptr_t> _imp;
#endif
//方法等其他部分省略
}
通过源码分析可知，cache中缓存的是sel-imp，也就是方法索引和方法实现。
通过例子分析cache的缓存内容
准备工作，定义一个WJPerson类，然后添加一下方法和属性
@interface WJPerson : NSObject
{
NSString *habby;
}
@property (nonatomic, copy) NSString *name;
- (void)sayHello;
- (void)sayHowAreYou;
- (void)sayIamFine;
- (void)sayThanksYou;
- (void)sayAndYou;
+ (void)sayGoodbye;
@end
@implementation WJPerson
- (void)sayHello{
NSLog(@"%s",__func__);
}
- (void)sayHowAreYou{
NSLog(@"%s",__func__);
}
- (void)sayIamFine{
NSLog(@"%s",__func__);
}
- (void)sayThanksYou{
NSLog(@"%s",__func__);
}
- (void)sayAndYou{
NSLog(@"%s",__func__);
}
+ (void)sayGoodbye{
NSLog(@"%s",__func__);
}
@end
然后在main.m中创建一个对象，并调用方法打好断点，然后运行启动。
main.m内的实现及断点位置
lldb调试
哎，不对啊，我们还没有调用自定义方法呢，这里怎么就有sel和imp了呢。有的同学会说是init，到底是不是呢，接下来我们验证一下。
buckets中的第一个方法
可以看到这里确实是init方法。接下来我们走的第二个断点，看下接下来的数据。我们再执行下上面的步骤
第二个断点lldb调试
居然没有数据了，这是什么情况？？？刚才不还有一个init方法吗。是不是不在第一个位置啊，我们再看一下buckets中的其他元素。
buckets其他元素
可以看到确实有的元素是有值的，为什么会这样呢，但是通过lldb这样找太麻烦了，有没有一种更简单的方式。接下来我们通过更简单的方式来看一下。
typedef uint32_t mask_t; // x86_64 & arm64 asm are less efficient with 16-bits
struct wj_bucket_t {
SEL _sel;
IMP _imp;
};
struct wj_cache_t {
struct wj_bucket_t * _buckets;
mask_t _mask;
uint16_t _flags;
uint16_t _occupied;
};
struct wj_class_data_bits_t {
uintptr_t bits;
};
struct wj_objc_class {
Class ISA;
Class superclass;
struct wj_cache_t cache; // formerly cache pointer and vtable
struct wj_class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
};
int main(int argc, const char * argv[]) {
@autoreleasepool {
WJPerson *person = [[WJPerson alloc] init];
Class personClass = [person class];
[person sayHello];
// [person sayHowAreYou];
// [person sayIamFine];
// [person sayThanksYou];
// [person sayAndYou];
[personClass sayGoodbye];
struct wj_objc_class *wj_pClass = (__bridge struct wj_objc_class *)(personClass);
NSLog(@"%hu - %u",wj_pClass->cache._occupied,wj_pClass->cache._mask);
for (mask_t i = 0; i<wj_pClass->cache._mask; i++) {
// 打印获取的 bucket
struct wj_bucket_t bucket = wj_pClass->cache._buckets[i];
NSLog(@"%@ - %p",NSStringFromSelector(bucket._sel),bucket._imp);
}
NSLog(@"%@", personClass);
}
return 0;
}
我们把cache_t相关的源码拷贝过来，加工成我们自己的wj_cache_t，然后通过我们自己的wj_cache_t看一下缓存结果。
首先我们只调用其中一个方法，看下打印结果
打印结果1
然后我们调用两个的方法，再看下打印结果
打印结果2
最后我们调用一下全部的方法，再看下打印结果
打印结果3
针对上面的打印结果，有以下几点疑问
-
occupied和mask是什么，又是怎么变化的呢。 - 为什么会出现有的方法没有打印的情况呢。
- 为什么
buckets中方法的顺序和我们的调用顺序不一致呢。
接下来我们分析下cache_t的源码
cache_t源码分析
cache_t方法
查看cache_t结构，发现public方法处，有incrementOccupied函数和setBucketsAndMask函数。进入
incrementOccupied发现只是执行了_occupied++。
void cache_t::incrementOccupied()
{
_occupied++;
}
进入setBucketsAndMask发现每次都是重新设置_buckets和_mask，并且把_occupied设置为0
void cache_t::setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask)
{
// objc_msgSend uses mask and buckets with no locks.
// It is safe for objc_msgSend to see new buckets but old mask.
// (It will get a cache miss but not overrun the buckets' bounds).
// It is unsafe for objc_msgSend to see old buckets and new mask.
// Therefore we write new buckets, wait a lot, then write new mask.
// objc_msgSend reads mask first, then buckets.
#ifdef __arm__
// ensure other threads see buckets contents before buckets pointer
mega_barrier();
_buckets.store(newBuckets, memory_order::memory_order_relaxed);
// ensure other threads see new buckets before new mask
mega_barrier();
_mask.store(newMask, memory_order::memory_order_relaxed);
_occupied = 0;
#elif __x86_64__ || i386
// ensure other threads see buckets contents before buckets pointer
// 存储新的buckets
_buckets.store(newBuckets, memory_order::memory_order_release);
// ensure other threads see new buckets before new mask
// 存储新的mask
_mask.store(newMask, memory_order::memory_order_release);
// occupied占用z设为0
_occupied = 0;
#else
#error Don't know how to do setBucketsAndMask on this architecture.
#endif
}
通过这两个方法的实现，我们发现incrementOccupied是执行计数加一操作，那么我们判断调用incrementOccupied方法的地方应该就是核心业务处理的过程，所以我们搜索incrementOccupied去看看哪里调用了它。发现只有cache_t::insert使用到了它。那我们再找下cache->insert又在哪里被使用了呢，发现只有一处cache_fill调用了cache->insert，然后我们再往上找，发现找不到调用cache_fill的地方，说明这里又是经过编译器做了处理，所以我们今天就只讨论cache_fill —>insert里的操作。
我们先来看下cache_fill的源码
void cache_fill(Class cls, SEL sel, IMP imp, id receiver)
{
runtimeLock.assertLocked(); // runtime锁 assert断言
#if !DEBUG_TASK_THREADS
// Never cache before +initialize is done
if (cls->isInitialized()) {
cache_t *cache = getCache(cls);//获取当前的cache缓存池
#if CONFIG_USE_CACHE_LOCK
mutex_locker_t lock(cacheUpdateLock);
#endif
cache->insert(cls, sel, imp, receiver);//向缓存池中插入信息
}
#else
_collecting_in_critical();
#endif
}
然后我们看下cache_t::insert的源码
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());
// 原occupied计数+1
mask_t newOccupied = occupied() + 1;
// 进入查看： return mask() ? mask()+1 : 0;
// 就是当前mask有值就+1，否则设置初始值0
unsigned oldCapacity = capacity(), capacity = oldCapacity;
// 当前缓存是否为空
if (slowpath(isConstantEmptyCache())) {
// Cache is read-only. Replace it.
// 如果为空，就给空间设置初始值4
// (进入INIT_CACHE_SIZE查看，可以发现就是1<<2，就是二进制100，十进制为4)
if (!capacity) capacity = INIT_CACHE_SIZE;
// 创建新空间（第三个入参为false，表示不需要释放旧空间）
reallocate(oldCapacity, capacity, /* freeOld */false);
}
// CACHE_END_MARKER 就是 1
// 如果当前计数+1 < 空间的 3/4。 就不用处理
// 表示空间够用。 不需要空间扩容
else if (fastpath(newOccupied + CACHE_END_MARKER <= capacity / 4 * 3)) {
// Cache is less than 3/4 full. Use it as-is.
}
// 如果计数大于3/4， 就需要进行扩容操作
else {
// 如果空间存在，就2倍扩容。 如果不存在，就设为初始值4
capacity = capacity ? capacity * 2 : INIT_CACHE_SIZE;
// 防止超出最大空间值（2^16 - 1）
if (capacity > MAX_CACHE_SIZE) {
capacity = MAX_CACHE_SIZE;
}
// 创建新空间（第三个入参为true，表示需要释放旧空间）
reallocate(oldCapacity, capacity, true);
}
// 读取现在的buckets数组
bucket_t *b = buckets();
// 新的mask值(当前空间最大存储大小)
mask_t m = capacity - 1;
// 使用hash计算当前函数的位置(内部就是sel & m， 就是取余操作，保障begin值在m当前可用空间内)
mask_t begin = cache_hash(sel, m);
mask_t i = begin;
do {
// 如果当前位置为空（空间位置没被占用）
if (fastpath(b[i].sel() == 0)) {
// Occupied计数+1
incrementOccupied();
// 将sle和imp与cls关联起来并写入内存中
b[i].set<Atomic, Encoded>(sel, imp, cls);
return;
}
// 如果当前位置有值(位置被占用)
if (b[i].sel() == sel) {
// The entry was added to the cache by some other thread
// before we grabbed the cacheUpdateLock.
// 直接返回
return;
}
// 如果位置有值，再次使用哈希算法找下一个空位置去写入
// 需要注意的是，cache_next内部有分支：
// 如果是arm64真机环境： 从最大空间位置开始，依次-1往回找空位
// 如果是arm旧版真机、x86_64电脑、i386模拟器： 从当前位置开始，依次+1往后找空位。不能超过最大空间。
// 因为当前空间是没超出mask最大空间的，所以一定有空位置可以放置的。
} while (fastpath((i = cache_next(i, m)) != begin));
// 各种错误处理
cache_t::bad_cache(receiver, (SEL)sel, cls);
}
我们再看下reallocate方法的实现，看下他是怎么对内存空间进行操作的
bucket_t *allocateBuckets(mask_t newCapacity)
{
// 创建1个bucket
bucket_t *newBuckets = (bucket_t *)
calloc(cache_t::bytesForCapacity(newCapacity), 1);
// 将创建的bucket放到当前空间的最尾部，标记数组的结束
bucket_t *end = cache_t::endMarker(newBuckets, newCapacity);
#if __arm__
// End marker's sel is 1 and imp points BEFORE the first bucket.
// This saves an instruction in objc_msgSend.
end->set<NotAtomic, Raw>((SEL)(uintptr_t)1, (IMP)(newBuckets - 1), nil);
#else
// 将结束标记为sel为1，imp为这个buckets
end->set<NotAtomic, Raw>((SEL)(uintptr_t)1, (IMP)newBuckets, nil);
#endif
// 只是打印记录
if (PrintCaches) recordNewCache(newCapacity);
// 返回这个bucket
return newBuckets;
}
我们看下allocateBuckets开辟新空间的操作
bucket_t *allocateBuckets(mask_t newCapacity)
{
// 创建1个bucket
bucket_t *newBuckets = (bucket_t *)
calloc(cache_t::bytesForCapacity(newCapacity), 1);
// 将创建的bucket放到当前空间的最尾部，标记数组的结束
bucket_t *end = cache_t::endMarker(newBuckets, newCapacity);
#if __arm__
// End marker's sel is 1 and imp points BEFORE the first bucket.
// This saves an instruction in objc_msgSend.
end->set<NotAtomic, Raw>((SEL)(uintptr_t)1, (IMP)(newBuckets - 1), nil);
#else
// 将结束标记为sel为1，imp为这个buckets
end->set<NotAtomic, Raw>((SEL)(uintptr_t)1, (IMP)newBuckets, nil);
#endif
// 只是打印记录
if (PrintCaches) recordNewCache(newCapacity);
// 返回这个bucket
return newBuckets;
}
最后我们看下cache_collect_free是怎么释放内存空间的
static void cache_collect_free(bucket_t *data, mask_t capacity)
{
#if CONFIG_USE_CACHE_LOCK
cacheUpdateLock.assertLocked();
#else
runtimeLock.assertLocked();
#endif
if (PrintCaches) recordDeadCache(capacity);
// 垃圾房： 开辟空间 （如果首次，就开辟初始空间，如果不是，就空间*2进行拓展）
_garbage_make_room ();
// 将当前扩容后的capacity加入垃圾房的尺寸中，便于后续释放。
garbage_byte_size += cache_t::bytesForCapacity(capacity);
// 将当前新数据data存放到 garbage_count 后面 这样可以释放前面的，而保留后面的新值
garbage_refs[garbage_count++] = data;
// 不记录之前的缓存 = 【清空之前的缓存】。
cache_collect(false);
}
最后我们可以总结一个流程图
cacht_t流程分析图
经过我们的分析，相信你对前面的疑问已经有了答案。
1.
occupied 和 mask是什么，又是怎么变化的呢。函数写入
cache缓存时，occupied会加1，mask记录当前cache最大可存储空间。当
inset缓存的操作，触发空间使用率超过3/4，空间2倍扩容时，mask记录新空间的最大可存储大小，因为旧空间被释放，之前cache的所有内容都被垃圾房清空了，所以occupied重置为0。从新开始计数2. 为什么会出现有的方法没有打印的情况呢。
因为触发空间扩容时，
旧空间被释放，所以cache中的旧值都被清空。 新值插入新cache空间。3. 为什么
buckets中方法的顺序和我们的调用顺序不一致呢。插入操作是使用的
hash算法。插入位置是经过取余计算的。且如果插入位置已经有值，就会不停的后移1位，直到找到空位置完成插入位置。
网友评论