See README.md for using two modules with a call from a routine in one that calls a a routine in the second module.
Exploring opaque pointers and finding the element type of an opaque pointer. We need this for reflection from R so we can invoke routines we did not create or analyze them generally.
See inferPointerElType.R which we will move to R/ to provide the functions via the Rllvm package.
Reasonably extensive exploration of compiling routines to use C's fgets, fopen, fclose routines and then timing the different approaches. This shows how we can create our own routines from within R that combine calls to C routines.
Exploring loop fusion.
Getting and setting a global variable in an LLVM module where the variable's type is a string/character sequence.
When we do not want to create an entire vector but still want to iterate over it, we have difficulties in R. We could partition it into blocks stored as elements in a list.
Like AltRep example or Haskell's lazy sequence.
We would like to have the efficiency of iterators where we can loop over the elements readily. sum(seq(1, n))
Also see fuseLoop.Rdb
Explore how LLVM deals with a union or a struct inside a struct.
See
- nestedStruct.c
- nestedStruct.ir
- nestedStruct.R
Explore creating and loading LLVM code for GPUs.
Compile a proxy routine.
Also see mkCallProxy() now in the package.
Incomplete
Read a random sample of rows from a large CSV file by compiling a routine that can read up to a k lines.
See also WASMTest.html. Needs fib.wasm. See ../inst/IR/GNUmakefile.
Not very relevant. parse and show a module.
Should be in TU.
Functions that get the names of the super-classes and sub-classes
of a given C++ class found in a TU.
We use this when writing code for quickly determining subclasses
included in calls to is(x, "LLVMType").
Set a parameter in an LLVM Function as read-only.
Insert a Function from one Module into a different Module.
Exploration of lower-level manipulation of target machine, pass manager and writing generated code.
Debugging a routine we dynamically generate via LLVM. This uses the address of the generated routine to set a break point in LLDB.
An C-like implementation in R of the dist() function with 2 nested loops.
Check/compare with dnorm.Rdb Start of code to implement version of dnorm as an LLVM Function. Not finished.
Given a version of dnorm() for a single value, this builds an LLVM Function that loops over a vector of inputs and calls dnorm() for each.
ExecutionEngine and the address of a Function via getGlobalValueAtAddress(). Perhaps extend to global variables generally.
No code, just an idea The idea here is to merge
apply(expand.grid(), 1, f)
so that we don't build the actual grid in memory and then apply the function but fuse the two and avoid the overhead of memory
Use RLLVMCompile to compile an R implementation of the fibonacci sequence. Then compare the performance with a byte-compiled version of the R function. To avoid using RLLVMCompile, we can manually generate the LLVM version of the fib() Function. See manualFib2.R.
Explore calling fopen in an LLVM Function we create. Uses RLLVMCompile.
Explores implementing commands such as
Reduce(`+`, Map(log, Map(dnorm, x, mu, sigma)))
in a single loop rather than 3 separate loops for
- dnorm
- log
+
Also see expandGrid.R Uses RLLVMCompile.
Related is a comment in MapReduce.R Consider the likelihood calculation
prod(dnorm(x, mu, sigma))
Additionally, in theory, R might end up with 2 copies of x. It doesn't, because prod is .Primtive and dnorm is an .External and doesn't modify the value of x.
Getting and setting a global variable in an LLVM module where the variable's type is a string/character sequence.
Functions to test inferPointerElType and inferReturnPointerType in inferPointerElType.R These loop over all of the routines in all of the Modules in R_HOME/src/main.
Functions to deal with opaque pointers and find the element type by analyzing the IR code that uses the pointers.
Explore an issue with the current insertion point for an IRBuilder and into which BasicBlock the next instruction will be added.
Exploring lazy LLVM JIT compilation - or not any more. Hasn't LLVM changed.
Explore LLJIT.
Explore LLJIT with Module we programmatically create, not via parseIR().
Uses RLLVMCompile to compile 5 different functions each of which has one or more loops.
Manually created LLVM implementations of the basic fibonacci function.
Create a Module and a Function that calls a routine from a second Module. We use the code from R's src/main/ directory as the second module.
Two functions - writeMapCall() and makeCall(). See fuseLoop.Rdb