Allow for generic MethodTableView

Author: vchuravy

src/interface.jl

@@ -231,12 +231,12 @@ isintrinsic(@nospecialize(job::CompilerJob), fn::String) = false
 # provide a specific interpreter to use.
 if VERSION >= v"1.11.0-DEV.1552"
 get_interpreter(@nospecialize(job::CompilerJob)) =
-    GPUInterpreter(job.world; method_table=method_table(job),
+    GPUInterpreter(job.world; method_table_view=maybe_cached(method_table_view(job)),
                    token=ci_cache_token(job), inf_params=inference_params(job),
                    opt_params=optimization_params(job))
 else
 get_interpreter(@nospecialize(job::CompilerJob)) =
-    GPUInterpreter(job.world; method_table=method_table(job),
+    GPUInterpreter(job.world; method_table_view=maybe_cached(method_table_view(job)),
                    code_cache=ci_cache(job), inf_params=inference_params(job),
                    opt_params=optimization_params(job))
 end
@@ -299,6 +299,7 @@ end
 
 # the method table to use
 method_table(@nospecialize(job::CompilerJob)) = GLOBAL_METHOD_TABLE
+method_table_view(@nospecialize(job::CompilerJob)) = get_method_table_view(job.world, method_table(job))
 
 # the inference parameters to use when constructing the GPUInterpreter
 function inference_params(@nospecialize(job::CompilerJob))

src/jlgen.jl

@@ -307,21 +307,19 @@ else
     import Core.Compiler: get_world_counter, get_world_counter as get_inference_world
 end
 
-using Core.Compiler: OverlayMethodTable
 const MTType = Core.MethodTable
 if isdefined(Core.Compiler, :CachedMethodTable)
     using Core.Compiler: CachedMethodTable
-    const GPUMethodTableView = CachedMethodTable{OverlayMethodTable}
-    get_method_table_view(world::UInt, mt::MTType) =
-        CachedMethodTable(OverlayMethodTable(world, mt))
+    maybe_cached(mtv::CC.MethodTableView) = CachedMethodTable(mtv)
 else
-    const GPUMethodTableView = OverlayMethodTable
-    get_method_table_view(world::UInt, mt::MTType) = OverlayMethodTable(world, mt)
+    maybe_cached(mtv::CC.MethodTableView) = mtv
 end
 
-struct GPUInterpreter <: CC.AbstractInterpreter
+get_method_table_view(world::UInt, mt::CC.MethodTable) = CC.OverlayMethodTable(world, mt)
+
+struct GPUInterpreter{MTV<:CC.MethodTableView} <: CC.AbstractInterpreter
     world::UInt
-    method_table::GPUMethodTableView
+    method_table_view::MTV
 
 @static if HAS_INTEGRATED_CACHE
     token::Any
@@ -336,57 +334,55 @@ end
 
 @static if HAS_INTEGRATED_CACHE
 function GPUInterpreter(world::UInt=Base.get_world_counter();
-                        method_table::MTType,
+                        method_table_view::CC.MethodTableView,
                         token::Any,
                         inf_params::CC.InferenceParams,
                         opt_params::CC.OptimizationParams)
     @assert world <= Base.get_world_counter()
 
-    method_table = get_method_table_view(world, method_table)
     inf_cache = Vector{CC.InferenceResult}()
 
-    return GPUInterpreter(world, method_table,
+    return GPUInterpreter(world, method_table_view,
                           token, inf_cache,
                           inf_params, opt_params)
 end
 
 function GPUInterpreter(interp::GPUInterpreter;
                         world::UInt=interp.world,
-                        method_table::GPUMethodTableView=interp.method_table,
+                        method_table_view::Core.MethodTable=interp.method_table_view,
                         token::Any=interp.token,
                         inf_cache::Vector{CC.InferenceResult}=interp.inf_cache,
                         inf_params::CC.InferenceParams=interp.inf_params,
                         opt_params::CC.OptimizationParams=interp.opt_params)
-    return GPUInterpreter(world, method_table,
+    return GPUInterpreter(world, method_table_view,
                           token, inf_cache,
                           inf_params, opt_params)
 end
 
 else
 
 function GPUInterpreter(world::UInt=Base.get_world_counter();
-                        method_table::MTType,
+                        method_table_view::CC.MethodTableView,
                         code_cache::CodeCache,
                         inf_params::CC.InferenceParams,
                         opt_params::CC.OptimizationParams)
     @assert world <= Base.get_world_counter()
 
-    method_table = get_method_table_view(world, method_table)
     inf_cache = Vector{CC.InferenceResult}()
 
-    return GPUInterpreter(world, method_table,
+    return GPUInterpreter(world, method_table_view,
                           code_cache, inf_cache,
                           inf_params, opt_params)
 end
 
 function GPUInterpreter(interp::GPUInterpreter;
                         world::UInt=interp.world,
-                        method_table::GPUMethodTableView=interp.method_table,
+                        method_table_view::CC.MethodTableView=interp.method_table_view,
                         code_cache::CodeCache=interp.code_cache,
                         inf_cache::Vector{CC.InferenceResult}=interp.inf_cache,
                         inf_params::CC.InferenceParams=interp.inf_params,
                         opt_params::CC.OptimizationParams=interp.opt_params)
-    return GPUInterpreter(world, method_table,
+    return GPUInterpreter(world, method_table_view,
                           code_cache, inf_cache,
                           inf_params, opt_params)
 end
@@ -416,7 +412,7 @@ CC.may_discard_trees(interp::GPUInterpreter) = true
 @static if VERSION <= v"1.12.0-DEV.1531"
 CC.verbose_stmt_info(interp::GPUInterpreter) = false
 end
-CC.method_table(interp::GPUInterpreter) = interp.method_table
+CC.method_table(interp::GPUInterpreter) = interp.method_table_view
 
 # semi-concrete interepretation is broken with overlays (JuliaLang/julia#47349)
 function CC.concrete_eval_eligible(interp::GPUInterpreter,