Changeable global variables in compile statement

Question

If a global variable is changed before each call of the function then answer is not changed accordingly. Please see a toy example:

Clear[zIc];
With[{Aopt = Aopt},
  zIc = Compile[{{q, _Integer}},
                Aopt + q
                , CompilationTarget -> "C", 
    CompilationOptions -> {"InlineExternalDefinitions" -> True}
    ]];

Aopt = 1;
zIc[3]
Aopt = 3;
zIc[3]

(Debug) Out[203]=
6
(Debug) Out[205]=
6

Expected answers are 4 and 6. I familiar with 31627 and 78768 posts but theirs solutions don't help.

[EDITED]:

1. Removing With doesn't help also.
2. As it is very simple toy example it seems to be very obvious answer to pass global variable as an argument to the function but not in real code where zIc already has 7 arguments and Aopt is calculated 4 logical layers above.

Answer 1

By using With, you freeze the value of Aopt at compile time if it has already a value assigned to it. You may want to execute Clear[Aopt] before the compilation takes place.

Anyways, it is probably better to supply the value of Aopt as an argument to the compiled function. This makes things a lot more predictable and efficient as this removes MainEvaluate calls from the compiled function.

Answer 2

There are basically 3 ways you can go with this:

1. Include Aopt as an argument (Henrik's answer).
2. Include Aopt as a global variable without "InlineExternalDefinitions". If you do this, the code compiled code will use MainEvaluate, which essentially stops the compiled code and makes it reach into normal WL evaluation to retrieve the value of Aopt. More often than not, this will kill off most of the benefits of compilation and if Aopt doesn't have a value that the compiled code can use it will be even worse than sub-optimal because the compile function will have to be completely abandoned and WL needs to resort to normal evaluation.

You can see this for yourself with CompilePrint:

Needs["CompiledFunctionTools`"];
zIc = Compile[{{q, _Integer}}, Aopt + q]
CompilePrint[zIc]

3. Define a function that returns a compiled function with the value of Aopt "baked in". In this case, you treat Aopt as a parameter that doesn't change to often, so you can afford to make a new compiled function whenever it's value changes. Kind of like a just-in-time compilation.

This would look a bit like this:

ClearAll[zIc2];
zIc2[Aopt_?NumericQ] := zIc2[Aopt] = Compile[{{q, _Integer}}, Aopt + q]

Aopt = 1.;
cf = zIc2[Aopt];
cf[3]

Out[24]= 4.