Introduction to the

The ObjC Runtime uses method caching for efficient messaging.

This article mainly records several characteristics of method caching:

  1. There is a method cache for each class, rather than a cache for each object.
  2. The method cache is a hash table.
  3. If a method of the parent class is called, it is added to the cache of the parent class.

The messaging

Just a quick review.

id objc_msgSend(id self, SEL _cmd, …) ; , the process of message passing:

  1. Judge receiver, if nil, return, otherwise 2
  2. Search in method cache, return IMP if found, otherwise 3
  3. In this class “method list” search, if can not find in the parent class search, trace to the source, find after adding to the cache, and return IMP, otherwise trigger forwarding mechanism.

id _objc_msgForward(id self, SEL _cmd,…) ; , message forwarding process:

  1. Can this class be implemented to handle this situation?
  2. Is there a “back-up” that can handle this?
  3. The Runtime System creates an NSInvocaton object, stores the information, and notifies globally who can handle it.

The method cache exists in the class

The cached declaration is concentrated in objc-Runtime-new.h:

// objc-runtime-new.h
struct objc_class : objc_object {
    ...
    cache_tcache; . }Copy the code

You can see from the source that the cache is stored in the class, not in the instance.

The method cache is a hash table

The source code for finding methods from the cache is mainly in objc-cache.mm

// objc-runtime-new.h
struct cache_t {
    // The find function is used as a hash table
    struct bucket_t* _buckets;.struct bucket_t * find(cache_key_t key, id receiver);
}

// objc-cache.mm
bucket_t * cache_t::find(cache_key_t k, id receiver)
{
    assert(k ! =0);

    bucket_t *b = buckets(a);mask_t m = mask(a);// Note by jd: calculate an index based on the key and mask
    mask_t begin = cache_hash(k, m);
    mask_t i = begin;
    do {
        if (b[i].key() = =0  ||  b[i].key() == k) {
            return&b[i]; }}while ((i = cache_next(i, m)) ! = begin);// Handle hash conflicts in parentheses

    // hack
    Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
    cache_t: :bad_cache(receiver, (SEL)k, cls);
}
Copy the code

From the source, the method cache is a hash table.

So why is the method list an array instead of a hash table?

Personally, I think there are the following reasons:

  1. Hash tables, hash computations are expensive, and there are empty Spaces. It’s a waste of space.
  2. Especially in the Category insertion method, if there is a conflict, it will affect the loading efficiency.

Superclass methods are also added to the class cache

When no method is found from the cache, the following function is called.

// objc-runtime-new.mm
/***********************************************************************
* _class_lookupMethodAndLoadCache.
* Method lookup for dispatchers ONLY. OTHER CODE SHOULD USE lookUpImp().
* This lookup avoids optimistic cache scan because the dispatcher
* already tried that.
**********************************************************************/
IMP _class_lookupMethodAndLoadCache3(id obj, SEL sel, Class cls)
{
    return lookUpImpOrForward(cls, sel, obj,
                              YES/*initialize*/, NO/*cache*/, YES/*resolver*/);
}

IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
                       bool initialize, bool cache, bool resolver)
{...// Try superclass caches and method lists.
    {
        unsigned attempts = unreasonableClassCount(a);for(Class curClass = cls->superclass; curClass ! = nil; curClass = curClass->superclass) {// Superclass cache.
            imp = cache_getImp(curClass, sel);
            if (imp) {
                if(imp ! = (IMP)_objc_msgForward_impcache) {// Found the method in a superclass. Cache it in this class.
                    log_and_fill_cache(cls, imp, sel, inst, curClass);
                    goto done;
                }
                else {
                    break; }}// Superclass method list.
            Method meth = getMethodNoSuper_nolock(curClass, sel);
            if (meth) {
                log_and_fill_cache(cls, meth->imp, sel, inst, curClass);
                imp = meth->imp;
                gotodone; }}}... }Copy the code

As you can see from the source code, it will successively search from the parent class cache, method list, and then save it in its own method cache.

summary

The ObjC Runtime uses method caching to improve message delivery efficiency.

It is designed as a hash table that is stored in each class.

In addition, even methods of the parent class are cached in the parent class.

Thank you

NSObject message forwarding mechanism | not bad blog

In-depth understanding of Objective-C: Method Caching – Meituan technical team