Question

我想创建一个JIT GPU编译器。你给了一个F＃函数，我们JIT编译它。 JIT编译的关键是能够缓存编译结果。我尝试使用MethodInfo作为缓存密钥，但它不会起作用。似乎F＃编译器将复制该函数而不是引用origin函数。有没有办法抑制这种行为？

这是一个测试代码，理想情况下，它应该只编译两次，但它做了4次。

let compileGpuCode (m:MethodInfo) =
    printfn "JIT compiling..."
    printfn "Type  : %A" m.ReflectedType
    printfn "Method: %A" m
    printfn ""
    "fake gpu code"

let gpuCodeCache = ConcurrentDictionary<MethodInfo, string>()

let launchGpu (func:int -> int -> int) =
    let m = func.GetType().GetMethod("Invoke", [| typeof<int>; typeof<int> |])
    let gpuCode = gpuCodeCache.GetOrAdd(m, compileGpuCode)
    // launch gpuCode
    ()

let myGpuCode (a:int) (b:int) = a + 2 * b

[<Test>]
let testFSFuncReflection() =
    launchGpu (+)
    launchGpu (+)
    launchGpu myGpuCode
    launchGpu myGpuCode

这是输出：

JIT compiling...
Type  : AleaTest.FS.Lab.Experiments+testFSFuncReflection@50
Method: Int32 Invoke(Int32, Int32)

JIT compiling...
Type  : AleaTest.FS.Lab.Experiments+testFSFuncReflection@51-1
Method: Int32 Invoke(Int32, Int32)

JIT compiling...
Type  : AleaTest.FS.Lab.Experiments+testFSFuncReflection@52-2
Method: Int32 Invoke(Int32, Int32)

JIT compiling...
Type  : AleaTest.FS.Lab.Experiments+testFSFuncReflection@53-3
Method: Int32 Invoke(Int32, Int32)

Answer 1

F＃编译器将您的代码更像是这样：

launchGpu (fun a b -> myGpuCode a b)
launchGpu (fun a b -> myGpuCode a b)

编译时，它会生成一个新类来表示每行的函数。如果您按如下方式编写测试：

let f = myGpuCode
launchGpu f
launchGpu f

...它只生成一个类（对于引用该函数的一个地方），然后在两个调用中共享相同的类型 - 这样就可以了。

在这个例子中，编译器实际内联myGpuCode因为它太短，但如果你把它变得更复杂，那么它会在两个类中生成非常简单的Invoke函数：

ldarg.1
ldarg.2
call int32 Test::myGpuCode(int32, int32)
ret

我确定有很多警告，但您可以检查生成的类的主体是否包含相同的IL并将其用作您的密钥。获得Invoke方法后，可以使用以下方法获取IL正文：

let m = func.GetType().GetMethod("Invoke", [| typeof<int>; typeof<int> |])
let body = m.GetMethodBody().GetILAsByteArray()

这两个类都是一样的 - 理想情况下，你也可以分析一下这个代码是否只是调用其他方法。

我可以抑制F＃编译器在IL代码中复制函数吗？

1 个答案: