LabView TestStand interoperability with LabView runtime adapter

Question

I would like to get some background information on how the interoperability of LabView and TestStand works.
We are using LabView steps mainly for some minor tasks in TestStand projects.
We do not use the regular deployment way as proposed by NI, but simply use one or more VI folders from which we reference LabView steps.
Deployment is done by copying the whole TestStand/LabView folder structure to the target machine.
We use the LabView runtime adapter within on our deployed systems.
We never mix LabView versions within one project.
Now, we frequently face the situation that the exact same project structure on two different machines has problems with the LabView steps.
So one changed VI runs on one target machine while the other after copy deployment is broken. Due to the same project structure and the virtual drives the paths must be the same.
A mass compile usually solves the situation.
So this is mystery number 1.
Today, I had the same problem, however I did not mass compile the full VI folder but simply some folders which I assumed had changed.
One VI which was referenced by TestStand was not mass compiled and was declared as broken by TestStand.
All I did was opening the broken VI in LabView Development System and nothing was obviously changed by LabView.
I closed the VI  and pressed the Reload VI button on the TestStand step and the VI was working again, however the sequence file now had changed somehow (* at file name).
Another phenomenon:
An existing project on a machine was running with a certain user.
After switching the user, the VI steps of the project were suddenly broken.
My questions?
1) Why do VIs which run in the development system flawlessly  become broken in the runtime?
2) Does the runtime use different search paths than the development system?
3) What kind of information does the mass compilation produce and where is it stored.
4) What kind of information does TestStand store along with the VI?
5) Is there a way to diagnose the problem with the runtime adapter ? With the runtime adapter I cannot open the VI to see what is the problem and in the developer mode it works.
 

Answer 1

First, to clarify a few points:
1) It is not necessary to use a workspace for TestStand deployments. You can specify a directory of source files for a TestStand deployment.
2) TestStand licensing should not be affecting this issue in any way. TestStand licenses do not have any impact on LabVIEW VI execution in TestStand.
Thorsten,
The issues you are describing are likely being caused by the LabVIEW VIs needing to be recompiled. The runtime engine is not able to recompile VIs, but the LabVIEW Dev System can, so this explains why you are able to execute again after opening the VIs in LabVIEW Dev. it also explains why a mass compile fixes the issue.
There are a variety of reasons why this could be happening. One scenario that could cause this to happen is that you make a change in one VI, but the change causes a second VI to need to be recompiled. This could cause a problem if you redeploy only the VI that you changed, because it will not be able to work properly unless the second VI is recompiled, which cannot be done by the LabVIEW RTE alone. This can happen because the LabVIEW compiler will optimize certain operations in the compiled code depending on where data is used--for example, the compiler will try to avoid allocating a copy of an array if it does not need to be accessed by multiple pieces of code at the same time. As you can imagine, this type of optimization might be appropriate for one version of your code, but might not be appropriate if a subVI changes such that it needs access to the array in parallel with the rest of the code. 
The specific example I mentioned is called the Inplaceness Algorithm, and is described along with much more information about the LabVIEW compiler in this whitepaper. This might help explain the reasons a LabVIEW VI would need to be recompiled.
One potential solution to your problem that would allow you to keep your current deployment method would be to use packed project libraries (PPLs). You could have multiple PPLs for different parts of your code that you want to be able to update individually, which would allow you to make small changes to your codebase without having to deploy the entire set of code at once. A PPL is a self-contained set of compiled code that does not change, which should avoid the recompile issue from occurring.