Can I lock access to vi's using embedded but inactive copies of those vi's?

Question

The aim is to avoid race conditions between different vi's. A representative example is this:
Will this vi reserve the vi's in the non-executing case structure? In reality the true case (shown above) will never be able to run, because the case is always false and the compiler could safely decide to remove them entirely.
Does it remove non used vi's?
I have read that this trick with embedding into non-active case structures is useful when using dynamic loading of vi's. Doing like this you are sure they are in the dependency path and will be included when making a distribution.
Solved!
Go to Solution.

Answer 1

heel wrote:
Maybe could someone comment on this side-note which happend to show up - to wrap up things brought up here:
..this trick with embedding into non-active case structures is useful when using dynamic loading of vi's. Doing like this you are sure they are in the dependency path and will be included when making a distribution.
also in this case, is it safer to use a control and not a constant, or are there better ways to automate dependency maintenance?
Ah, the dynamically calling of VIs.  When you dynamically call a VI, LabVIEW can't tell what VI you are going to call.  So the VIs that you want to call dynamically were not put into the executable build.  Then you have errors (VI not available).  So the trick a long time ago was to put VIs that you want to call dynamically into a case structure that would not run.  LabVIEW would see the VI and put it in the built executable.  This is the main reason when you convert from 7.1 or older to 8.0 or newer, you see the constants changed to hidden controls.
So what is the best way to do this now?  In the build specification of your executable there is an "Always Include" section.  Put your dynamically called VIs in there.
There are only two ways to tell somebody thanks: Kudos and Marked Solutions
Unofficial Forum Rules and Guidelines