Class之cache_t#

1
struct cache_t {
2

3
// <<<< 主要数据结构
4
private:
5
    explicit_atomic<uintptr_t> _bucketsAndMaybeMask;
6
    union {
7
        struct {
8
            explicit_atomic<mask_t>    _maybeMask;
9
#if __LP64__
10
            uint16_t                   _flags;
11
#endif
12
            uint16_t                   _occupied;
13
        };
14
        explicit_atomic<preopt_cache_t *> _originalPreoptCache;
15
    };
16
    ...
17
};

1
(lldb) p/x RYModel.class
2
(Class) $10 = 0x00000001000087c8 RYModel
3

4
// 平移取 cache
5
(lldb) p (cache_t *)(0x00000001000087c8 + 0x10)
6
(cache_t *) $11 = 0x00000001000087d8
7
(lldb) p $11
8
(cache_t *) $11 = 0x00000001000087d8
9

10
// 取出 cache 内容
11
(lldb) p *$11
12
(cache_t) $12 = {
13
  _bucketsAndMaybeMask = {
14
    std::__1::atomic<unsigned long> = {
15
      Value = 4314911728
16
    }
17
  }
18
   = {
19
     = {
20
      _maybeMask = {
21
        std::__1::atomic<unsigned int> = {
22
          Value = 3
23
        }
24
      }
25
      _flags = 32820
26
      _occupied = 1
27
    }
28
    _originalPreoptCache = {
29
      std::__1::atomic<preopt_cache_t *> = {
30
        Value = 0x0001803400000003
31
      }
32
    }
33
  }
34
}

1
struct bucket_t {
2
private:
3
    // IMP-first is better for arm64e ptrauth and no worse for arm64.
4
    // SEL-first is better for armv7* and i386 and x86_64.
5
#if __arm64__
6
    explicit_atomic<uintptr_t> _imp;
7
    explicit_atomic<SEL> _sel;
8
#else
9
    explicit_atomic<SEL> _sel;
10
    explicit_atomic<uintptr_t> _imp;
11
#endif
12
...
13
};

1
RYModel *obj = [RYModel alloc];
2
[obj dosomethingA];
3
[obj dosomethingB];
4
struct lw_objc_class *lw_class = (__bridge struct lw_objc_class *)(RYModel.class);
5
NSLog(@"缓存数量：%hu - 容量：%u",lw_class->cache._occupied,lw_class->cache._maybeMask);
6

7
for (mask_t i = 0; i<lw_class->cache._maybeMask; i++) {
8
    struct lw_bucket_t bucket = lw_class->cache._bukets[i];
9
    NSLog(@"SEL:%@ - IMP:%pf",NSStringFromSelector(bucket._sel),bucket._imp);
10
}

1
-[RYModel dosomethingA]
2
-[RYModel dosomethingB]
3
缓存数量：2 - 容量：3
4
SEL:dosomethingA - IMP:0xb300f
5
SEL:dosomethingB - IMP:0xb330f
6
EL:(null) - IMP:0x0f

1
[obj dosomethingA];
2
[obj dosomethingB];
3
[obj dosomethingC];
4

5
输出：
6
2021-06-27 16:00:51.939958+0800 LWCacheT[73396:867351] -[RYModel dosomethingA]
7
2021-06-27 16:00:51.940352+0800 LWCacheT[73396:867351] -[RYModel dosomethingB]
8
2021-06-27 16:00:51.940441+0800 LWCacheT[73396:867351] -[RYModel dosomethingC]
9
2021-06-27 16:00:51.940602+0800 LWCacheT[73396:867351] 缓存数量：1 - 容量：7
10
2021-06-27 16:00:51.940668+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
11
2021-06-27 16:00:51.940742+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
12
2021-06-27 16:00:51.940780+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
13
2021-06-27 16:00:51.940814+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
14
2021-06-27 16:00:51.940900+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
15
2021-06-27 16:00:51.941025+0800 LWCacheT[73396:867351] SEL:(null) - IMP:0x0f
16
2021-06-27 16:00:51.941124+0800 LWCacheT[73396:867351] SEL:dosomethingC - IMP:0xbcd8f

1
void cache_t::insert(SEL sel, IMP imp, id receiver)
2
{
3

4
    ...
5

6
    // Use the cache as-is if until we exceed our expected fill ratio.
7
    // 计数 + 1
8
    mask_t newOccupied = occupied() + 1;
9
    unsigned oldCapacity = capacity(), capacity = oldCapacity;
10
    if (slowpath(isConstantEmptyCache())) {
11
        // 判空，没有缓存创建缓存，根据架构不同，通过位运算初始化一个一定大小的容器
12
        // Cache is read-only. Replace it.
13
        if (!capacity) capacity = INIT_CACHE_SIZE;
14
        reallocate(oldCapacity, capacity, /* freeOld */false);
15
    }
16
    else if (fastpath(newOccupied + CACHE_END_MARKER <= cache_fill_ratio(capacity))) {
17
        // Cache is less than 3/4 or 7/8 full. Use it as-is.
18
        // 未达到扩容临界点
19
    }
20
#if CACHE_ALLOW_FULL_UTILIZATION
21
    else if (capacity <= FULL_UTILIZATION_CACHE_SIZE && newOccupied + CACHE_END_MARKER <= capacity) {
22
        // Allow 100% cache utilization for small buckets. Use it as-is.
23

24
        // Allow 100% cache utilization for smaller cache sizes. This has the same
25
        // advantages and disadvantages as the fill ratio. A very large percentage
26
        // of caches end up with very few entries and the worst case of collision
27
        // chains in small tables is relatively small.
28
        // NOTE: objc_msgSend properly handles a cache lookup with a full cache.
29

30
        //
31
    }
32
#endif
33
    else {
34
      // 扩容操作
35
        capacity = capacity ? capacity * 2 : INIT_CACHE_SIZE;
36
        if (capacity > MAX_CACHE_SIZE) {
37
            capacity = MAX_CACHE_SIZE;
38
        }
39
        reallocate(oldCapacity, capacity, true);
40
    }
41

42
    bucket_t *b = buckets();
43
    mask_t m = capacity - 1;
44
    mask_t begin = cache_hash(sel, m);
45
    mask_t i = begin;
46

47
    // Scan for the first unused slot and insert there.
48
    // There is guaranteed to be an empty slot.
49
    // 循环找到合适的下标
50
    do {
51
        if (fastpath(b[i].sel() == 0)) {
52
            incrementOccupied();
53
            /// 插入逻辑
54
            b[i].set<Atomic, Encoded>(b, sel, imp, cls());
55
            return;
56
        }
57
        if (b[i].sel() == sel) {
58
            // The entry was added to the cache by some other thread
59
            // before we grabbed the cacheUpdateLock.
60
            return;
61
        }
62
    } while (fastpath((i = cache_next(i, m)) != begin));
63

64
    // 未找到合适的下标 crash
65
    bad_cache(receiver, (SEL)sel);
66
#endif // !DEBUG_TASK_THREADS
67
}

1
static inline mask_t cache_hash(SEL sel, mask_t mask)
2
{
3
    uintptr_t value = (uintptr_t)sel;
4
#if CONFIG_USE_PREOPT_CACHES
5
    value ^= value >> 7;// 真机 & m1
6
#endif
7
    return (mask_t)(value & mask);
8
}

1
#if CACHE_END_MARKER
2
static inline mask_t cache_next(mask_t i, mask_t mask) {
3
    return (i+1) & mask; // 向后找
4
}
5
#elif __arm64__
6
static inline mask_t cache_next(mask_t i, mask_t mask) {
7
    return i ? i-1 : mask; // 反复横跳
8
}
9
#else
10
#error unexpected configuration
11
#endif

1
template<Atomicity atomicity, IMPEncoding impEncoding>
2
void bucket_t::set(bucket_t *base, SEL newSel, IMP newImp, Class cls)
3
{
4
...
5
    // objc_msgSend uses sel and imp with no locks.
6
    // It is safe for objc_msgSend to see new imp but NULL sel
7
    // (It will get a cache miss but not dispatch to the wrong place.)
8
    // It is unsafe for objc_msgSend to see old imp and new sel.
9
    // Therefore we write new imp, wait a lot, then write new sel.
10

11
    /// 对 IMP 进行编码操作
12
    uintptr_t newIMP = (impEncoding == Encoded
13
                        ? encodeImp(base, newImp, newSel, cls)
14
                        : (uintptr_t)newImp);
15
...
16
  保存
17
}