Copy over CodeInstances too

timholy · timholy · commit 88a1cbfc366a · 2022-02-20T02:56:05.000-06:00
diff --git a/src/dump.c b/src/dump.c
@@ -2205,17 +2205,20 @@ void remove_code_instance_from_validation(jl_code_instance_t *codeinst)
 
 static void jl_insert_method_instances(jl_array_t *list)
 {
-    size_t i, l = jl_array_len(list), ll = l;
+    size_t i, l = jl_array_len(list);
     // Validate the MethodInstances
+    jl_array_t *valids = jl_alloc_array_1d(jl_array_uint8_type, l);
+    memset(jl_array_data(valids), 1, l);
     size_t world = jl_atomic_load_acquire(&jl_world_counter);
-    for (i = 0; i < ll; i++) {
+    for (i = 0; i < l; i++) {
         jl_method_instance_t *mi = (jl_method_instance_t*)jl_array_ptr_ref(list, i);
         assert(jl_is_method_instance(mi));
         if (jl_is_method(mi->def.method)) {
             // Is this still the method we'd be calling?
             jl_methtable_t *mt = jl_method_table_for(mi->specTypes);
             jl_value_t *mworld = jl_methtable_lookup(mt, mi->specTypes, world);
             if (jl_is_method(mworld) && mi->def.method != (jl_method_t*)mworld) {
+                jl_array_uint8_set(valids, i, 0);
                 invalidate_backedges(&remove_code_instance_from_validation, mi, world, "jl_insert_method_instance");
                 // The codeinst of this mi haven't yet been removed
                 jl_code_instance_t *codeinst = mi->cache;
@@ -2227,13 +2230,10 @@ static void jl_insert_method_instances(jl_array_t *list)
                     jl_array_ptr_1d_push(_jl_debug_method_invalidation, mworld);
                     jl_array_ptr_1d_push(_jl_debug_method_invalidation, jl_cstr_to_string("jl_method_table_insert")); // GC disabled
                 }
-                jl_array_ptr_set(list, i, jl_array_ptr_ref(list, ll-1));
-                jl_array_ptr_set(list, ll-1, mi);
-                ll--;
             }
         }
     }
-    // While it's tempting to just remove the invalidated MIs altogether (loop only up to `ll`),
+    // While it's tempting to just remove the invalidated MIs altogether,
     // this hurts the ability of SnoopCompile to diagnose problems.
     for (i = 0; i < l; i++) {
         jl_method_instance_t *mi = (jl_method_instance_t*)jl_array_ptr_ref(list, i);
@@ -2280,6 +2280,22 @@ static void jl_insert_method_instances(jl_array_t *list)
                     }
                 }
             }
+            // Additionally, if we have CodeInstance(s) and the running CodeInstance is world-limited, transfer it
+            if (mi->cache && jl_array_uint8_ref(valids, i)) {
+                if (!milive->cache || milive->cache->max_world < ~(size_t)0) {
+                    jl_code_instance_t *cilive = milive->cache, *ci;
+                    milive->cache = mi->cache;
+                    jl_gc_wb(milive, milive->cache);
+                    ci = mi->cache;
+                    ci->def = milive;
+                    while (ci->next) {
+                        ci = ci->next;
+                        ci->def = milive;
+                    }
+                    ci->next = cilive;
+                    jl_gc_wb(ci, ci->next);
+                }
+            }
         }
     }
 }
diff --git a/test/precompile.jl b/test/precompile.jl
@@ -787,6 +787,8 @@ precompile_test_harness("code caching") do dir
     end
 
     StaleA = :StaleA_0xab07d60518763a7e
+    StaleB = :StaleB_0xab07d60518763a7e
+    StaleC = :StaleC_0xab07d60518763a7e
     write(joinpath(dir, "$StaleA.jl"),
         """
         module $StaleA
@@ -806,7 +808,6 @@ precompile_test_harness("code caching") do dir
         end
         """
     )
-    StaleB = :StaleB_0xab07d60518763a7e
     write(joinpath(dir, "$StaleB.jl"),
         """
         module $StaleB
@@ -825,7 +826,6 @@ precompile_test_harness("code caching") do dir
         end
         """
     )
-    StaleC = :StaleC_0xab07d60518763a7e
     write(joinpath(dir, "$StaleC.jl"),
         """
         module $StaleC
@@ -852,7 +852,7 @@ precompile_test_harness("code caching") do dir
     world = Base.get_world_counter()
     m = only(methods(MA.use_stale))
     mi = m.specializations[1]
-    @test_broken hasvalid(mi, world)   # it should have been re-inferred by StaleC
+    @test hasvalid(mi, world)   # was re-inferred by StaleC
     m = only(methods(MA.build_stale))
     mis = filter(!isnothing, collect(m.specializations))
     @test length(mis) == 2

Original file line number	Diff line number	Diff line change
`@@ -2205,17 +2205,20 @@ void remove_code_instance_from_validation(jl_code_instance_t *codeinst)`
`2205`	`2205`
`2206`	`2206`	`static void jl_insert_method_instances(jl_array_t *list)`
`2207`	`2207`	`{`
`2208`		`- size_t i, l = jl_array_len(list), ll = l;`
	`2208`	`+ size_t i, l = jl_array_len(list);`
`2209`	`2209`	`// Validate the MethodInstances`
	`2210`	`+ jl_array_t *valids = jl_alloc_array_1d(jl_array_uint8_type, l);`
	`2211`	`+ memset(jl_array_data(valids), 1, l);`
`2210`	`2212`	`size_t world = jl_atomic_load_acquire(&jl_world_counter);`
`2211`		`- for (i = 0; i < ll; i++) {`
	`2213`	`+ for (i = 0; i < l; i++) {`
`2212`	`2214`	`jl_method_instance_t mi = (jl_method_instance_t)jl_array_ptr_ref(list, i);`
`2213`	`2215`	`assert(jl_is_method_instance(mi));`
`2214`	`2216`	`if (jl_is_method(mi->def.method)) {`
`2215`	`2217`	`// Is this still the method we'd be calling?`
`2216`	`2218`	`jl_methtable_t *mt = jl_method_table_for(mi->specTypes);`
`2217`	`2219`	`jl_value_t *mworld = jl_methtable_lookup(mt, mi->specTypes, world);`
`2218`	`2220`	`if (jl_is_method(mworld) && mi->def.method != (jl_method_t*)mworld) {`
	`2221`	`+ jl_array_uint8_set(valids, i, 0);`
`2219`	`2222`	`invalidate_backedges(&remove_code_instance_from_validation, mi, world, "jl_insert_method_instance");`
`2220`	`2223`	`// The codeinst of this mi haven't yet been removed`
`2221`	`2224`	`jl_code_instance_t *codeinst = mi->cache;`
`@@ -2227,13 +2230,10 @@ static void jl_insert_method_instances(jl_array_t *list)`
`2227`	`2230`	`jl_array_ptr_1d_push(_jl_debug_method_invalidation, mworld);`
`2228`	`2231`	`jl_array_ptr_1d_push(_jl_debug_method_invalidation, jl_cstr_to_string("jl_method_table_insert")); // GC disabled`
`2229`	`2232`	`}`
`2230`		`- jl_array_ptr_set(list, i, jl_array_ptr_ref(list, ll-1));`
`2231`		`- jl_array_ptr_set(list, ll-1, mi);`
`2232`		`- ll--;`
`2233`	`2233`	`}`
`2234`	`2234`	`}`
`2235`	`2235`	`}`
`2236`		- // While it's tempting to just remove the invalidated MIs altogether (loop only up to `ll`),
	`2236`	`+ // While it's tempting to just remove the invalidated MIs altogether,`
`2237`	`2237`	`// this hurts the ability of SnoopCompile to diagnose problems.`
`2238`	`2238`	`for (i = 0; i < l; i++) {`
`2239`	`2239`	`jl_method_instance_t mi = (jl_method_instance_t)jl_array_ptr_ref(list, i);`
`@@ -2280,6 +2280,22 @@ static void jl_insert_method_instances(jl_array_t *list)`
`2280`	`2280`	`}`
`2281`	`2281`	`}`
`2282`	`2282`	`}`
	`2283`	`+ // Additionally, if we have CodeInstance(s) and the running CodeInstance is world-limited, transfer it`
	`2284`	`+ if (mi->cache && jl_array_uint8_ref(valids, i)) {`
	`2285`	`+ if (!milive->cache \|\| milive->cache->max_world < ~(size_t)0) {`
	`2286`	`+ jl_code_instance_t cilive = milive->cache, ci;`
	`2287`	`+ milive->cache = mi->cache;`
	`2288`	`+ jl_gc_wb(milive, milive->cache);`
	`2289`	`+ ci = mi->cache;`
	`2290`	`+ ci->def = milive;`
	`2291`	`+ while (ci->next) {`
	`2292`	`+ ci = ci->next;`
	`2293`	`+ ci->def = milive;`
	`2294`	`+ }`
	`2295`	`+ ci->next = cilive;`
	`2296`	`+ jl_gc_wb(ci, ci->next);`
	`2297`	`+ }`
	`2298`	`+ }`
`2283`	`2299`	`}`
`2284`	`2300`	`}`
`2285`	`2301`	`}`