Exporting a compiled function for later use

Question

I wish to export compiled functions for later use. This means that I do not want the compiled function to be recompiled every time I reload it. It also means that if my compiled function was for example Listable, then the function should still be Listable when I reload it.

Below I will present some attempts to save and reload the following function.

function = 
  Compile[{{x, _Real}}, Sum[Sin[Cos[-x^2*i]], {i, 1, 10^6}], 
  CompilationTarget -> "C", RuntimeAttributes -> {Listable}, 
  Parallelization -> True];

Attempt using .wdx file

SetDirectory[NotebookDirectory[]]
Export["compiled.wdx", function];
function[Range[10]] // AbsoluteTiming//First   
(* 0.191019 seconds *)

Now after restarting the kernel, we get

SetDirectory[NotebookDirectory[]];
function2 = Import["compiled.wdx"];
function2[Range[10]] // AbsoluteTiming//First
(* 0.310031 seconds *)

Of course this difference in timing is unacceptable - it seems the function is now recompiled every time it is called.

Attempt using LibraryGenerate

Our example function function accepts lists, because we used RuntimeAttributes -> {Listable}

function[{1, 0}]
(* {-0.2982909888387981, 841470.9848238959} *)

We now try to save this function as follows:

Needs["CCodeGenerator`"]
LibraryGenerate[function, "Myfun"]

And load it again:

function3 = LibraryFunctionLoad["Myfun", "Myfun", {Real}, Real]

There are two problems when using this method of exporting the function.

1. It seems that even if you do not compile to C code when you export as mentioned above it compiles to C code because if the function is not compiled to C code after loading it, it gets as fast as a function compiled to C code.

2. The more important issue is that now the function won't accept a list as its argument:

   function3[{1, 0}] 
   

LibraryFunction::cfsa: Argument {1,1} at position 1 should be a machine-size real number. >>

Answer 1

This is inspired by my recent answer to Save a C compiled function without losing the blessing of C compiler.

---

The key point here is to retain the {Listable} attribute of the compiled function. This is difficult as this attribute is stored in the Mathematica definition of the function, rather than the compiled C code, so neither Export/DumpSave or LibraryGenerate can store both pieces of information.

Instead we have to save the Mathematica definition of the function, and also locate the compiled library (e.g. *.dll) so that we can reload that rather than recompiling.

---

First, let's define an example listable function.

func = Compile[{{x, _Integer}}, 
         Module[{j = 0}, 
           Do[j++, {i, 10^8}]; 
           x*j],
        CompilationTarget -> "C", 
        RuntimeAttributes -> {Listable}]

func[{1, 2, 3, 4, 5}] // AbsoluteTiming
(* {1.44 seconds, {1*10^8, 2*10^8, 3*10^8, 4*10^8, 5*10^8}} *)

The next step is to extract the location of the library created by this compilation (which is what I did in the linked question) and copy it to a new location, such as the current notebook directory.

funcLoc = func[[-1, 1]]
newfuncLoc = ToString@NotebookDirectory[] <> FileNameTake[funcLoc, -1]
CopyFile[funcLoc, newfuncLoc, OverwriteTarget -> True]

Now let's save the definition of func and the location of the library, and reload it.

DumpSave["compile.mx", {func, newfuncLoc}];
Clear[func, newfuncLoc]
<< compile.mx

func[{1, 2, 3, 4, 5}] // AbsoluteTiming
(* 2.59 seconds, {1*10^8, 2*10^8, 3*10^8, 4*10^8, 5*10^8} *)

Herein lies the problem, as this is significantly slower. But remember, we also saved the location of the C library, so let's link that file back into a new function:

funcNew = ReplacePart[func, {-1, 1} -> newfuncLoc]
funcNew[{1, 2, 3, 4, 5}] // AbsoluteTiming
(* 1.40 seconds, {1*10^8, 2*10^8, 3*10^8, 4*10^8, 5*10^8} *)

There we are - the benefit of compilation to C is restored, and the {Listable} attribute remains.