CompiledFunctionCall vs. LibraryFunction

Question

When compiling code to C, and the compiled code calls other compiled functions, I see CompiledFunctionCall in the output of CompilePrint most of the time. But sometimes, it's replaced by LibraryFunction[<>,...]. Could anybody explain the difference between these two?

EDIT: As an example, I would expect a LibraryFunction call in the following case. If I define:

compBinomial=Compile[{{n,_Real},{k,_Real}},
Which[
k==0.||k==n,
1,
n==0.,
0,
k<=Quotient[n,2],
Product[(n+1-i)/i,{i,1,k}],
True,
Product[(n+1-i)/i,{i,1,n-k}]
]
,CompilationTarget->"C",RuntimeOptions->"Speed"
];

If I then define the following:

compsum=Compile[
{{n,_Integer},{m,_Integer},{j,_Integer}},
Round@Sum[
(-1)^k*compBinomial[n+m,n-k]*compBinomial[k+j,k]
,{k,0,n}]
,CompilationTarget->"C",RuntimeOptions->"Speed",
CompilationOptions->{"InlineExternalDefinitions" -> True,
"InlineCompiledFunctions"->False}
];

I see CompiledFunctionCall in the output of CompilePrint[compsum].

Answer 1

It appears that LibraryFunction occurs if the function being called inside the other compiled function is a function that has been compiled to C, provided this function has been called with the right type of arguments. It seems that in other cases there is a CompiledFunctionCall.

As pointed out by Simon Woods in the comments below, there is a type mismatch in the example that you added later, so that in this case CompiledFunctionCall is used.

Be warned that this is based on very few examples, so this may not be the correct explanation.

Here is a simple example where compiled functions are called with the right type of arguments. First we compile it to the WVM and then to C and observe the difference.

<< CompiledFunctionTools`
cf = Compile[{{x}}, Sin[x]];
cf5 = Compile[{{x}}, cf[x^2], 
   CompilationOptions -> {"InlineExternalDefinitions" -> True, 
     "InlineCompiledFunctions" -> False}];
cf5 // CompilePrint

...
R2 = CompiledFunctionCall[ Hold[CompiledFunction[{x}, Sin[x], \
-CompiledCode-]][ R1]]
...

cf2 = Compile[{{x}}, Sin[x], CompilationTarget -> "C"];
cf6 =
  Compile[{{x}}, cf2[x^2],
   CompilationOptions ->
    {"InlineExternalDefinitions" -> True, 
     "InlineCompiledFunctions" -> False}
   ];
cf6 // CompilePrint

...
R2 = LibraryFunction[<>, compiledFunction12, {{Real, 0, Constant}}, \
Real][ R1]]
...

About LibraryFunction

In a compiled function that has been compiled to C, a LibraryFunction will do all the work. A library function is a function that is part of a dynamically linked library that is loaded into the kernel. The dynamically linked library is the result of compiling C code.

The following code creates an expression with head LibraryFunction. It does this by loading a pre-compiled function from a library.

fun = LibraryFunctionLoad["demo", "demo_I_I", {Integer}, Integer];
fun//Head

LibraryFunction

You can also see a LibraryFunction in the definition of cf2

cf2//InputForm

CompiledFunction[{10, 10.1, 
  5468}, {_Real}, {{3, 0, 0}, {3, 0, 1}}, {}, {0, 0, 2, 0, 0}, 
  {{40, 1, 3, 0, 0, 3, 0, 1}, {1}}, Function[{x}, Sin[x]], Evaluate, 
  LibraryFunction["path/compiledFunction12.dylib", 
  "compiledFunction12", 
    {{Real, 0, "Constant"}}, Real]]

In the definition of cf, no such LibraryFunction is present.

Skipping interaction with the CompiledFunction

The compilation process in Mathematica is smart enough to figure out that a compiled function is compiled to C, so it knows that it can simply call the LibraryFunction, rather than interacting with some CompiledFunction object. In fact we can do the same manually. Let

libFunc = cf2[[9]]

LibraryFunction[Function name: compiledFunction12 Argument count: 1]

So that we have defined libFunc as the LibraryFunction that does all the work for cf2.

Then we can do

libFunc[Pi]

 1.22465*10^-16

Conclusion

My guess is that this explains the difference. When calling a function that has been compiled to the WVM, a CompiledFunction is really called. When using a function that has been compiled to C, in the absence of a type mismatch,a shortcut is taken and the LibraryFunction is called directly.