iOS 從源碼解析Runtime (八)：聚焦cache_t及方法緩存實現相關內容篇(1)
前面連續幾篇咱們已經詳細分析了
objc_object的相關的全部源碼，接下來幾篇則開始分析定義於objc-runtime-new.h中的objc_class，本篇先從struct objc_class : objc_object的cache_t cache開始，cache_t主要實現方法緩存，幫助咱們更快的找到方法地址進行調用。html
縱覽 objc-runtime-new.h 文件真的超長，那咱們就分塊來學習，一塊兒 ⛽️⛽️ 吧！c++
struct objc_class : objc_object {
// Class ISA; // objc_class 繼承自 objc_object，因此其第一個成員變量實際上是 isa_t isa
Class superclass; // 父類指針
cache_t cache; // formerly cache pointer and vtable 之前緩存指針和虛函數表
...
};
複製代碼
typedef uintptr_t SEL;在objc-runtime-new.h的198行，看到SEL。數組
cache 是 objc_class 的第三個成員變量，類型是 cache_t。從數據結構角度及使用方法來看 cache_t 的話，它是一個 SEL 做爲 Key ，SEL + IMP(bucket_t) 做爲 Value 的散列表。爲了對方法緩存先有一個大體的瞭解，咱們首先解讀一下 objc-cache.mm 文件開頭的一大段註釋內容。緩存
/* objc-cache.m 1. Method cache management 方法緩存管理 2. Cache flushing 緩存刷新 3. Cache garbage collection 緩存垃圾回收 4. Cache instrumentation 緩存檢測 5. Dedicated allocator for large caches 大型緩存的專用分配器 (?) /* Method cache locking (GrP 2001-1-14) For speed, objc_msgSend does not acquire any locks when it reads method caches. 爲了提升速度，objc_msgSend 在讀取方法緩存時不獲取任何鎖。 Instead, all cache changes are performed so that any objc_msgSend running concurrently with the cache mutator will not crash or hang or get an incorrect result from the cache. 相反，將執行全部緩存更改，以便與緩存 mutator 併發運行的任何 objc_msgSend 都不會崩潰或掛起， 或者從緩存中得到不正確的結果。（以 std::atomic 完成全部的原子操做） When cache memory becomes unused (e.g. the old cache after cache expansion), it is not immediately freed, because a concurrent objc_msgSend could still be using it. 當緩存未使用時，（例如：緩存擴展後的舊緩存），它不會當即釋放，由於併發的 objc_msgSend 可能仍在使用它。 Instead, the memory is disconnected from the data structures and placed on a garbage list. 相反，內存與數據結構斷開鏈接，並放在垃圾列表中。 The memory is now only accessible to instances of objc_msgSend that were running when the memory was disconnected; 內存如今只能訪問斷開內存時運行的 objc_msgSend 實例； any further calls to objc_msgSend will not see the garbage memory because the other data structures don't point to it anymore. 對 objc_msgSend 的任何進一步調用都不會看到垃圾內存，由於其餘數據結構再也不指向它。 The collecting_in_critical function checks the PC of all threads and returns FALSE when all threads are found to be outside objc_msgSend. collecting_in_critical 函數檢查全部線程的PC，當發現全部線程都在 objc_msgSend 以外時返回 FALSE。 This means any call to objc_msgSend that could have had access to the garbage has finished or moved past the cache lookup stage, so it is safe to free the memory. 這意味着能夠訪問垃圾的對 objc_msgSend 的任何調用都已完成或移動到緩存查找階段，所以能夠安全地釋放內存。 All functions that modify cache data or structures must acquire the cacheUpdateLock to prevent interference from concurrent modifications. 全部修改緩存數據或結構的函數都必須獲取 cacheUpdateLock，以防止併發修改的干擾。 The function that frees cache garbage must acquire the cacheUpdateLock and use collecting_in_critical() to flush out cache readers. 釋放緩存垃圾的函數必須獲取 cacheUpdateLock，並使用 collecting_in_critical() 清除緩存讀取器 The cacheUpdateLock is also used to protect the custom allocator used for large method cache blocks. Cache readers (PC-checked by collecting_in_critical()) cacheUpdateLock 還用於保護用於大型方法緩存塊的自定義分配器。緩存讀取器（由collecting_in_critical() 進行 PC 檢查） objc_msgSend cache_getImp Cache writers (hold cacheUpdateLock while reading or writing; not PC-checked) (讀取或寫入時獲取 cacheUpdateLock，不使用 PC-checked) cache_fill (acquires lock)(獲取鎖) cache_expand (only called from cache_fill)(僅從 cache_fill 調用) cache_create (only called from cache_expand)(僅從 cache_expand 調用) bcopy (only called from instrumented cache_expand)(僅從已檢測的 cache_expand 調用) flush_caches (acquires lock)(獲取鎖) cache_flush (only called from cache_fill and flush_caches)(僅從 cache_fill 和 flush_caches 調用) cache_collect_free (only called from cache_expand and cache_flush)(僅從 cache_expand 和 cache_flush 調用) UNPROTECTED cache readers (NOT thread-safe; used for debug info only)(不是線程安全的；僅用於調試信息) cache_print cache 打印 _class_printMethodCaches _class_printDuplicateCacheEntries _class_printMethodCacheStatistics */
複製代碼
到這裏就看完註釋了，有點懵，下面仍是把源碼一行一行看完，而後再回顧上面的內容到底指的是什麼。安全
CACHE_IMP_ENCODING/CACHE_MASK_STORAGE
在進入 cache_t/bucket_t 內容以前，首先看兩個宏定義，CACHE_IMP_ENCODING 表示在 bucket_t 中 IMP 的存儲方式，CACHE_MASK_STORAGE 表示 cache_t 中掩碼的位置。struct bucket_t 和 struct cache_t 裏面的不一樣實現部分正是根據這兩個宏來判斷的。咱們最關注的 x86_64(mac) 和 arm64(iphone) 兩個平臺下 bucket_t 中 IMP 都是以 ISA 與 IMP 異或的值存儲。而掩碼位置的話 x86_64 下是 CACHE_MASK_STORAGE_OUTLINED 沒有掩碼，buckets 散列數組和 _mask 以兩個成員變量分別表示。在 arm64 下則是 CACHE_MASK_STORAGE_HIGH_16 高 16 位爲掩碼，散列數組和 mask 共同保存在 _maskAndBuckets 中。markdown
// 三種方法緩存存儲 IMP 的方式：（bucket_t 中 _imp 成員變量存儲 IMP 的方式）
// Determine how the method cache stores IMPs.
// 肯定方法緩存如何存儲 IMPs. (IMP 是函數實現的指針，保存了函數實現的地址，根據 IMP 能夠直接執行函數...)
// Method cache contains raw IMP. 方法緩存包含原始的 IMP（bucket_t 中 _imp 爲 IMP）
#define CACHE_IMP_ENCODING_NONE 1
// Method cache contains ISA ^ IMP. 方法緩存包含 ISA 與 IMP 的異或（bucket_t 中 _imp 是 IMP ^ ISA）
#define CACHE_IMP_ENCODING_ISA_XOR 2
// Method cache contains ptrauth'd IMP.
// 方法緩存包含指針驗證的 IMP (bucket_t 中 _imp 是 ptrauth_auth_and_resign 函數計算的值)
#define CACHE_IMP_ENCODING_PTRAUTH 3
// 上述三種方式的各在什麼平臺使用：
#if __PTRAUTH_INTRINSICS__ // 未找到該宏定義的值
// Always use ptrauth when it's supported. 當平臺支持 __PTRAUTH_INTRINSICS__ 時老是使用指針驗證
// 此時 CACHE_IMP_ENCODING 爲 CACHE_IMP_ENCODING_PTRAUTH
#define CACHE_IMP_ENCODING CACHE_IMP_ENCODING_PTRAUTH
#elif defined(__arm__)
// 32-bit ARM uses no encoding. 32位 ARM 下不進行編碼，直接使用原始 IMP(watchOS 下)
#define CACHE_IMP_ENCODING CACHE_IMP_ENCODING_NONE
#else
// Everything else uses ISA ^ IMP. 其它狀況下在方法緩存中存儲 ISA 與 IMP 異或的值
#define CACHE_IMP_ENCODING CACHE_IMP_ENCODING_ISA_XOR
#endif
複製代碼
// CACHE 中掩碼位置
#define CACHE_MASK_STORAGE_OUTLINED 1 // 沒有掩碼
#define CACHE_MASK_STORAGE_HIGH_16 2 // 高 16 位
#define CACHE_MASK_STORAGE_LOW_4 3 // 低 4 位
#if defined(__arm64__) && __LP64__ // 若是是 64 位 ARM 平臺（iPhone 自 5s 起都是）
// 掩碼存儲在高 16 位
#define CACHE_MASK_STORAGE CACHE_MASK_STORAGE_HIGH_16
#elif defined(__arm64__) && !__LP64__ // ARM 平臺 非 64 位系統架構（watchOS 下）
// 掩碼存儲在低 4 位
#define CACHE_MASK_STORAGE CACHE_MASK_STORAGE_LOW_4
#else
// 不使用掩碼的方式（_buckets 與 _mask 分別是兩個變量，上面則是把 buckets 和 mask 合併保存在 _maskAndBuckets 中）
#define CACHE_MASK_STORAGE CACHE_MASK_STORAGE_OUTLINED
#endif
複製代碼
bucket_t
看到 bucket_t 一下想起了 RefcountMap refcnts 中保存對象引用計數時使用的數據結構 typename BucketT = detail::DenseMapPair<KeyT, ValueT>> 用於保存對象的地址和對象的引用計數。bucket_t 基本也是大體相同的做用，這裏是把函數的 SEL 和函數的實現地址 IMP 保存在 bucket_t 這個結構體中。這裏先看一下 bucket_t 定義的 private 部分:數據結構
struct bucket_t {
private:
// 爲了優化性能，針對 __arm64__ 和其它平臺調換 _imp 和 _sel 兩個成員變量的順序
// IMP-first is better for arm64e ptrauth and no worse for arm64.
// IMP 在前時對 arm64e 的指針驗證機制更好，對 arm64 也不差。
// SEL-first is better for armv7* and i386 and x86_64.
// SEL 在前時對 armv7* i386 x86_64 更好。
// typedef unsigned long uintptr_t;
// template <typename T> struct explicit_atomic : public std::atomic<T> { ... };
// 禁止隱式轉換，T 操做爲原子操做，避免多線程競爭
// 類型如出一轍，這裏是修改一下 _imp 和 _sel 的先後順序
#if __arm64__
explicit_atomic<uintptr_t> _imp;
explicit_atomic<SEL> _sel;
#else
explicit_atomic<SEL> _sel;
explicit_atomic<uintptr_t> _imp;
#endif
// Compute the ptrauth signing modifier from &_imp, newSel, and cls.
// 從 ＆_imp、newSel 和 cls 計算 ptrauth 簽名修飾符。
uintptr_t modifierForSEL(SEL newSel, Class cls) const {
// 連續異或
return (uintptr_t)&_imp ^ (uintptr_t)newSel ^ (uintptr_t)cls;
}
// Sign newImp, with &_imp, newSel, and cls as modifiers.
// 簽署 newImp，使用 ＆_imp、newSel 和 cls 做修改。
uintptr_t encodeImp(IMP newImp, SEL newSel, Class cls) const {
// 若是 newImp 爲 nil，返回 0
if (!newImp) return 0;
#if CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_PTRAUTH
// 若是 IMP 編碼使用指針驗證機制
return (uintptr_t)
ptrauth_auth_and_resign(newImp,
ptrauth_key_function_pointer, 0,
ptrauth_key_process_dependent_code,
modifierForSEL(newSel, cls));
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_ISA_XOR
// IMP 與 Class 做異或的值
return (uintptr_t)newImp ^ (uintptr_t)cls;
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_NONE
// 直接使用原始 IMP
return (uintptr_t)newImp;
#else
#error Unknown method cache IMP encoding. // 未知方式
#endif
}
...
};
複製代碼
bucket_t 定義的 public 部分:多線程
public:
// 原子讀取 _sel
inline SEL sel() const { return _sel.load(memory_order::memory_order_relaxed); }
// 根據 cls 從 bucket_t 實例中取得 _imp
inline IMP imp(Class cls) const {
// 首先原子讀取 _imp
uintptr_t imp = _imp.load(memory_order::memory_order_relaxed);
// 若是 imp 不存在，則返回 nil
if (!imp) return nil;
#if CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_PTRAUTH
// 原子讀取 _sel
SEL sel = _sel.load(memory_order::memory_order_relaxed);
// 計算返回 IMP
return (IMP)
ptrauth_auth_and_resign((const void *)imp,
ptrauth_key_process_dependent_code,
modifierForSEL(sel, cls),
ptrauth_key_function_pointer, 0);
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_ISA_XOR
// imp 與 cls 再進行一次異或，返回原值，獲得 encodeImp 傳入的 newImp（之因此是再，是由於 _imp 存儲時就已經作過一次異或了）
return (IMP)(imp ^ (uintptr_t)cls);
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_NONE
// 原始 IMP
return (IMP)imp;
#else
#error Unknown method cache IMP encoding. // 未知
#endif
}
// enum Atomicity { Atomic = true, NotAtomic = false };
// enum IMPEncoding { Encoded = true, Raw = false };
// set 函數 的聲明，按住 command 點擊 set，可看到 set 函數定義在 objc-cache.mm 中
template <Atomicity, IMPEncoding>
void set(SEL newSel, IMP newImp, Class cls);
};
複製代碼
set
set 函數完成的功能是以原子方式完成 bucket_t 實例 _imp 和 _sel 成員變量的設置。架構
memory_order 的值可參考: 《如何理解 C++11 的六種 memory order？》併發
// 非 __arm64__ 平臺下(x86_64 下):
template<Atomicity atomicity, IMPEncoding impEncoding> void bucket_t::set(SEL newSel, IMP newImp, Class cls) {
// 當前 bucket_t 實例的 _sel 爲 0 或者與傳入的 newSel 相同
// DEBUG 下 bucket_t 的 _sel 和 newSel 不一樣就會執行斷言 ？
ASSERT(_sel.load(memory_order::memory_order_relaxed) == 0 ||
_sel.load(memory_order::memory_order_relaxed) == newSel);
// objc_msgSend uses sel and imp with no locks.
// objc_msgSend 使用 sel 和 imp 不會加鎖。
// It is safe for objc_msgSend to see new imp but NULL sel
// objc_msgssend 能夠安全地看到新的 imp 和 NULL 的 sel。
// (It will get a cache miss but not dispatch to the wrong place.
// 它將致使緩存未命中，但不會分派到錯誤的位置。)
// It is unsafe for objc_msgSend to see old imp and new sel.
// objc_msgSend 查看舊的 imp 和新的 sel 是不安全的。
// Therefore we write new imp, wait a lot, then write new sel.
// 所以，咱們首先寫入新的 imp，等一下，而後再寫入新的 sel。
// 根據 impEncoding 判斷 新 IMP 是須要作異或求值仍是直接使用
uintptr_t newIMP = (impEncoding == Encoded
? encodeImp(newImp, newSel, cls)
: (uintptr_t)newImp);
if (atomicity == Atomic) {
// 若是是 Atomic
// 首先把 newIMP 存儲到 _imp
_imp.store(newIMP, memory_order::memory_order_relaxed);
// _sel 是 0 時：
if (_sel.load(memory_order::memory_order_relaxed) != newSel) {
// 若是當前 _sel 與 newSel 不一樣，則根據不一樣的平臺來設置 _sel
#ifdef __arm__
// barrier
mega_barrier();
_sel.store(newSel, memory_order::memory_order_relaxed);
#elif __x86_64__ || __i386__
_sel.store(newSel, memory_order::memory_order_release);
#else
// 不知道如何在此架構上執行 bucket_t::set。
#error Don't know how to do bucket_t::set on this architecture. #endif } } else { // 原子保存 _imp _imp.store(newIMP, memory_order::memory_order_relaxed); // 原子保存 _sel _sel.store(newSel, memory_order::memory_order_relaxed); } } 複製代碼
首先要把 newImp 寫入，__arm64__ 下 set 函數的實現涉及一個 __asm__ 好像涉及到 ARM 的內存排序內存屏障啥的看不懂。 struct bucket_t 到這裏就結束了，主要用來保存函數的 SEL 和 IMP（IMP 根據不一樣的編碼方式來保存）。
cache_t
cache_t 是做爲一個散列數組來緩存方法的。先看下 cache_t 定義的 private 部分:
mask_t:
#if __LP64__
// x86_64 & arm64 asm are less efficient with 16-bits
// x86_64 和 arm64 asm 的 16 位效率較低
typedef uint32_t mask_t; // 32 位 4 字節 int
#else
typedef uint16_t mask_t; // 16 位 2 字節 int
#endif
複製代碼
struct cache_t private
struct cache_t {
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
// 若是沒有掩碼的話
// _buckets 是 struct bucket_t 類型的數組
// 方法的緩存數組（以散列表的形式存儲 bucket_t）
explicit_atomic<struct bucket_t *> _buckets;
// _buckets 的數組長度 -1（容量的臨界值）
explicit_atomic<mask_t> _mask;
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
// 高 16 位是掩碼的平臺（iPhone 5s 之後的真機）
// 掩碼和 Buckets 指針共同保存在 uintptr_t 類型的 _maskAndBuckets 中
explicit_atomic<uintptr_t> _maskAndBuckets;
mask_t _mask_unused; // 未使用的容量
// How much the mask is shifted by.
// 高 16 位是 mask，即 _maskAndBuckets 右移 48 位獲得 mask
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.
// 掩碼後的其餘位必須爲零。
// msgSend 利用這些額外的位在單個指令中從 _maskAndBuckets 構造了值 mask<< 4
static constexpr uintptr_t maskZeroBits = 4;
// The largest mask value we can store.
// 咱們能夠保存的最大的 mask 值。
// (64 - maskShiift) 即掩碼位數，而後 1 左移掩碼位數後再 減 1 即 16 位能保存的最大二進制值
//（16 位 1，其他位都是 0 的數值）
static constexpr uintptr_t maxMask = ((uintptr_t)1 << (64 - maskShift)) - 1;
// The mask applied to `_maskAndBuckets` to retrieve the buckets pointer.
// 應用於 _maskAndBuckets 的掩碼，以獲取 buckets 指針。
// 1 左移 44(48 - 4) 位後再 減 1（44 位 1，其他都是 0 的數值）
static constexpr uintptr_t bucketsMask = ((uintptr_t)1 << (maskShift - maskZeroBits)) - 1;
// Ensure we have enough bits for the buckets pointer.
// 確保咱們有足夠的位用於存儲 buckets 指針。
static_assert(bucketsMask >= MACH_VM_MAX_ADDRESS, "Bucket field doesn't have enough bits for arbitrary pointers.");
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
// _maskAndBuckets stores the mask shift in the low 4 bits, and the buckets pointer in the remainder of the value.
// The mask shift is the value where (0xffff >> shift) produces the correct mask.
// This is equal to 16 - log2(cache_size).
// _maskAndBuckets 將掩碼移位存儲在低 4 位中，並將 buckets 指針存儲在該值的其他部分中。
// 掩碼 shift 是（0xffff >> shift）產生正確掩碼的值。
// 等於 16 - log2(cache_size)
// 幾乎同上
explicit_atomic<uintptr_t> _maskAndBuckets;
mask_t _mask_unused;
static constexpr uintptr_t maskBits = 4;
static constexpr uintptr_t maskMask = (1 << maskBits) - 1;
static constexpr uintptr_t bucketsMask = ~maskMask;
#else
#error Unknown cache mask storage type. // 未知掩碼存儲類型
#endif
#if __LP64__
// 若是是 64 位環境的話會多一個 _flags 標誌位
uint16_t _flags;
#endif
uint16_t _occupied; // 緩存數組的已佔用量
...
};
複製代碼
struct cache_t public
cache_t 定義的 public 部分: cache_t 的實現部分也是涉及到不一樣的平臺下不一樣的實現，這裏只分析 CACHE_MASK_STORAGE_OUTLINED(x86_64) 和 CACHE_MASK_STORAGE_HIGH_16 (__arm64__ && __LP64__) 兩個平臺的實現。
emptyBuckets
一個指向 _objc_empty_cache 的 bucket_t 指針，用來指示當前類的緩存指向空緩存。（_objc_empty_cache 是一個外聯變量）
// OBJC2 不可見
struct objc_cache {
unsigned int mask /* total = mask + 1 */ OBJC2_UNAVAILABLE;
unsigned int occupied OBJC2_UNAVAILABLE;
Method _Nullable buckets[1] OBJC2_UNAVAILABLE;
};
OBJC_EXPORT struct objc_cache _objc_empty_cache OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
// 位於 objc-cache-old.mm 中
// 靜態的空緩存，全部類最初都指向此緩存。
// 發送第一條消息時，它在緩存中未命中，當緩存新增時，它會檢查這種狀況，並使用 malloc 而不是 realloc。
// 這避免了在 Messenger 中檢查 NULL 緩存的須要。
struct objc_cache _objc_empty_cache =
{
0, // mask
0, // occupied
{ NULL } // buckets
};
// CACHE_MASK_STORAGE_OUTLINED 下
struct bucket_t *cache_t::emptyBuckets() {
// 直接使用 & 取 _objc_empty_cache 的地址並返回，
// _objc_empty_cache 是一個全局變量，用來標記當前類的緩存是一個空緩存。
return (bucket_t *)&_objc_empty_cache;
}
// CACHE_MASK_STORAGE_HIGH_16 下（看到和 OUTLINED 徹底同樣）
struct bucket_t *cache_t::emptyBuckets() {
return (bucket_t *)&_objc_empty_cache;
}
複製代碼
buckets
散列數組的起始地址。
// CACHE_MASK_STORAGE_OUTLINED
// 沒有任何 "鎖頭"，原子加載 _buckets 並返回
struct bucket_t *cache_t::buckets() {
// 原子加載 _buckets 並返回
return _buckets.load(memory_order::memory_order_relaxed);
}
// CACHE_MASK_STORAGE_HIGH_16
// 也是沒有任何 "鎖頭"，原子加載 _maskAndBuckets，而後與 bucketsMask 掩碼與操做並把結果返回
struct bucket_t *cache_t::buckets() {
// 原子加載 _maskAndBuckets
uintptr_t maskAndBuckets = _maskAndBuckets.load(memory_order::memory_order_relaxed);
// 而後與 bucketsMask 作與操做並返回結果。
//（bucketsMask 的值是 低 44 位是 1，其它位所有是 0，與操做取出 maskAndBuckets 低 44 位的值）
return (bucket_t *)(maskAndBuckets & bucketsMask);
}
複製代碼
mask
_buckets 的數組長度 -1（容量的臨界值）。
// CACHE_MASK_STORAGE_OUTLINED
mask_t cache_t::mask() {
// 沒有任何鎖頭，原子加載 _mask 並返回
return _mask.load(memory_order::memory_order_relaxed);
}
// CACHE_MASK_STORAGE_HIGH_16
mask_t cache_t::mask() {
// 原子加載 _maskAndBuckets
uintptr_t maskAndBuckets = _maskAndBuckets.load(memory_order::memory_order_relaxed);
// maskAndBuckets 左移 48 位即獲得了 mask，並返回此值。（高 16 位保存 mask）
return maskAndBuckets >> maskShift;
}
#if __LP64__
typedef uint32_t mask_t; // x86_64 & arm64 asm are less efficient with 16-bits
#else
typedef uint16_t mask_t;
#endif
typedef uintptr_t SEL;
複製代碼
這裏有一個點，在 CACHE_MASK_STORAGE_HIGH_16 時是 __LP64__ 平臺，mask_t 在 __LP64__ 下是 uint32_t，多出了 16 位空間，mask 只須要 16 位就足夠保存。註釋給出的解釋是: " x86_64 和 arm64 asm 的 16 位效率較低。"
occupied/incrementOccupied
mask_t cache_t::occupied() {
return _occupied; // 返回 _occupied
}
void cache_t::incrementOccupied() {
_occupied++; // _occupied 自增
}
複製代碼
setBucketsAndMask
設置 _buckets 與 _mask 的值，CACHE_MASK_STORAGE_OUTLINED 模式只須要分別以原子方式設置兩個成員變量的值便可，CACHE_MASK_STORAGE_HIGH_16 模式須要把兩個值作位操做合併在一塊兒而後以原子方式保存在 _maskAndBuckets 中。同時以上兩種狀況都會順便把 _occupied 設置爲 0。
// CACHE_MASK_STORAGE_OUTLINED
void cache_t::setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask) {
// objc_msgSend uses mask and buckets with no locks.
// objc_msgSend 使用 mask 和 buckets 不會進行加鎖。
// It is safe for objc_msgSend to see new buckets but old mask.
// 對於 objc_msgSend 來講，看到新的 buckets 和舊的 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.
// objc_msgSend 查看舊 buckets 和新 mask 是不安全的。
// Therefore we write new buckets, wait a lot, then write new mask.
// 因此咱們先寫入新的 buckets，寫入完成後，再寫入新的 mask。
// objc_msgSend reads mask first, then buckets.
// objc_msgSend 首先讀取 mask，而後讀取 buckets。
#ifdef __arm__
// ensure other threads see buckets contents before buckets pointer
// 確保其餘線程在 buckets 指針以前看到 buckets 內容
mega_barrier();
_buckets.store(newBuckets, memory_order::memory_order_relaxed);
// ensure other threads see new buckets before new mask
// 確保其餘線程在新 mask 以前看到新 buckets
mega_barrier();
_mask.store(newMask, memory_order::memory_order_relaxed);
_occupied = 0; // _occupied 置爲 0
#elif __x86_64__ || i386
// ensure other threads see buckets contents before buckets pointer
// 確保其餘線程在 buckets 指針以前看到 buckets 內容
// 以原子方式保存 _buckets
_buckets.store(newBuckets, memory_order::memory_order_release);
// ensure other threads see new buckets before new mask
// 確保其餘線程在新 mask 以前看到新 buckets
// 以原子方式保存 _mask
_mask.store(newMask, memory_order::memory_order_release);
_occupied = 0; // _occupied 置爲 0
#else
// 不知道如何在此架構上執行 setBucketsAndMask。
#error Don't know how to do setBucketsAndMask on this architecture. #endif } // CACHE_MASK_STORAGE_HIGH_16 void cache_t::setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask) { // 轉爲 unsigned long uintptr_t buckets = (uintptr_t)newBuckets; uintptr_t mask = (uintptr_t)newMask; // 斷言: buckets 小於等於 buckets 的掩碼（bucketsMask 的值低 44 位全爲 1，其它位是 0） ASSERT(buckets <= bucketsMask); // 斷言: mask 小於等於 mask 的最大值（maxMask 的值低 16 位全爲 1，其它位是 0） ASSERT(mask <= maxMask); // newMask 左移 48 位而後與 newBuckets 作或操做， // 由於 newBuckets 高 16 位所有是 0，因此 newMask 左移 16 的值與 newBuckets 作或操做時依然保持不變 // 把結果以原子方式保存在 _maskAndBuckets 中 _maskAndBuckets.store(((uintptr_t)newMask << maskShift) | (uintptr_t)newBuckets, std::memory_order_relaxed); // 把 _occupied 置爲 0 _occupied = 0; } 複製代碼
initializeToEmpty
// bzero
// 頭文件：#include <string.h>
// 函數原型：void bzero (void *s, int n);
// 功能：將字符串 s 的前 n 個字節置爲 0，通常來講 n 一般取 sizeof(s)，將整塊空間清零
// CACHE_MASK_STORAGE_OUTLINED
void cache_t::initializeToEmpty() {
// 把 this 的內存清零
bzero(this, sizeof(*this));
// 以原子方式把 _objc_empty_cache 的地址存儲在 _buckets 中
_buckets.store((bucket_t *)&_objc_empty_cache, memory_order::memory_order_relaxed);
}
// CACHE_MASK_STORAGE_HIGH_16
void cache_t::initializeToEmpty() {
// 把 this 的內存清零
bzero(this, sizeof(*this));
// 把 _objc_empty_cache 的地址轉換爲 uintptr_t而後以原子方式把其存儲在 _maskAndBuckets 中
_maskAndBuckets.store((uintptr_t)&_objc_empty_cache, std::memory_order_relaxed);
}
複製代碼
兩種模式下都是把 _objc_empty_cache 的地址取出用於設置 _buckets/_maskAndBuckets，兩種模式下也都對應上面的 emptyBuckets 函數，取出 (bucket_t *)&_objc_empty_cache 返回。
canBeFreed
canBeFreed 函數只有下面一種實現，看名字咱們大概也能猜出此函數的做用，正式判斷能不能釋放 cache_t。
bool cache_t::canBeFreed() {
// 調用 isConstantEmptyCache 函數，若是它返回 true，
// 則代表 cache_t 的 buckets 當前正是那些準備的標記 emptyBuckets 的靜態值
//（當 capacity 小於 capacity 時，
// isConstantEmptyCache 函數內部的 emptyBucketsForCapacity 函數返回的都是:
// cache_t::emptyBuckets() 全局的 (bucket_t *)&_objc_empty_cache 值），則不能進行釋放，
// 咱們本身申請的有效的方法緩存內容，纔可根據狀況進行釋放。
return !isConstantEmptyCache();
}
複製代碼
isConstantEmptyCache
看完下面的 emptyBucketsForCapacity 實現才知道 isConstantEmptyCache 中 Constant 的含義。
bool cache_t::isConstantEmptyCache() {
// occupied() 函數很簡單就是獲取 _occupied 成員變量的值而後直接返回，
// _occupied 表示散列表中已佔用的容量
// 此處要求 occupied() 爲 0 而且 buckets() 等於 emptyBucketsForCapacity(capacity(), false)
// emptyBucketsForCapacity 函數則是根據 capacity() 去找其對應的 emptyBuckets，
// 且這些 emptyBuckets 地址都是固定的，
// 它們是做標記用的靜態值，若是此時 buckets 正是這些個靜態值，說明此時 cache_t 是一個空緩存。
return
occupied() == 0 &&
buckets() == emptyBucketsForCapacity(capacity(), false);
// 且這裏用了 false 則下面不執行 emptyBucketsList 相關的申請空間的邏輯，
// 會直接 if (!allocate) return nil;
}
複製代碼
capacity
// mask 是臨界值，加 1 後就是散列表的容量
unsigned cache_t::capacity() {
return mask() ? mask()+1 : 0;
}
複製代碼
emptyBucketsForCapacity
根據入參 capacity，返回一個指定 capacity 容量的空的散列表，返回的這個 bucket_t * 是 static bucket_t **emptyBucketsList 這個靜態變量指定下標的值，當 capacity 位於指定的區間時，返回的 bucket_t * 都是相同的。若是 capacity 超出了現有的容量界限，則會對 emptyBucketsList 進行擴容。 例如：capacity 值在 [8，15] 以內時，經過 index = log2u(capacity) 計算的 index 值都是相同的，那麼調用 emptyBucketsForCapacity 函數返回的都是相同的 emptyBucketsList[index]。因爲這裏有 EMPTY_BYTES 限制，因此至少 capacity 大於 9/1025 纔會使用到 emptyBucketsList 相關的邏輯，內部 index 是從 3/10（2 的 3 次方是 8，2 的 10 次方是 1024） 開始的。其它的狀況則一概返回 cache_t::emptyBuckets()。
bucket_t *emptyBucketsForCapacity(mask_t capacity, bool allocate = true) {
#if CONFIG_USE_CACHE_LOCK
cacheUpdateLock.assertLocked();
#else
runtimeLock.assertLocked(); // 走此分支，加鎖（加鎖失敗會執行斷言）
#endif
// buckets 總字節佔用（sizeof(bucket_t) * capacity）
size_t bytes = cache_t::bytesForCapacity(capacity);
// Use _objc_empty_cache if the buckets is small enough.
// 若是 buckets 足夠小的話使用 _objc_empty_cache。
if (bytes <= EMPTY_BYTES) {
// 小於 ((8+1)*16) 主要針對的是 DEBUG 模式下。
// 小於 ((1024+1)*16) 非 DEBUG 模式（後面的乘以 16 是由於 sizeof(bucket_t) == 16）
//（以爲這個 1025 的容量就已經很大大了，可能很難超過，大機率這裏就直接返回 cache_t::emptyBuckets() 了）
return cache_t::emptyBuckets();
}
// Use shared empty buckets allocated on the heap.
// 使用在堆上分配的 shared empty buckets。
// 靜態的 bucket_t **，下次再進入 emptyBucketsForCapacity 函數的話依然是保持上次的值
// 且返回值正是 emptyBucketsList[index]，就是說調用 emptyBucketsForCapacity 獲取就是一個靜態的定值
static bucket_t **emptyBucketsList = nil;
// 靜態的 mask_t (uint32_t)，下次再進入 emptyBucketsForCapacity 函數的話依然是保持上次的值
static mask_t emptyBucketsListCount = 0;
// ⚠️
// template <typename T>
// static inline T log2u(T x) {
// return (x<2) ? 0 : log2u(x>>1)+1;
// }
// log2u 計算的是小於等於 x 的最大的 2 冪的指數
// x 在 [8，15] 區間內，大於等於 2^3，因此返回值爲 3
// x 在 [16, 31] 區間內，大於等於 2^4, 因此返回值爲 4
mask_t index = log2u(capacity);
if (index >= emptyBucketsListCount) {
if (!allocate) return nil;
// index + 1 此值尚未看出來是什麼意思
mask_t newListCount = index + 1;
// capacity 大於 9/1026 那麼 bytes 大於 9 * 16/1026 * 16，16 Kb 也可太大了
// 分配 bytes 個長度爲 1 的連續內存空間，且內存初始化爲 0
bucket_t *newBuckets = (bucket_t *)calloc(bytes, 1);
// ⚠️
// extern void *realloc(void *mem_address, unsigned int newsize);
//（數據類型*）realloc（要改變內存大小的指針名，新的大小）
// 新的大小可大可小，若是新的大小大於原內存大小，則新分配部分不會被初始化；若是新的大小小於原內存大小，可能會致使數據丟失。
// 注意事項: 重分配成功舊內存會被自動釋放，舊指針變成了野指針。
// 返回值: 若是從新分配成功則返回指向被分配內存的指針，不然返回空指針 NULL。
// 先判斷當前的指針是否有足夠的連續空間，若是有，擴大 mem_address 指向的地址，而且將 mem_address 返回，
// 若是空間不夠，先按照 newsize 指定的大小分配空間，將原有數據從頭至尾拷貝到新分配的內存區域，
// 然後釋放原來 mem_address 所指內存區域（注意：原來指針是自動釋放，不須要使用 free），
// 同時返回新分配的內存區域的首地址，即從新分配存儲器塊的地址。
// 對 emptyBucketsList 進行擴容
emptyBucketsList = (bucket_t**)
realloc(emptyBucketsList, newListCount * sizeof(bucket_t *));
// Share newBuckets for every un-allocated size smaller than index.
// 對於每一個小於索引的未分配大小，Share newBucket。
// The array is therefore always fully populated.
// 所以，array 始終老是徹底填充。
// 把新擴容的 emptyBucketsList 的新位置上都放上 newBuckets
for (mask_t i = emptyBucketsListCount; i < newListCount; i++) {
// 把新擴容的 emptyBucketsList 的 新位置上都放上 newBuckets
emptyBucketsList[i] = newBuckets;
}
// 更新 emptyBucketsListCount，且 emptyBucketsListCount 是函數內的靜態局部變量，
// 函數進來 emptyBucketsListCount 都保持上次的值
emptyBucketsListCount = newListCount;
// OPTION( PrintCaches, OBJC_PRINT_CACHE_SETUP, "log processing of method caches")
if (PrintCaches) {
// 若是開啓了 OBJC_PRINT_CACHE_SETUP 則打印
_objc_inform("CACHES: new empty buckets at %p (capacity %zu)",
newBuckets, (size_t)capacity);
}
}
return emptyBucketsList[index];
}
複製代碼
CONFIG_USE_CACHE_LOCK
emptyBucketsForCapacity 函數實現第一行就是一個 CONFIG_USE_CACHE_LOCK 宏定義，它是用來標誌 emptyBucketsForCapacity 函數使用 cacheUpdateLock 仍是 runtimeLock，注意這裏針對的是 Objective-C 的版本，__OBJC2__ 下使用的是 runtimeLock 不然使用 cacheUpdateLock。
// OBJC_INSTRUMENTED controls whether message dispatching is dynamically monitored.
// OBJC_INSTRUMENTED 控制是否動態監視消息調度。
// Monitoring introduces substantial overhead.
// 監控會帶來大量開銷。
// NOTE: To define this condition, do so in the build command, NOT by uncommenting the line here.
// NOTE: 若要定義此條件，請在 build 命令中執行此操做，而不是取消下面 OBJC_INSTRUMENTED 的註釋。
// This is because objc-class.h heeds this condition, but objc-class.h can not
// #include this file (objc-config.h) because objc-class.h is public and objc-config.h is not.
// 這是由於 objc-class.h 注意到了這個條件，可是 objc-class.h 不能包括這個文件（objc-config.h），
// 由於 objc-class.h 是公共的，而 objc-config.h 不是。
//#define OBJC_INSTRUMENTED
// --------------- 以上與 CONFIG_USE_CACHE_LOCK 無關
// In __OBJC2__, the runtimeLock is a mutex always held hence the cache
// lock is redundant and can be elided.
// 在 __OBJC2__ 中，runtimeLock 是 "始終保持" 的互斥鎖，所以 cache lock 是多餘的，能夠忽略。
// (始終保持那裏的意思是指 runtime Lock 始終是一個互斥鎖嗎？)
// If the runtime lock ever becomes a rwlock again, the cache lock would need to be used again.
// 若是 runtime lock 再次變爲 rwlock，則須要再次使用 cache lock。
// 可在 objc-runtime-new.mm 中看到以下定義，代表 cacheUpdateLock 只是一個在舊版本中使用的鎖
// #if CONFIG_USE_CACHE_LOCK
// mutex_t cacheUpdateLock;
// #endif
#if __OBJC2__
#define CONFIG_USE_CACHE_LOCK 0 // Objective-C 2.0 下是 0
#else
#define CONFIG_USE_CACHE_LOCK 1 // 其餘狀況下是 1
#endif
// 對應與以下調用：
#if CONFIG_USE_CACHE_LOCK
cacheUpdateLock.assertLocked();
#else
// extern mutex_t runtimeLock; 在 objc-locks-new.h 中一個外聯聲明
// mutex_t runtimeLock; 在 objc-runtime-new.mm Line 75 定義（類型是互斥鎖）
// assertLocked 進行加鎖，若是加鎖失敗是致使斷言
runtimeLock.assertLocked(); // 在 __OBJC2__ 下是使用 runtimeLock
#endif
複製代碼
bytesForCapacity
bucket_t 散列數組的總的內存佔用（以字節爲單位）。
size_t cache_t::bytesForCapacity(uint32_t cap) {
// 總容量乘以每一個 bucket_t 的字節大小
return sizeof(bucket_t) * cap;
}
複製代碼
EMPTY_BYTES
// EMPTY_BYTES includes space for a cache end marker bucket.
// EMPTY_BYTES 是包括 緩存結束標記 bucket 的空間。
// This end marker doesn't actually have the wrap-around pointer
// because cache scans always find an empty bucket before they might wrap.
// 這個結束標記實際上沒有 wrap-around 指針，
// 由於緩存掃描老是在可能進行換行以前找到一個空的 bucket。(由於 buckets 的擴容機制)
// 1024 buckets is fairly common.
// 1024 bukcets 很常見。
// 一個 bucket_t 的實例變量的大小應該是 16 字節。
#if DEBUG
// Use a smaller size to exercise heap-allocated empty caches.
// 使用較小的容量來執行堆分配的空緩存。
# define EMPTY_BYTES ((8+1)*16)
#else
# define EMPTY_BYTES ((1024+1)*16)
#endif
複製代碼
getBit/setBit/clearBit
針對 __LP64__ 平臺下的 _flags 的操做。atomic_fetch_or/atomic_fetch_and
#if __LP64__
bool getBit(uint16_t flags) const {
return _flags & flags;
}
void setBit(uint16_t set) {
__c11_atomic_fetch_or((_Atomic(uint16_t) *)&_flags, set, __ATOMIC_RELAXED);
}
void clearBit(uint16_t clear) {
__c11_atomic_fetch_and((_Atomic(uint16_t) *)&_flags, ~clear, __ATOMIC_RELAXED);
}
#endif
複製代碼
FAST_CACHE_ALLOC_MASK
// Fast Alloc fields:
// This stores the word-aligned size of instances + "ALLOC_DELTA16",
// or 0 if the instance size doesn't fit.
// 它存儲實例的字對齊大小 + "ALLOC_DELTA16"，若是實例大小不適合，則存儲 0。
// These bits occupy the same bits than in the instance size,
// so that the size can be extracted with a simple mask operation.
// 這些位佔用與實例大小相同的位，所以能夠經過簡單的掩碼操做提取大小。
// FAST_CACHE_ALLOC_MASK16 allows to extract the instance size rounded
// rounded up to the next 16 byte boundary, which is a fastpath for _objc_rootAllocWithZone()
// FAST_CACHE_ALLOC_MASK16 容許提取四捨五入到下一個 16 字節邊界的實例大小，
// 這是 _objc_rootAllocWithZone() 的快速路徑
#define FAST_CACHE_ALLOC_MASK 0x1ff8 // 0b0001 1111 1111 1000
#define FAST_CACHE_ALLOC_MASK16 0x1ff0 // 0b0001 1111 1111 0000
#define FAST_CACHE_ALLOC_DELTA16 0x0008 // 0b0000 0000 0000 1000
複製代碼
hasFastInstanceSize/fastInstanceSize/setFastInstanceSize
在 __LP64__ 平臺下，cache_t 多了一個 uint16_t _flags。如下函數是根據 _flags 中的一些標誌位作出不一樣的處理。這些個函數內容都是給 objc_class 用的，本篇的內容是針對的都是方法緩存的學習，等到 objc_class 篇再詳細分析下面的函數。
#if FAST_CACHE_ALLOC_MASK
bool hasFastInstanceSize(size_t extra) const {
if (__builtin_constant_p(extra) && extra == 0) {
// 若是 extra 在編譯時是常量且值爲 0，則 _flags & 0b0001 1111 1111 0000 的值返回，
// 判斷 cache_t 是否有快速實例化的大小
return _flags & FAST_CACHE_ALLOC_MASK16;
}
// 返回 _flags & 0b0001 1111 1111 1000 的值
return _flags & FAST_CACHE_ALLOC_MASK;
}
// 快速實例化的大小
size_t fastInstanceSize(size_t extra) const {
// 斷言
ASSERT(hasFastInstanceSize(extra));
if (__builtin_constant_p(extra) && extra == 0) {
// 若是 extra 在編譯時是常量且值爲 0，則直接返回 _flags & 0b0001 1111 1111 0000 的值
return _flags & FAST_CACHE_ALLOC_MASK16;
} else {
// size = _flags & 0b0001 1111 1111 1000
size_t size = _flags & FAST_CACHE_ALLOC_MASK;
// remove the FAST_CACHE_ALLOC_DELTA16 that was added by setFastInstanceSize
// 刪除由 setFastInstanceSize 添加的 FAST_CACHE_ALLOC_DELTA16
// static inline size_t align16(size_t x) {
// return (x + size_t(15)) & ~size_t(15);
// }
// align16 函數是計算大於等於 x 的最小的 16 的倍數，即計算 16 字節對齊時的長度
// 0b1000 8
// 0b1111 15
// 0b0001 0111 8 + 15 = 23
// &
// 0b0000 ~15
// 0b0001 0000 16
// 16 字節對齊
return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
}
}
// 設置快速實例化的大小
void setFastInstanceSize(size_t newSize) {
// Set during realization or construction only. No locking needed.
// 僅在 實現 或 構造 期間設置。不須要加鎖。
// #define FAST_CACHE_ALLOC_MASK 0x1ff8 // 0b0001 1111 1111 1000
// _flags & 0b1110 0000 0000 0111
uint16_t newBits = _flags & ~FAST_CACHE_ALLOC_MASK;
uint16_t sizeBits;
// Adding FAST_CACHE_ALLOC_DELTA16 allows for FAST_CACHE_ALLOC_MASK16 to yield
// the proper 16byte aligned allocation size with a single mask.
// 添加 FAST_CACHE_ALLOC_DELTA16 容許 FAST_CACHE_ALLOC_MASK16 經過單個掩碼產生正確的 16 字節對齊的分配大小。
// #ifdef __LP64__
// # define WORD_MASK 7UL
// #else
// # define WORD_MASK 3UL
// #endif
// 0b0101 5
// 0b0111 7
// 0b1100 5 + 7
// 0b1000 ~7
// &
// 0b1000 // 8
// static inline size_t word_align(size_t x) {
// return (x + WORD_MASK) & ~WORD_MASK;
// }
// word_align 函數是進行字對齊，即 8 字節對齊
// newSize 8 字節對齊
sizeBits = word_align(newSize) + FAST_CACHE_ALLOC_DELTA16;
// 與操做
sizeBits &= FAST_CACHE_ALLOC_MASK;
if (newSize <= sizeBits) {
// 或操做
newBits |= sizeBits;
}
// _flags 賦值
_flags = newBits;
}
#else
// 不支持 FAST_CACHE_ALLOC_MASK 時，返回 false
bool hasFastInstanceSize(size_t extra) const {
return false;
}
size_t fastInstanceSize(size_t extra) const {
// 直接 abort
abort();
}
void setFastInstanceSize(size_t extra) {
// nothing
}
#endif
複製代碼
__builtin_constant_p
__builtin_constant_p 是編譯器 gcc 內置函數，用於判斷一個值是否爲編譯時常量，若是是常數，函數返回 1 ，不然返回 0。此內置函數的典型用法是在宏中用於手動編譯時優化。
// 在 main.m 中作以下測試：
printf("😊😊 %d\n", __builtin_constant_p(101)); // 打印: 😊😊 1
constexpr int a = 12 * 13;
printf("😊😊 %d\n", __builtin_constant_p(a)); // 打印: 😊😊 1
int a = 12 * 13;
printf("😊😊 %d\n", __builtin_constant_p(a)); // 打印: 😊😊 0
複製代碼
endMarker
// CACHE_END_MARKER 值爲 1 時，定義 endMarker 函數
bucket_t *cache_t::endMarker(struct bucket_t *b, uint32_t cap) {
// 最後一個 bucket_t 的指針，-1 是從內存末尾再前移一個 bucket_t 的寬度，
// 這裏是先把 bucket_t 指針轉化爲一個 unsigned long，而後加上 cap 的字節總數，
// 而後轉化爲 bucket_t 指針，而後再退一個指針的寬度，即 cache_t 哈希數組的最後一個 bucket_t 的位置。
return (bucket_t *)((uintptr_t)b + bytesForCapacity(cap)) - 1;
}
複製代碼
CACHE_END_MARKER
標記是否支持 cache_t 的 buckets 散列數組的內存末尾標記。
#if __arm__ || __x86_64__ || __i386__
// objc_msgSend has few registers available.
// objc_msgSend 可用寄存器不多。
// Cache scan increments and wraps at special end-marking bucket.
// 緩存掃描增量包裹在特殊的末端標記桶上。
#define CACHE_END_MARKER 1 // 定爲 1
static inline mask_t cache_next(mask_t i, mask_t mask) {
return (i+1) & mask;
}
#elif __arm64__
// objc_msgSend has lots of registers available.
// objc_msgSend 有不少可用的寄存器。
// Cache scan decrements. No end marker needed.
// 緩存掃描減量，無需結束標記。
#define CACHE_END_MARKER 0 // 定爲 0
static inline mask_t cache_next(mask_t i, mask_t mask) {
return i ? i-1 : mask;
}
#else
// 未知的架構
#error unknown architecture
#endif
複製代碼
reallocate
ALWAYS_INLINE void cache_t::reallocate(mask_t oldCapacity, mask_t newCapacity, bool freeOld) {
// 一個臨時變量用於記錄舊的散列表
bucket_t *oldBuckets = buckets();
// 爲新散列表申請指定容量的空間
bucket_t *newBuckets = allocateBuckets(newCapacity);
// Cache's old contents are not propagated.
// 緩存的舊內容不會傳播。
// This is thought to save cache memory at the cost of extra cache fills.
// 這被認爲是以額外的緩存填充爲代價來節省緩存內存的。
// fixme re-measure this 從新測量
ASSERT(newCapacity > 0);
ASSERT((uintptr_t)(mask_t)(newCapacity-1) == newCapacity-1);
// 設置 buckets 和 mask
setBucketsAndMask(newBuckets, newCapacity - 1);
if (freeOld) {
// 這裏不是當即釋放舊的 bukckts，而是將舊的 buckets 添加到存放舊散列表的列表中，以便稍後釋放，注意這裏是稍後釋放。
cache_collect_free(oldBuckets, oldCapacity);
}
}
複製代碼
allocateBuckets
#if CACHE_END_MARKER
bucket_t *allocateBuckets(mask_t newCapacity) {
// Allocate one extra bucket to mark the end of the list.
// 分配一個額外的 bucket 以標記列表的末尾。
// This can't overflow mask_t because newCapacity is a power of 2.
// 由於 newCapacity 是 2 的冪，因此它不會溢出 mask_t。
// 申請 sizeof(bucket_t) * newCapacity 個長度爲 1 的連續內存空間，且內存初始化爲 0
bucket_t *newBuckets = (bucket_t *)
calloc(cache_t::bytesForCapacity(newCapacity), 1);
// end 標記的 bucket_t
bucket_t *end = cache_t::endMarker(newBuckets, newCapacity);
#if __arm__
// arm 32位架構下
// End marker's sel is 1 and imp points BEFORE the first bucket.
// 結束標記的 sel 爲1，imp 指向第一個 bucket 以前。
// This saves an instruction in objc_msgSend.
// 這會將指令保存在 objc_msgSend 中。
// bucket_t 的 set 函數，設置 _sel 和 _imp，_imp 設置爲了 (newBuckets - 1)
// _sel 設置爲 1
end->set<NotAtomic, Raw>((SEL)(uintptr_t)1, (IMP)(newBuckets - 1), nil);
#else
// 其餘
// End marker's sel is 1 and imp points to the first bucket.
// 結束標記的 sel 爲1，imp 指向第一個存儲桶。
end->set<NotAtomic, Raw>((SEL)(uintptr_t)1, (IMP)newBuckets, nil);
#endif
// 緩存容量統計
if (PrintCaches) recordNewCache(newCapacity);
return newBuckets;
}
#else
bucket_t *allocateBuckets(mask_t newCapacity) {
// 緩存容量統計
if (PrintCaches) recordNewCache(newCapacity);
// 申請 sizeof(bucket_t) * newCapacity 個長度爲 1 的連續內存空間，且內存初始化爲 0
return (bucket_t *)calloc(cache_t::bytesForCapacity(newCapacity), 1);
}
#endif
複製代碼
cache_collect_free
cache_collect_free 函數聲明在 objc-cache.mm 文件頂部，定義在 objc-cache.mm 的 Line 977。
/* cache_collect_free. Add the specified malloc'd memory to the list of them to free at some later point. 將指定的已分配內存（待釋放的方法列表）添加到它們的列表中，以便稍後釋放。 size is used for the collection threshold. It does not have to be precisely the block's size. size 用於收集閾值。它沒必要精確地是 塊 的大小。 Cache locks: cacheUpdateLock must be held by the caller. cacheUpdateLock 必須由調用方持有。須要加鎖。（__objc2__ 下使用的是 runtimeLock） */
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);
// 爲 garbage 準備空間，須要時進行擴容
_garbage_make_room ();
// 增長 garbage_byte_size 的值
garbage_byte_size += cache_t::bytesForCapacity(capacity);
// 把舊的 buckets 放進 garbage_refs 中，garbage_count 並自增 1
garbage_refs[garbage_count++] = data;
// 嘗試去釋放累積的舊緩存（bucket_t）
cache_collect(false);
}
複製代碼
_garbage_make_room
一樣 _garbage_make_room 函數聲明在 objc-cache.mm 頂部，定義在 objc-cache.mm 的 Line 947。
/* _garbage_make_room. Ensure that there is enough room for at least one more ref in the garbage. 確保 garbage 中有足夠的空間容納至少一個引用。 */
// amount of memory represented by all refs in the garbage.
// garbage 中全部引用所表示的內存量。
static size_t garbage_byte_size = 0;
// do not empty the garbage until garbage_byte_size gets at least this big.
// 在 garbage 中字節大小（garbage_byte_size）至少達到這麼大（garbage_threshold）以前，不要清空 garbage。
static size_t garbage_threshold = 32*1024;
// table of refs to free.
// bucket_t **
static bucket_t **garbage_refs = 0;
// current number of refs in garbage_refs.
// 當前 garbage_refs 中 bucket_t * 的數量。
static size_t garbage_count = 0;
// capacity of current garbage_refs.
// 當前 garbage_refs 的容量。
static size_t garbage_max = 0;
// capacity of initial garbage_refs
// 初始 garbage_refs 的容量。
enum {
INIT_GARBAGE_COUNT = 128
};
static void _garbage_make_room(void)
{
static int first = 1; // 靜態局部變量，下次進來 first 依然是上次的值
// Create the collection table the first time it is needed
// 第一次須要時建立收集表
if (first)
{
first = 0; // 此處置爲 0 後，之後調用 _garbage_make_room 不再會進到這個 if
// 申請初始空間
// 申請 INIT_GARBAGE_COUNT * sizeof(void *) 字節個空間。
// (malloc 不會對空間進行初始化，會保持申請時的垃圾數據)
garbage_refs = (bucket_t**)malloc(INIT_GARBAGE_COUNT * sizeof(void *));
// 當前 garbage_refs 的容量是 INIT_GARBAGE_COUNT
garbage_max = INIT_GARBAGE_COUNT;
}
// Double the table if it is full
// 若是當前 garbage_refs 中 refs 的數量等於 garbage_max 就對 garbage_refs 擴容爲當前的 2 倍
else if (garbage_count == garbage_max)
{
// garbage_refs 擴容爲 2 倍
garbage_refs = (bucket_t**)
realloc(garbage_refs, garbage_max * 2 * sizeof(void *));
// 更新 garbage_max 爲 2 倍
garbage_max *= 2;
}
}
複製代碼
cache_collect
/* cache_collect. Try to free accumulated dead caches. 嘗試釋放累積的死緩存。 collectALot tries harder to free memory. collectALot 若是爲 true 則即便 garbage_byte_size 未達到閥值也會去釋放內存（舊的 bucket_t）。 Cache locks: cacheUpdateLock must be held by the caller. cacheUpdateLock 必須由調用方持有，須要加鎖。（__objc2__ 下使用的是 runtimeLock） */
void cache_collect(bool collectALot) {
#if CONFIG_USE_CACHE_LOCK
cacheUpdateLock.assertLocked();
#else
runtimeLock.assertLocked(); // 加鎖，加鎖失敗會執行斷言
#endif
// Done if the garbage is not full
// 若是 garbage 未滿，則返回
// 32*1024
// 未達到釋放閥值，且 collectALot 爲 false
if (garbage_byte_size < garbage_threshold && !collectALot) {
return;
}
// Synchronize collection with objc_msgSend and other cache readers.
// objc_msgSend 和其餘 緩存讀取器 同步收集。
if (!collectALot) {
if (_collecting_in_critical ()) {
// objc_msgSend (or other cache reader) is currently looking in the cache and might still be using some garbage.
// objc_msgSend（或其餘緩存讀取器）當前正在緩存中查找，而且可能仍在使用某些 garbage。
// 打印
if (PrintCaches) {
_objc_inform ("CACHES: not collecting; "
"objc_msgSend in progress");
}
// 直接 return
return;
}
}
else {
// No excuses.
// 一直循環直到 _collecting_in_critical 爲 false.
while (_collecting_in_critical())
;
}
// No cache readers in progress - garbage is now deletable.
// 沒有正在進行中的 緩存讀取器 如今能夠刪除 garbage 了。
// Log our progress
// Log
if (PrintCaches) {
cache_collections++; // 自增
// 打印 garbage_byte_size garbage 使用的字節 cache_allocations 分配了多少 cache_t
_objc_inform ("CACHES: COLLECTING %zu bytes (%zu allocations, %zu collections)", garbage_byte_size, cache_allocations, cache_collections);
}
// Dispose all refs now in the garbage.
// 處理 garbage 中的全部 refs。
// Erase each entry so debugging tools don't see stale pointers.
// 擦除每一個條目，以便調試工具不會看到過期的指針。
// 循環釋放 garbage_refs 中的 bucket_t *
while (garbage_count--) {
auto dead = garbage_refs[garbage_count];
garbage_refs[garbage_count] = nil;
free(dead);
}
// Clear the garbage count and total size indicator.
// garbage_count 和 garbage_byte_size 置 0。
garbage_count = 0;
garbage_byte_size = 0;
// 打印 Cache statistics 中的內容
if (PrintCaches) {
size_t i;
size_t total_count = 0;
size_t total_size = 0;
for (i = 0; i < countof(cache_counts); i++) {
int count = cache_counts[i];
int slots = 1 << i;
size_t size = count * slots * sizeof(bucket_t);
if (!count) continue;
_objc_inform("CACHES: %4d slots: %4d caches, %6zu bytes",
slots, count, size);
total_count += count;
total_size += size;
}
_objc_inform("CACHES: total: %4zu caches, %6zu bytes",
total_count, total_size);
}
}
複製代碼
_collecting_in_critical
一樣 _collecting_in_critical 函數聲明在 objc-cache.mm 頂部，定義在 objc-cache.mm 的 Line 838。 返回 true 表示 objc_msgSend（或其餘緩存讀取器（cache reader））當前正在緩存中查找，而且可能仍在使用某些 garbage。返回 false 的話表示 garbage 中的 bucket_t 沒有被在使用。
static int _collecting_in_critical(void)
{
#if TARGET_OS_WIN32 // 若是是 TARGET_OS_WIN32 則一直返回 true
return TRUE;
#elif HAVE_TASK_RESTARTABLE_RANGES (arm64 和 x86_64 都支持)
// Only use restartable ranges if we registered them earlier.
// 若是咱們較早註冊它們，請僅使用 restartable ranges。
// #if HAVE_TASK_RESTARTABLE_RANGES
// static bool shouldUseRestartableRanges = true;
// #endif
if (shouldUseRestartableRanges) {
// typedef int kern_return_t;
kern_return_t kr = task_restartable_ranges_synchronize(mach_task_self());
if (kr == KERN_SUCCESS) return FALSE; // return FALSE 表示 garbage 沒有被在使用，此時處於可清空狀態。
（若是 collectALot 爲真則表示必須清空，若是是不可清空狀態則會一直等待，上面的 while (_collecting_in_critical()) ; ）
_objc_fatal("task_restartable_ranges_synchronize failed (result 0x%x: %s)",
kr, mach_error_string(kr));
}
#endif // !HAVE_TASK_RESTARTABLE_RANGES
// Fallthrough if we didn't use restartable ranges.
// 若是咱們不使用 restartable ranges，則會失敗。
thread_act_port_array_t threads;
unsigned number;
unsigned count;
kern_return_t ret;
int result;
// objc_thread_self: (pthread_t)tls_get_direct(_PTHREAD_TSD_SLOT_PTHREAD_SELF);
// 從線程的存儲空間讀取
mach_port_t mythread = pthread_mach_thread_np(objc_thread_self());
// Get a list of all the threads in the current task.
// 獲取當前任務中全部線程的列表。
#if !DEBUG_TASK_THREADS
ret = task_threads(mach_task_self(), &threads, &number);
#else
ret = objc_task_threads(mach_task_self(), &threads, &number);
#endif
if (ret != KERN_SUCCESS) {
// See DEBUG_TASK_THREADS below to help debug this.
// 請參閱下面的 DEBUG_TASK_THREADS 來幫助調試。
_objc_fatal("task_threads failed (result 0x%x)\n", ret);
}
// Check whether any thread is in the cache lookup code.
// 檢查緩存查找代碼中是否有線程。
result = FALSE;
for (count = 0; count < number; count++)
{
int region;
uintptr_t pc;
// Don't bother checking ourselves.
// 不要打擾本身
if (threads[count] == mythread)
continue;
// Find out where thread is executing.
// 找出線程在哪裏執行。
pc = _get_pc_for_thread (threads[count]);
// Check for bad status, and if so, assume the worse (can't collect).
// 檢查狀態是否良好，若是是，則假設狀況更糟（沒法收集）。
if (pc == PC_SENTINEL)
{
result = TRUE;
goto done;
}
// Check whether it is in the cache lookup code.
// 檢查它是否在緩存查找代碼中。
for (region = 0; objc_restartableRanges[region].location != 0; region++)
{
uint64_t loc = objc_restartableRanges[region].location;
if ((pc > loc) &&
(pc - loc < (uint64_t)objc_restartableRanges[region].length))
{
result = TRUE;
goto done;
}
}
}
done:
// Deallocate the port rights for the threads
// 取消分配線程的端口權限
for (count = 0; count < number; count++) {
mach_port_deallocate(mach_task_self (), threads[count]);
}
// Deallocate the thread list
// 取消分配線程列表
vm_deallocate (mach_task_self (), (vm_address_t) threads, sizeof(threads[0]) * number);
// Return our finding
// 返回咱們的發現
return result;
}
複製代碼
HAVE_TASK_RESTARTABLE_RANGES
// Define HAVE_TASK_RESTARTABLE_RANGES to enable usage of task_restartable_ranges_synchronize().
// 定義 HAVE_TASK_RESTARTABLE_RANGES 以啓用使用 task_restartable_ranges_synchronize() 函數。
#if TARGET_OS_SIMULATOR || defined(__i386__) || defined(__arm__) || !TARGET_OS_MAC
# define HAVE_TASK_RESTARTABLE_RANGES 0
#else
# define HAVE_TASK_RESTARTABLE_RANGES 1
#endif
複製代碼
task_restartable_ranges_synchronize
/*! * @function task_restartable_ranges_synchronize * * @brief * Require for all threads in the task to reset their PC if within a restartable range. * 若是在可從新啓動的範圍內，則要求任務中的全部線程重置其 PC。 * * @param task * The task to operate on (needs to be current task) * 要執行的任務（須要是當前任務） * @returns * - KERN_SUCCESS * - KERN_FAILURE if the task isn't the current one 若是任務不是當前任務 */
extern kern_return_t task_restartable_ranges_synchronize(task_t task);
複製代碼
cache_t 的內容先分析到這裏，下篇咱們接着來看 cache_t 剩餘的 insert 和 bad_cache，以及最重要的 objc-cache.h 文件中聲明的一系列方法，正是它們完整構成了方法緩存的實現。
參考連接
參考連接:🔗
相關文章
- 1. iOS的方法緩存（cache_t）是如何實現的
- 2. iOS-runtime的理解
- 3. iOS RunTime解析
- 4. myBatis源碼解析-緩存篇（2）
- 5. iOS runtime （二）（runtime學習之AutoCoding源碼分析）
- 6. 內存相關內容
- 7. 靜態內容實現緩存的七種不一樣方法
- 8. Runtime源碼解析（JDK1.8）
- 9. MyBatis緩存實現源碼分析
- 10. 聚焦http協議緩存策略（RFC7234）在okhttp中的實現
- 更多相關文章...
- • Hibernate整合EHCache實現二級緩存 - Hibernate教程
- • XML 相關技術 - XML 教程
- • NewSQL-TiDB相關
- • 三篇文章瞭解 TiDB 技術內幕——說存儲
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
