Running functions from MOD files via LLVM JIT#482
Conversation
|
Can one of the admins verify this patch? |
|
@georgemitenkov : which version of cmake-format you have? it should be 0.6.0. For this PR, on my machine I see: |
pramodk
left a comment
There was a problem hiding this comment.
I quickly skimmed though, very nice! ⭐
I will take a detailed look at JIT driver tomorrow.
That's the issue then! I have 0.6.13 |
|
@georgemitenkov : I see following error in CI : Which LLVM version you are using? master or 11.0 ? If it's hassle to be compatible with 9.0, we can just drop it and move to 11.0. I can update our Jenkins CI. |
|
I am using LLVM 11. I think it makes sense to upgrade to 11 on CI? As far as I am aware LLVM tries to keep up to date with new C++ standards, so lambdas, callbacks, etc. are used more and more frequently. If that's a problem, I can try to rewrite it in the more standard way too. |
I would upgrade to v11.0 in CI for two reasons:
I will update CI shortly and re-trigger build. |
|
Retest this please |
pramodk
left a comment
There was a problem hiding this comment.
@georgemitenkov : overall, this looks sufficiently good starting point and ready to merge in llvm.
I have merged rest of my PRs into llvm branch. I haven't rebased and pushed this PR branch in case you have any local commits. You can rebase on llvm branch and push it. There are two minor conflicts which should be easy to solve.
ed5a1ee to
892a8e0
Compare
|
@pramodk I have rebased on your recent PR, so this should be ready for the merge now! I have made some additions to the previous draft version, particularly:
|
pramodk
left a comment
There was a problem hiding this comment.
2 minimal comments, LGTM!
Feel free to squash & merge.
This commit introduces a functionality to execute functions from MOD file via LLVM jit.
For that, there is now:
- `JITDriver` class that, given a LLVM IR module, set ups the JIT compiler and is able to look up a function and execute it.
- `Runner` class that wraps around JIT driver. It helps to initialise JIT with LLVM IR module only once, and then run multiple functions from it.
To execute functions, `nmodl_llvm_runner` executable is used. It takes a single mod file and a specified entry-point function, and runs it via LLVM code generation pipeline and JIT driver. Only functions with double result types are supported at the moment.
For example, for MOD file `foo.mod`:
```
FUNCTION one() {
one = 1
}
FUNCTION bar() {
bar = one() + exp(1)
}
```
running `nmodl_llvm_runner -f foo.mod -e bar` gives
```
Result: 3.718282
```
Tests for execution of generated IR have been added as well.
fixes #482
Co-authored-by: Pramod Kumbhar <pramod.s.kumbhar@gmail.com>
This commit introduces a functionality to execute functions from MOD file via LLVM jit.
For that, there is now:
- `JITDriver` class that, given a LLVM IR module, set ups the JIT compiler and is able to look up a function and execute it.
- `Runner` class that wraps around JIT driver. It helps to initialise JIT with LLVM IR module only once, and then run multiple functions from it.
To execute functions, `nmodl_llvm_runner` executable is used. It takes a single mod file and a specified entry-point function, and runs it via LLVM code generation pipeline and JIT driver. Only functions with double result types are supported at the moment.
For example, for MOD file `foo.mod`:
```
FUNCTION one() {
one = 1
}
FUNCTION bar() {
bar = one() + exp(1)
}
```
running `nmodl_llvm_runner -f foo.mod -e bar` gives
```
Result: 3.718282
```
Tests for execution of generated IR have been added as well.
fixes #482
Co-authored-by: Pramod Kumbhar <pramod.s.kumbhar@gmail.com>
This commit introduces a functionality to execute functions from MOD file via LLVM jit.
For that, there is now:
- `JITDriver` class that, given a LLVM IR module, set ups the JIT compiler and is able to look up a function and execute it.
- `Runner` class that wraps around JIT driver. It helps to initialise JIT with LLVM IR module only once, and then run multiple functions from it.
To execute functions, `nmodl_llvm_runner` executable is used. It takes a single mod file and a specified entry-point function, and runs it via LLVM code generation pipeline and JIT driver. Only functions with double result types are supported at the moment.
For example, for MOD file `foo.mod`:
```
FUNCTION one() {
one = 1
}
FUNCTION bar() {
bar = one() + exp(1)
}
```
running `nmodl_llvm_runner -f foo.mod -e bar` gives
```
Result: 3.718282
```
Tests for execution of generated IR have been added as well.
fixes #482
Co-authored-by: Pramod Kumbhar <pramod.s.kumbhar@gmail.com>
This commit introduces a functionality to execute functions from MOD file via LLVM jit.
For that, there is now:
- `JITDriver` class that, given a LLVM IR module, set ups the JIT compiler and is able to look up a function and execute it.
- `Runner` class that wraps around JIT driver. It helps to initialise JIT with LLVM IR module only once, and then run multiple functions from it.
To execute functions, `nmodl_llvm_runner` executable is used. It takes a single mod file and a specified entry-point function, and runs it via LLVM code generation pipeline and JIT driver. Only functions with double result types are supported at the moment.
For example, for MOD file `foo.mod`:
```
FUNCTION one() {
one = 1
}
FUNCTION bar() {
bar = one() + exp(1)
}
```
running `nmodl_llvm_runner -f foo.mod -e bar` gives
```
Result: 3.718282
```
Tests for execution of generated IR have been added as well.
fixes #482
Co-authored-by: Pramod Kumbhar <pramod.s.kumbhar@gmail.com>
This commit introduces a functionality to execute functions from MOD file via LLVM jit.
For that, there is now:
- `JITDriver` class that, given a LLVM IR module, set ups the JIT compiler and is able to look up a function and execute it.
- `Runner` class that wraps around JIT driver. It helps to initialise JIT with LLVM IR module only once, and then run multiple functions from it.
To execute functions, `nmodl_llvm_runner` executable is used. It takes a single mod file and a specified entry-point function, and runs it via LLVM code generation pipeline and JIT driver. Only functions with double result types are supported at the moment.
For example, for MOD file `foo.mod`:
```
FUNCTION one() {
one = 1
}
FUNCTION bar() {
bar = one() + exp(1)
}
```
running `nmodl_llvm_runner -f foo.mod -e bar` gives
```
Result: 3.718282
```
Tests for execution of generated IR have been added as well.
fixes #482
Co-authored-by: Pramod Kumbhar <pramod.s.kumbhar@gmail.com>
This commit introduces a functionality to execute functions from MOD file via LLVM jit.
For that, there is now:
- `JITDriver` class that, given a LLVM IR module, set ups the JIT compiler and is able to look up a function and execute it.
- `Runner` class that wraps around JIT driver. It helps to initialise JIT with LLVM IR module only once, and then run multiple functions from it.
To execute functions, `nmodl_llvm_runner` executable is used. It takes a single mod file and a specified entry-point function, and runs it via LLVM code generation pipeline and JIT driver. Only functions with double result types are supported at the moment.
For example, for MOD file `foo.mod`:
```
FUNCTION one() {
one = 1
}
FUNCTION bar() {
bar = one() + exp(1)
}
```
running `nmodl_llvm_runner -f foo.mod -e bar` gives
```
Result: 3.718282
```
Tests for execution of generated IR have been added as well.
fixes #482
Co-authored-by: Pramod Kumbhar <pramod.s.kumbhar@gmail.com>
This is a draft PR to gather some feedback and suggestions :)
It introduces:
JITDriverclass that, given a LLVM IR module, set ups the JIT compiler and is able to look up a function and execute it. Currently, the result of the execution is printed to stdout and can be a double only.nmodl_llvm_runnerexecutable that can take a mod file and a specified entry-point function, and run it via LLVM code generation pipeline andJITDriver.For example, for MOD file like
running
nmodl_llvm_runner -f foo.mod -e bargivesCurrent status:
[x] An executable to run functions from MOD files
[x] JIT class to wrap around LLVM's JIT, which can be used in executable(mentioned above) or testing
[ ] Function results and optimisations tests
fixes #482