消息的慢速查找流程

Posted 2021-08-02 WeaterMr

消息的慢速查找流程

lookUpImpOrForward 慢速查找核心函数

在cache内查找bucket_t的过程中，如果查找了所有的缓存也无法命中的时候，接下来就要进入消息的慢速查找流程了，也就是由汇编查找 -> C/C++代码查找。
为什么缓冲以汇编的形式来查找？

• 1.这个流程更加接近机器语言执行快，更快的让对象找到方法。
• 2.可变参数未知，和c语言（比较明确的参数类型）的特性有冲突，而汇编更加动态化。

NEVER_INLINE
IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    //创建forward_imp，并给定默认值_objc_msgForward_impcache
    const IMP forward_imp = (IMP)_objc_msgForward_impcache;
    //创建imp，用于接收通过sel查找的imp
    IMP imp = nil;
    //创建要查找的类，这个类通过isa的指向关系是会一直变化的，
    //直到最终指向NSObject的父类nil为止
    Class curClass;

    runtimeLock.assertUnlocked();

    if (slowpath(!cls->isInitialized())) {
        /**
        发送到类的第一条消息通常是 +new 或 +alloc 或 +self
        但是，此时该类尚未初始化，此时behavior = 3｜8 = 11
        当向将上+new等这些方法inset进缓存的时候
        不满足behavior & LOOKUP_NOCACHE) == 0这个条件，8 & 11 = 8
        所以上述这些方法不会加载进缓存。
        
        如果类已经初始化了，就不会修改behavior的值了，behavior=3
        我们自定义的方法是可以正常加载进缓存的。
        */
        behavior |= LOOKUP_NOCACHE;
    }

    // runtimeLock 在 isRealized 和 isInitialized 检查期间被持有
    // 防止与并发实现竞争。
    runtimeLock.lock();

    //检查类是否被注册了
    checkIsKnownClass(cls);

    /**初始化跟cls实例对象在isa指向图中的每一个类（class和metaClass）
    以便后续自己类里面找不到方法去父类里面找
    依次向上找
    所以在此处对所有相关的类进行了初始化
    */
    cls = realizeAndInitializeIfNeeded_locked(inst, cls, behavior & LOOKUP_INITIALIZE);
    // runtimeLock may have been dropped but is now locked again
    runtimeLock.assertLocked();
    //curClass为当前实例对象的类
    curClass = cls;

    /**
    * 循环查找类对象的methodList，当前类没有的话就找父类
    * 父类没有就找父类的父类，一直找到NSObject类
    * 如果NSObject都找不到的话最终curClass会指向nil
    * 将事先准备好的forward_imp赋值给imp
    * 然后结束慢速查找流程，接下来进入Runtime消息转发机制
    */
    for (unsigned attempts = unreasonableClassCount();;) {
        if (curClass->cache.isConstantOptimizedCache(/* strict */true)) {
#if CONFIG_USE_PREOPT_CACHES
            /**
            * 第一步先找共享缓存里面有没有我们的方法
            * 通常情况下我们的自定义方法不会出现在共享缓存中
            */
            imp = cache_getImp(curClass, sel);
            if (imp) goto done_unlock;
            curClass = curClass->cache.preoptFallbackClass();
#endif
        } else {
            /**
            *在当前类的方法列表里面查找，这是重点
            *查找算法是二分法
            */
            Method meth = getMethodNoSuper_nolock(curClass, sel);
            if (meth) {
                imp = meth->imp(false);
                goto done;
            }
            /**
            *如果当前类找不到，取将curClass指向superclass
            *查询父类的methodList，一直找到NSObject的父类nil为止
            * 将事先准备好的forward_imp赋值给imp
            * 然后结束慢速查找流程，接下来进入Runtime消息转发机制
            * 结束循环遍历
            */
            if (slowpath((curClass = curClass->getSuperclass()) == nil)) {
                imp = forward_imp;
                break;
            }
        }

        // 类列表中的内存损坏
        if (slowpath(--attempts == 0)) {
            _objc_fatal("Memory corruption in class list.");
        }

        // 在父类的缓存中查找，这里再次进入汇编查找流程
        imp = cache_getImp(curClass, sel);
        //如果没有找到，将默认的forward_imp赋值给imp
        if (slowpath(imp == forward_imp)) {
            // Found a forward:: entry in a superclass.
            // Stop searching, but don't cache yet; call method
            // resolver for this class first.
            break;
        }
        //如果找到了
        if (fastpath(imp)) {
            //将找到的method插入到缓存中，以便下次查找使用快速缓存查找
            goto done;
        }
    }

    // No implementation found. Try method resolver once.

    if (slowpath(behavior & LOOKUP_RESOLVER)) {
        behavior ^= LOOKUP_RESOLVER;
        return resolveMethod_locked(inst, sel, cls, behavior);
    }

//找到了sel对应的imp，将method方法加载进缓存
 done:
    if (fastpath((behavior & LOOKUP_NOCACHE) == 0)) {
#if CONFIG_USE_PREOPT_CACHES
        while (cls->cache.isConstantOptimizedCache(/* strict */true)) {
            cls = cls->cache.preoptFallbackClass();
        }
#endif
        log_and_fill_cache(cls, imp, sel, inst, curClass);
    }
 done_unlock:
    runtimeLock.unlock();
    if (slowpath((behavior & LOOKUP_NIL) && imp == forward_imp)) {
        return nil;
    }
    return imp;
}

方法解析：

• if (slowpath(!cls->isInitialized())) 判断是否初始化
• checkIsKnownClass(cls); 检查类是否被注册到当前类的缓存表里面。
• cls = realizeAndInitializeIfNeeded_locked(inst, cls, behavior & LOOKUP_INITIALIZE); 类->类父类->NSObject->nil 流程的初始化；元类->元类父类->NSObject->nil的初始化。将对应的类与元类递归初始化其目的主要是为了通过继承链寻找方法。（主要是对ro，rw中对应的m_list，p_list查询）
• for (unsigned attempts = unreasonableClassCount();;) 通过for循环查找方法。先查找自己的methodlist，找父类的methodlist，找NSObject methodlist.-跳出循环 （这里的循环查找，当前类如果找不到对应的方法，会将当前类重置为空，然后跳过，继续找当前循环）
• Method meth = getMethodNoSuper_nolock(curClass, sel); 当自己查找不到时，将当前的查询置为父类。
• #if CONFIG_USE_PREOPT_CACHES首先到共享缓存中查找，这样做的目的，可能在类与元类递归初始化是调用了某些方法，正好写入缓存。
• Method meth = getMethodNoSuper_nolock(curClass, sel); 这里有一点要注意，methlist可能是一个二维数组，二分法方法查找，下面做补充。
• log_and_fill_cache(cls, imp, sel, inst, curClass);缓存的写入，当我们第一次查找到对应的方法时，会把当前的方法写入到缓存。
• if (slowpath(behavior & LOOKUP_RESOLVER)) 单例，只执行一次

getMethodNoSuper_nolock二分查找

static method_t *
getMethodNoSuper_nolock(Class cls, SEL sel)
{
    runtimeLock.assertLocked();

    ASSERT(cls->isRealized());

    //获取methodList，methodList因为数据类型的原因可能为二维数组
    //循环条件是数组不为空，即开始位置不等于结束位置
    auto const methods = cls->data()->methods();
    for (auto mlists = methods.beginLists(),
              end = methods.endLists();
         mlists != end;
         ++mlists)
    {
        //进入search_method_list_inline修复为有序list
        method_t *m = search_method_list_inline(*mlists, sel);
        if (m) return m;
    }

    return nil;
}

search_method_list_inline(const method_list_t *mlist, SEL sel)
{
    int methodListIsFixedUp = mlist->isFixedUp();
    int methodListHasExpectedSize = mlist->isExpectedSize();
    
    if (fastpath(methodListIsFixedUp && methodListHasExpectedSize)) {
        return findMethodInSortedMethodList(sel, mlist);
    } else {
        // Linear search of unsorted method list
        if (auto *m = findMethodInUnsortedMethodList(sel, mlist))
            return m;
    }

    return nil;
}

ALWAYS_INLINE static method_t *
findMethodInSortedMethodList(SEL key, const method_list_t *list)
{
    if (list->isSmallList()) {
        if (CONFIG_SHARED_CACHE_RELATIVE_DIRECT_SELECTORS && objc::inSharedCache((uintptr_t)list)) {
            return findMethodInSortedMethodList(key, list, [](method_t &m) { return m.getSmallNameAsSEL(); });
        } else {
            return findMethodInSortedMethodList(key, list, [](method_t &m) { return m.getSmallNameAsSELRef(); });
        }
    } else {
        return findMethodInSortedMethodList(key, list, [](method_t &m) { return m.big().name; });
    }
}

template<class getNameFunc>
ALWAYS_INLINE static method_t *
findMethodInSortedMethodList(SEL key, const method_list_t *list, const getNameFunc &getName)
{
    ASSERT(list);
    //开始位置：0
    auto first = list->begin();
    //base开始也为0
    auto base = first;
    //probe也为0
    decltype(first) probe;
    //要查找imp对应的sel
    uintptr_t keyValue = (uintptr_t)key;
    //list的个数
    uint32_t count;
    
    /**
    * 举例：假设要查找的sel在第7位
    * 首先count = list.count,这里假定count=8
    * 进入循环，probe = base + （ 8 >> 1 ） = 0 + 4 = 4
    * 那么第一次查找的范围就是4-8，匹配元素位置是4，判定结果keyValue（7）> prebeValue(4)，未匹配
    * 满足keyValue > probeValue，base = probe + 1 = 4 + 1 = 5，count-- = 7
    * 第二次进入循环，此时count = 7 >> 1 = 3, probe = 5 + 3 >> 1 = 6
    * 第二次查找的范围是6-7，匹配元素位置是6，判定结果keyValue（7）> prebeValue(6)，未匹配
    * 满足keyValue > probeValue，base = probe + 1 = 6 + 1 = 7，count-- = 2
    * 第三次进入循环，此时count = 2 >> 1 = 1, probe = 7 + 1 >> 1 = 7
    * 第三次查找的元素是7，匹配，返回imp
    */
    for (count = list->count; count != 0; count >>= 1) {
        probe = base + (count >> 1);
        
        uintptr_t probeValue = (uintptr_t)getName(probe);
        
        if (keyValue == probeValue) {
            //向前寻找第一个出现的imp，为了避免分类方法于主类方法相同时问题
            //这也就是为什么分类方法会被加载的原因
            while (probe > first && keyValue == (uintptr_t)getName((probe - 1))) {
                probe--;
            }
            return &*probe;
        }
        
        if (keyValue > probeValue) {
            base = probe + 1;
            count--;
        }
    }
    
    return nil;
}