在OC底层探索06-isa本身藏了多少信息你知道吗？分析了isa。
在OC底层探索08-基于objc4-781类结构分析中分析了bits；
在平时的开发中应该都接触或者使用过
缓存的技术，目的就是提高执行效率，用空间换取时间。当然apple在这方面一定也有其特别的地方。
// 再熟悉一下objc_class的结构
struct objc_class : objc_object {
// Class ISA;
Class superclass;
cache_t cache;
class_data_bits_t bits;
...
}
本文中会注重介绍objc_object中的cache
提到缓存那么cache面缓存的是什么呢：属性还方法？其实很好猜测，平时开发中使用最多的就是方法，因为只有方法才会引起变化。下面会通过两种方式进行验证这个猜测。
首先了解一下这3个宏定义
[图片上传中...(2251862-01f4cba6213b80d7.png-442467-1600666984191-0)]
* #define CACHE_MASK_STORAGE_OUTLINED //代表当前环境：模拟器、macos
* #define CACHE_MASK_STORAGE_HIGH_16 2 //代表当前环境：64位真机
* #define CACHE_MASK_STORAGE_LOW_4 3 //代表当前环境：低于64位真机
通过cache_t了解cache到底缓存了什么？
struct cache_t {
//不同设备环境数据结构不同
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
explicit_atomic<struct bucket_t *> _buckets;
explicit_atomic<mask_t> _mask;
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
// `buckets`占低位48位。而`实际不得超过44位`，中间4位应该是考虑到访问安全
// `mask`占高位16位
explicit_atomic<uintptr_t> _maskAndBuckets;
mask_t _mask_unused;
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
explicit_atomic<uintptr_t> _maskAndBuckets;
mask_t _mask_unused;
uint16_t _flags;
uint16_t _occupied;
...
}
struct bucket_t {
#if __arm64__
explicit_atomic<uintptr_t> _imp; //方法指针
explicit_atomic<SEL> _sel; //方法标示
#else
explicit_atomic<SEL> _sel;
explicit_atomic<uintptr_t> _imp;
#endif
}
- cache根据当前环境分为3个版本.
-
explicit_atomic<X>：类似于swift中的泛型。将当前类型设置为原子性,也就是将其设置为线程安全。（毕竟在多线程中调用方法的场景太多了） - mask_t _mask_unused： 根据命名当前参数还未进行使用
- 主要信息存在：
_buckets | _maskAndBuckets中
cache_t的结构图
图片来自Style_月月-简书
- 了解
cache_t的结构会进一步方便对于cache内部的探索。
使用lldb来调试cache
使用lldb调试的前提是你需要有
lib-objc的源码环境
准备工作
@interface HRTest : NSObject
@property(nonatomic, copy)NSString *name;
-(void)say1;
-(void)say2;
@end
在没有进行任何方法调用
(lldb) p/x HRTest.class
(Class) $0 = 0x0000000100008308 HRTest
(lldb) p (cache_t *)0x0000000100008318 //类指针偏移16字节
(cache_t *) $1 = 0x0000000100008318
(lldb) p *$1
(cache_t) $2 = {
_buckets = {
std::__1::atomic<bucket_t *> = {
Value = 0x0000000100346450
}
}
_mask = {
std::__1::atomic<unsigned int> = {
Value = 0 //关注点1
}
}
_flags = 32812
_occupied = 0 //关注点2
}
查找当前方法
HRTest * t = [HRTest alloc];
t.name = @"Henry";
[t say1];
(lldb) p *$1 //cache
(cache_t) $3 = {
_buckets = {
std::__1::atomic<bucket_t *> = {
Value = 0x0000000101334620
}
}
_mask = {
std::__1::atomic<unsigned int> = {
Value = 3 //关注点1
}
}
_flags = 32812
_occupied = 2 //关注点2
}
(lldb) p $3.buckets() //获取buckets列表
(bucket_t *) $5 = 0x0000000101334620
//bucketb第一个元素
(lldb) p *$5 //指针取地址
(bucket_t) $6 = {
_sel = { //列表第一个元素的sel
std::__1::atomic<objc_selector *> = "" {
Value = ""
}
}
_imp = { //列表第一个元素的imp
std::__1::atomic<unsigned long> = {
Value = 49112
}
}
}
(lldb) p $6.sel() //列表第一个元素的sel
(SEL) $7 = "setName:"
(lldb) p $6.imp(HRTest.class) //列表第一个元素的imp
(IMP) $8 = 0x0000000100003cd0 (HRTest`-[HRTest setName:])
//bucketb第二个元素
(lldb) p $3.buckets()[2] //使用列表的地址偏移来读取下一个bucket_t
(bucket_t) $10 = {
_sel = {
std::__1::atomic<objc_selector *> = "" {
Value = ""
}
}
_imp = {
std::__1::atomic<unsigned long> = {
Value = 48984
}
}
}
(lldb) p $10.sel() //与之前同理
(SEL) $12 = "say1"
(lldb) p $10.imp(HRTest.class)
(IMP) $13 = 0x0000000100003c50 (HRTest`-[HRTest say1])
通过lldb的调试，cache_t的结构很清楚了，但是在调试过程中使用的buckets(),sel(),imp(HRTest.class)是哪里的来的呢？
cache_t 、bucket_t中的方法
struct cache_t {
...
struct bucket_t *buckets(){ //从获取_buckets、_maskAndBuckets中获取bucket
#if CACHE_MASK_STORAGE = CACHE_MASK_STORAGE_OUTLINED //模拟器、macos
return _buckets.load(memory_order::memory_order_relaxed);
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
uintptr_t maskAndBuckets = _maskAndBuckets.load(memory_order::memory_order_relaxed);
return (bucket_t *)(maskAndBuckets & bucketsMask); //通过位运算将buckets地址取出
}
}
struct bucket_t {
...
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);
...
}
}
- 放出这部分源码只是想说明一个问题，
buckets,sel,imp，这3个值的get方法在系统中是进行过处理的，无法直接访问变量指针地址获取值。这一点在cache的探索中非常重要.
脱离源码来调试cache(模拟器)
代码基础都是依赖源码来进行修改，可以直接使用，只模拟了模拟器、macos环境,其他环境也很简单，如果有需要可以再下方留言。
typedef uint32_t mask_t;
struct HR_bucket_t {
SEL sel;
IMP imp;
};
struct HR_cache_t {
//模拟器、macos环境
struct HR_bucket_t * buckets;
mask_t mask;
uint16_t flags;
uint16_t occupied;
};
struct HR_objc_class {
Class ISA;
Class superclass;
struct HR_cache_t cache;
};
int mian() {
struct HR_objc_class *obj = (__bridge struct HR_objc_class *)(HRTest.class);
NSLog(@"mask:%u---occupied:%u",obj->cache.mask,obj->cache.occupied);
for (mask_t i = 0; i < obj->cache.mask; i++) {
struct HR_bucket_t bucket = obj->cache.buckets[i];
NSLog(@"sel:%@---imp:%p",NSStringFromSelector(bucket.sel),bucket.imp);
}
}
脱离源码来调试cache(真机)
代码基础都是依赖源码来进行修改，可以直接使用，只模拟了模拟器、macos环境,其他环境也很简单，如果有需要可以再下方留言。
typedef uint32_t mask_t; // x86_64 & arm64 asm are less efficient with 16-bits
typedef unsigned long uintptr_t;
struct hr_bucket_t {
IMP _imp;
SEL _sel;
};
struct hr_cache_t {
uintptr_t _maskAndBuckets;
mask_t _mask_unused;
uint16_t _flags;
uint16_t _occupied;
};
struct hr_class_data_bits_t {
uintptr_t bits;
};
struct hr_objc_class {
Class ISA;
Class superclass;
struct hr_cache_t cache; // formerly cache pointer and vtable
struct hr_class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
};
int mian() {
struct hr_objc_class *hr_pClass = (__bridge struct hr_objc_class *)(pClass);
uintptr_t mask = hr_pClass->cache._maskAndBuckets >> 48;
struct hr_bucket_t *bucket = hr_pClass->cache._maskAndBuckets << 16 >> 16;
NSLog(@"%hu - %lu",hr_pClass->cache._occupied,mask);
for (mask_t i = 0; i<mask+1; i++) {
// 打印获取的 bucket
struct hr_bucket_t *buckets = (bucket + 0x000000000000001*i);
NSLog(@"%@ - %p",NSStringFromSelector(buckets->_sel),buckets->_imp);
}
}
继续玩一下
- 例一：调用1个方法
HRTest * t = [[HRTest alloc] init];
输出结果:
- 列二： 调用4个方法
HRTest * t = [[HRTest alloc] init];
t.name = @"Henry";
[t say1];
[t say2];
输出结果:
看到这个结果不知道和你脑中的结果一不一致。
有这样一个规律:（模拟器）
| 调用的方法数量 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|---|---|
| mask的值 | 0 | 3 | 3 | 7 | 7 | 7 | 7 | 7 | 15 |
| occupied的值 | 0 | 1 | 2 | 1 | 2 | 3 | 4 | 5 | 1 |
有这样一个规律:（真机）
| 调用的方法数量 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|---|---|
| mask的值 | 0 | 3 | 3 | 3 | 7 | 7 | 7 | 7 | 7 |
| occupied的值 | 0 | 1 | 2 | 3 | 1 | 2 | 3 | 4 | 5 |
相信各位都会有这些疑问：
- mask是什么？ occupied是什么？
- 为什么会随着方法调用的增多，而变化?
- bucket数据为什么少了？在例二中
name，init方法为什么不见了 - 存储顺序并没有按照调用顺序？
带着这些问题继续探索cache的原理。
cache的缓存原理
我们猜测mask是缓存最大值，occupied是当前缓存个数。看起来要从occupied入手.
在cache_t中发现了这个方法：自增occupied
- 在源码中全局搜索incrementOccupied()函数，发现只在cache_t的insert方法有调用。所以这就是
探索cache的入口。
继续搜索
在搜索过程中还无意中发现了方法的调用流程，具体会在后面的中文展开解释.
inster方法分析
由于涉及到的相关方法比较多，重点解释我认为比较重要的方法.
void cache_t::insert(Class cls, SEL sel, IMP imp, id receiver){
ASSERT(sel != 0 && cls->isInitialized());
//第一步
//获取occupied的旧值并且+1
mask_t newOccupied = occupied() + 1;
//获取当前mask的值
// capacity: 获取mask()并+1
unsigned oldCapacity = capacity(), capacity = oldCapacity;
//第二步 创建对应大小的内存空间
//isConstantEmptyCache判断当前类是否是首次inster
//INIT_CACHE_SIZE ： 1 << 2 = 4 mask默认初始值
//reallocate：开辟 4个 内存空间
if (slowpath(isConstantEmptyCache())) {
if (!capacity) capacity = INIT_CACHE_SIZE; // 如果capacity 为0 初始化为4
reallocate(oldCapacity, capacity, /* freeOld */false); // 根据当前内容分配空间
}
// arm64下 如果 newOccupied <= 容量的4分之3，存储空间还足够，不需额外处理
else if (fastpath(newOccupied + CACHE_END_MARKER <= capacity / 4 * 3)) {
// Cache is less than 3/4 full. Use it as-is.
}
//扩容原因：第一次申请开辟的内存容量是 4 ，如果已经有3个bucket插入到cache里面，再次插入一个就会存满这个容量，为了保证读取的正确性，就对其进行扩容
// 如果超过capacity的4分之3 则进行扩容2倍处理
else {
capacity = capacity ? capacity * 2 : INIT_CACHE_SIZE;
if (capacity > MAX_CACHE_SIZE) { //最大缓存个数不得超过:1 << 16 65536还会很大的一个值
capacity = MAX_CACHE_SIZE;
}
reallocate(oldCapacity, capacity, true); // 重新分配空间 存储新的数据，抹除已有缓存
}
//第三步 缓存插入到buckets散列表中
// 获取散列表
bucket_t *b = buckets();
// 获取散列表最大index
mask_t m = capacity - 1;
// 通过cache_hash函数【begin = sel & m】计算出key值对应的 index值
// begin，用来记录查询起始索引
mask_t begin = cache_hash(sel, m);
// begin 赋值给 i，用于切换索引
mask_t i = begin;
//通过循环找到inster的位置,hash计算会有冲突所以并不能直接插入
do {
if (fastpath(b[i].sel() == 0)) { //当前位置为空，直接插入，Occupied自增
incrementOccupied();
b[i].set<Atomic, Encoded>(sel, imp, cls);
return;
}
if (b[i].sel() == sel) { //当前方法已经缓存，直接返回
return;
}
} while (fastpath((i = cache_next(i, m)) != begin));
// 通过cache_next来解决hash冲突，找到对应的index。但不会一次就可以解决，所以需要循环
//由于内存大小已经在第二步中处理完毕，所以在该步一定会找到对应的index
//如果到这一步都没有命中，则证明该cache是一个bad缓存
cache_t::bad_cache(receiver, (SEL)sel, cls);
}
cache->insert 函数大致做了 3件事
- 创建缓存标识符
- 创建对应大小的内存空间
- 缓存插入到buckets散列表中
insert总结：
- 缓存空间大小： (mask + 1) * 8byte
- 最大缓存个数：
- 64位真机：（mask + 0） / 4 * 3 - 1
- 模拟器、macos、低64位：（mask + 1） / 4 * 3 - 1
-
occupied：当前已缓存的个数 -
mask：可以计算得到最大缓存个数、hash的掩码 - 方法的缓存位置是按照对应
hash值来进行处理的，所以是乱序的 - 当前缓存数量 超过 (散列表 + 1) 总存储空间的四分之三时，散列表的存储空间以2倍的原始大小进行扩容，并抹除已有缓存。所以会丢弃一部分内容。
以下是cache原理分析的流程图
图片来自Style_月月-简书
inster一些细节点
cache_hash、cache_next
static inline mask_t cache_hash(SEL sel, mask_t mask)
{
return (mask_t)(uintptr_t)sel & mask;
}
- mask值为：3、7、15等，所以任何数
& mask都不会超过mask。散列表大小为：mask() + 1,可以保证inster时不会出现越界情况。根据sel的存放地址 & mask来计算hash值
cache_next
#if __arm__ || __x86_64__ || __i386__ //macos、模拟器、低于64位的真机
// objc_msgSend has few registers available.
// Cache scan increments and wraps at special end-marking bucket.
#define CACHE_END_MARKER 1
static inline mask_t cache_next(mask_t i, mask_t mask) {
return (i+1) & mask;
}
#elif __arm64__ //64位真机
// objc_msgSend has lots of registers available.
// Cache scan decrements. No end marker needed.
#define CACHE_END_MARKER 0
static inline mask_t cache_next(mask_t i, mask_t mask) {
return i ? i-1 : mask;
}
- 出现hash冲突时，不同的运行环境会有不同的处理。但原理都是相同：在mask的范围内按照一定规则来进行偏移，直到命中。
- CACHE_END_MARKER 结尾标示
Tip:
为什么在缓存容量达到总容量的3/4时进行扩容？
这是一个选择的适当值，因为在哈希表这种数据结构里面，其性能受装载因子影响，装载因子可以用来表示空位率的大小，其公式为：装载因子 = 已填入的容量 / 散列表的总容量。
装载因子越大，说明空闲的位置越少，冲突的可能性越多，散列表的性能会下降。尽可能小的装载因子可以提高散列表的性能，同时太小的值又容易触发扩容条件，所以这里苹果设计了这样一个的适当的值。
reallocate
void cache_t::reallocate(mask_t oldCapacity, mask_t newCapacity, bool freeOld)
{
bucket_t *oldBuckets = buckets();
// 开辟空间
bucket_t *newBuckets = allocateBuckets(newCapacity);
ASSERT(newCapacity > 0);
ASSERT((uintptr_t)(mask_t)(newCapacity-1) == newCapacity-1);
setBucketsAndMask(newBuckets, newCapacity - 1);
// 扩容后：释放旧的缓存信息
if (freeOld) {
cache_collect_free(oldBuckets, oldCapacity);
}
}
bucket_t *allocateBuckets(mask_t newCapacity)
{
// 开辟 newCapacity = mask+1 大小的内存空间，完全新的一片空间，旧值丢弃。（零时变量）
// 所以新的空间大小都为 4的倍数
bucket_t *newBuckets = (bucket_t *)
calloc(cache_t::bytesForCapacity(newCapacity), 1);
...
}
setBucketsAndMask
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
void cache_t::setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask)
{
#elif __x86_64__ || i386 //模拟器、macos
//将 newBuckets 、 newMask 、occupied = 03个临时变量存入内存中
_buckets.store(newBuckets, memory_order::memory_order_release);
_mask.store(newMask, memory_order::memory_order_release);
_occupied = 0;
}
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
void cache_t::setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask)
{ //真机
uintptr_t buckets = (uintptr_t)newBuckets;
uintptr_t mask = (uintptr_t)newMask;
//buckets和mask存入一个指针中，所以需要一些位移操作
_maskAndBuckets.store(((uintptr_t)newMask << maskShift) | (uintptr_t)newBuckets, std::memory_order_relaxed);
_occupied = 0;
}
- 因为旧的缓存数据已经丢弃，所以
occupied无脑设为0 - 不是
64位真机，正常存储bucket和mask -
64位真机,buckets和mask要存入一个指针中。buckets占低位48位，，mask占高位16位。
真机中一些常量
static constexpr uintptr_t maskShift = 48;
static constexpr uintptr_t maskZeroBits = 4;
static constexpr uintptr_t maxMask = ((uintptr_t)1 << (64 - maskShift)) - 1;
static constexpr uintptr_t bucketsMask = ((uintptr_t)1 << (maskShift - maskZeroBits)) - 1;
网友评论