Executing same VI multiple times, sending/retrieving data

Question

I know how to
execute a single vi multiple times using the invoke node/reentrant method.  But
I am not sure how to send/get data the running vi's.
A little background
on my project.  I have to test up to 64 units for a long period of time.  When
one of the 64 units is found, I want the test to execute the test.vi then come
back to my main.vi and wait for the next unit to test to be
found.
The test.vi will
require some information to run so I need to get that data into the test.vi
along with a way to stop the tests while they are running.  I also want to
report running data back to the user, so I need to get data from
test.vi.
I am using a
producer/consumer/display loop(s) and I would like to be able to use my display
queue to collect and sort data from my running test.vi's.
I may be going about
this wrong executing test.vi using the invoke node, but I am trying to find away
that the test vi's will independently execute and run.
Please let me know
if I need to clarify my situation.  I have been trying to figure this out for a
while, so it may make sense in my head, but not on paper.
Thanks,
Zac

Answer 1

If I understand you correctly, you are invoking a reentrant VI to run in up to 64 different instances?  And you need to set up a communications mechanism between each instance and the main VI.
I would look at a functional global variable or action engine.  (Search on either of those terms and  you will come up with numerous examples).
Let the FGV store data in its uninitialized shift registers.  If you need a separate queue from each VI instance to the main, then have one shift register be an array of queue references.  Let's say you are ready to invoke the first instance of your VI.  Pass to it and ID value of 0 in its connector pane.  Obtain a queue and store the reference to that in index 0 of the queue array in the FGV.  Every time you need to enqueue or dequeue from queue 0, you use index array to retrieve the reference stored in queue 0.  You would do that whenever you need to work inside the instance of the VI (have it remember that its ID was 0) or in the main VI.
Next instance of the reentrant VI, you pass it a 1 as its ID.  Let the FGV obtain a queue and store its reference in index 1 of the array.  You could have other values stored in the FGV or other arrays such as an array of booleans that serve as flags to tell the instance of the reentrant VI to stop running.
Basically the FGV or action engine becomes a storehouse of information for each instance of the reentrant VI.  It will be scalable.  Each time you need to add a new instance of your VI, you store the info in another element of the array stored in the FGV that is based on a ID number you assign as you create each instance.