cache_t的结构
struct objc_class : objc_object {
// Class ISA; 继承自objc_object //8
Class superclass; //8
cache_t cache; //16 // formerly cache pointer and vtable
class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
...
}
在上一篇类的结构分析中, 我们从类的结构体源码中看到,类中存有一个cache_t cache(方法缓存),但是没有做具体分体分析,这篇博客就来具体分析一下cache_t 。
先来看一下cache_t的源码结构:
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));
};
_buckets: 一个存放bucket_t 结构体的数组,用来存放缓存方法的imp和缓存的key。
_mask:缓存数组的大小
_occupied:当前已缓存的方法数
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
...
};
using MethodCacheIMP = IMP;
typedef uintptr_t cache_key_t;
//获取key
cache_key_t getKey(SEL sel)
{
assert(sel);
return (cache_key_t)sel;
}
_imp: 缓存的方法的imp。
_key: 有sel强转而来,其实就是SEL的内存地址。
了解完了cache_t的结构,我们通过代码来验证一下,实际的类中的cache_t是否如我们分析的一样呢?我们创建一个简单的person对象,然后调用一下它的sayHappy方法,然后进入断点调试:
在控制台做如下输出:
//打印person的类对象的内存地址
(lldb) x/4gx person.class
0x100002518: 0x001d8001000024f1 0x0000000100b37140
0x100002528: 0x0000000100fc4320 0x0000000300000003
//根据内存便宜找到cache_t并打印cache_t的指针
(lldb) p (cache_t *)0x100002528
(cache_t *) $1 = 0x0000000100002528
//打印cache_t
(lldb) p *$1
(cache_t) $2 = {
_buckets = 0x0000000100fc4320
_mask = 3
_occupied = 3
}
//打印_buckets的指针
(lldb) p $2._buckets
(bucket_t *) $3 = 0x0000000100fc4320
//打印_buckets指针指向的地址,也就是_buckets的第一个元素。
(lldb) p *$3
(bucket_t) $4 = {
_key = 4294974988
_imp = 0x0000000100001a20 (LGTest`-[ZPerson sayHello] at main.m:124)
}
我们发现打印出的sayHello方法,正式在上面调用的[person sayHello]。说明cache_t里确实缓存了我们曾经调用过的方法。那么cache_t是如何进行方法的缓存的呢?请继续往下看。
cache_t的缓存查找
在cache_t的结构体里我们看到有这样一个方法:
struct bucket_t * find(cache_key_t key, id receiver);
点进去看它的具体实现:
bucket_t * cache_t::find(cache_key_t k, id receiver)
{
assert(k != 0);
//取出当前cache_t的buckets
bucket_t *b = buckets();
//取出当前cache_t的mask
mask_t m = mask();
// 通过cache_hash函数【begin = k & m】计算出key值 k 对应的 index值 begin,用来记录查询起始索引
mask_t begin = cache_hash(k, m);
// begin 赋值给 i,用于切换索引
mask_t i = begin;
do {
if (b[i].key() == 0 || b[i].key() == k) {
//用这个i从散列表取值,如果取出来的bucket_t的 key = k,则查询成功,返回该bucket_t,
//如果key = 0,说明在索引i的位置上还没有缓存过方法,同样需要返回该bucket_t,用于中止缓存查询。
return &b[i];
}
} while ((i = cache_next(i, m)) != begin);
//如果此时还没有找到key对应的bucket_t,或者是空的bucket_t,则循环结束,说明查找失败,调用bad_cache方法。
Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
cache_t::bad_cache(receiver, (SEL)k, cls);
这个方法的作用就是根据传进来的key遍历查找buckets,然后返回存有方法imp的bucket_t。这个方法应该属于查找流程中的一个过程。我们再在源码中全局搜索一下,是谁什么时候调用了这个方法。
我们在cache_fill_nolock方法中找到了find方法调用。先贴一下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);
}
1、cache_fill_nolock方法传进来4个参数:类cls、方法的sel、方法的imp和方法的调用者。
2、加一把cacheUpdateLock。
3、然后进行一下安全检查。
4、取出cls中的cahce。
5、根据sel生成相对应的key。
6、取出当前cache缓存方法的个数,然后加1,得到newOccupied,新的缓存方法个数。
7、得到当前cache的最大容量。
8、进行总容量与缓存个数的判断:
a.当前cache里面是空的,调用reallocate开去开辟新的buckets赋值的当前的cache_t
b.当前缓存个数小于总容量的3/4,不做操作
c.当前缓存个数不小于总容量的3/4,就调用expand()去扩容。
9、调用cache的find方法查找缓存
10、如果没找到,将已缓存的数目occupied加1,再将key和imp存入bucket
关于expand()扩容方法,我们在看一下它的实现源码:
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);
}
我们可以看到,方法中先去取了一下旧的容量大小oldCapacity,然后将oldCapacity乘以2,也就是将oldCapacity扩大了一倍,得到新的容量大小newCapacity。在调用reallocate()去进行内存的开辟,需要将oldCapacity和newCapacity作为参数传递进去。
我们再看一下reallocate()方法的源码:
{
bool freeOld = canBeFreed();
//获取原来的buckets
bucket_t *oldBuckets = buckets();
//根据新的容量大小,创新出新的newBuckets,这个newBuckets是空的
bucket_t *newBuckets = allocateBuckets(newCapacity);
assert(newCapacity > 0);
assert((uintptr_t)(mask_t)(newCapacity-1) == newCapacity-1);
//将新的newCapacity-1作为新的mask大小,再将_buckets和mask存入cache_t,并将occupied置为0
setBucketsAndMask(newBuckets, newCapacity - 1);
//将旧的buckets释放
if (freeOld) {
cache_collect_free(oldBuckets, oldCapacity);
cache_collect(false);
}
}
根据上面源码的注释,我们可以知道reallocate()方法具体做了哪些操作。然后我们再看一下系统都在哪些方法调用了reallocate()。根据全局搜索可以找到,有两处代码进行了reallocate()方法的调用。一个是cache_t为空,第一次开辟的时候,再有就就是调用expand()方法进行扩容的时候。
第一次调用的时候,
cache->reallocate(capacity, capacity ?: INIT_CACHE_SIZE);
,capacity
为0, INIT_CACHE_SIZE((1 << INIT_CACHE_SIZE_LOG2))
= 4。所以第一次传进的参数为(0,4)。结合上面的代码我们可以知道,第一次的容量大小mask为4-1=3。
关于cache_fill_nolock
我们已经分析的差不多了。接下来我们再找找哪里调用了cache_fill_nolock
,自下而上的查找一下,尽量到刨根儿,哈哈。
void cache_fill(Class cls, SEL sel, IMP imp, id receiver)
{
#if !DEBUG_TASK_THREADS
mutex_locker_t lock(cacheUpdateLock);
cache_fill_nolock(cls, sel, imp, receiver);
#else
_collecting_in_critical();
return;
#endif
}
找到cache_fill
方法调用了cache_fill_nolock
。再继续查找,找到lookUpImpOrForward
,lookupMethodInClassAndLoadCache
两个方法。根据方法名可以知道,当进行方法调用的时候,会进行cache_filll,也就是填充方法缓存。关于方法的调用,我们后面的博客再将。关于cache_t的分析基本上就是这些了。最后附上一张流程图,方便理清思路。