fixup! internals: better representation for code

Author: vtjnash

src/gf.c

@@ -1406,21 +1406,31 @@ static int invalidate_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
     if (oldentry->max_world == ~(size_t)0) {
         jl_method_instance_t *mi = oldentry->func.linfo;
         jl_method_t *m = mi->def.method;
+        int intersects = 0;
         if (jl_is_method(env->shadowed)) {
-            if ((jl_value_t*)m == env->shadowed)
-                oldentry->max_world = env->max_world;
+            if ((jl_value_t*)m == env->shadowed) {
+                intersects = 1;
+            }
         }
         else {
             assert(jl_is_array(env->shadowed));
             jl_typemap_entry_t **d = (jl_typemap_entry_t**)jl_array_ptr_data(env->shadowed);
             size_t i, n = jl_array_len(env->shadowed);
             for (i = 0; i < n; i++) {
                 if (m == d[i]->func.method) {
-                    oldentry->max_world = env->max_world;
-                    return 1;
+                    intersects = 1;
+                    break;
                 }
             }
         }
+        if (intersects) {
+            if (JL_DEBUG_METHOD_INVALIDATION) {
+                jl_uv_puts(JL_STDOUT, "-- ", 4);
+                jl_static_show(JL_STDOUT, (jl_value_t*)mi);
+                jl_uv_puts(JL_STDOUT, "\n", 1);
+            }
+            oldentry->max_world = env->max_world;
+        }
     }
     return 1;
 }
@@ -2118,14 +2128,25 @@ STATIC_INLINE jl_method_instance_t *jl_lookup_generic_(jl_value_t **args, uint32
     jl_methtable_t *mt = NULL;
     int i;
     // check each cache entry to see if it matches
-    for (i = 0; i < 4; i++) {
-        entry = call_cache[cache_idx[i]];
-        if (entry && nargs == jl_svec_len(entry->sig->parameters) &&
-            sig_match_fast(args, jl_svec_data(entry->sig->parameters), 0, nargs) &&
-            world >= entry->min_world && world <= entry->max_world) {
-            break;
-        }
-    }
+    //#pragma unroll
+    //for (i = 0; i < 4; i++) {
+    //    LOOP_BODY(i);
+    //}
+#define LOOP_BODY(_i) do { \
+            i = _i; \
+            entry = call_cache[cache_idx[i]]; \
+            if (entry && nargs == jl_svec_len(entry->sig->parameters) && \
+                sig_match_fast(args, jl_svec_data(entry->sig->parameters), 0, nargs) && \
+                world >= entry->min_world && world <= entry->max_world) { \
+                goto have_entry; \
+            } \
+        } while (0);
+    LOOP_BODY(0);
+    LOOP_BODY(1);
+    LOOP_BODY(2);
+    LOOP_BODY(3);
+#undef LOOP_BODY
+    i = 4;
     // if no method was found in the associative cache, check the full cache
     if (i == 4) {
         JL_TIMING(METHOD_LOOKUP_FAST);
@@ -2136,11 +2157,13 @@ STATIC_INLINE jl_method_instance_t *jl_lookup_generic_(jl_value_t **args, uint32
             // put the entry into the cache if it's valid for a leafsig lookup,
             // using pick_which to slightly randomize where it ends up
             call_cache[cache_idx[++pick_which[cache_idx[0]] & 3]] = entry;
+            goto have_entry;
         }
     }
 
-    jl_method_instance_t *mfunc = NULL;
+    jl_method_instance_t *mfunc;
     if (entry) {
+have_entry:
         mfunc = entry->func.linfo;
     }
     else {
@@ -2177,11 +2200,23 @@ jl_method_instance_t *jl_lookup_generic(jl_value_t **args, uint32_t nargs, uint3
 
 JL_DLLEXPORT jl_value_t *jl_apply_generic(jl_value_t **args, uint32_t nargs)
 {
+    size_t world = jl_get_ptls_states()->world_age;
     jl_method_instance_t *mfunc = jl_lookup_generic_(args, nargs,
                                                      jl_int32hash_fast(jl_return_address()),
-                                                     jl_get_ptls_states()->world_age);
+                                                     world);
     JL_GC_PROMISE_ROOTED(mfunc);
-    jl_value_t *res = jl_invoke(mfunc, args, nargs);
+    jl_value_t *res;
+    // manually inline key parts of jl_invoke:
+    jl_code_instance_t *codeinst = mfunc->cache;
+    while (codeinst) {
+        if (codeinst->min_world <= world && world <= codeinst->max_world && codeinst->invoke != NULL) {
+            res = codeinst->invoke(codeinst, args, nargs);
+            return verify_type(res);
+        }
+        codeinst = codeinst->next;
+    }
+    codeinst = jl_compile_method_internal(mfunc, world);
+    res = codeinst->invoke(codeinst, args, nargs);
     return verify_type(res);
 }
 

src/typemap.c

@@ -1016,8 +1016,14 @@ jl_typemap_entry_t *jl_typemap_insert(jl_typemap_t **cache, jl_value_t *parent,
         if (ml && ml->simplesig == (void*)jl_nothing) {
             if (overwritten != NULL)
                 *overwritten = ml->func.value;
-            if (newvalue == ml->func.value) // no change. TODO: involve world in computation!
+            if (newvalue == ml->func.value) {
+                // just update the existing entry to reflect new knowledge
+                if (ml->min_world > min_world)
+                    ml->min_world = min_world;
+                if (ml->max_world < max_world)
+                    ml->max_world = max_world;
                 return ml;
+            }
             if (newvalue == NULL)  // don't overwrite with guard entries
                 return ml;
             ml->max_world = min_world - 1;