Loading default limits for every execution

Question

Hi,
My situation is like that:
I execute my sequence using sequential model. Usually, the sequence is executed "in the loop" which means when once the sequential model is launched we can test unit after unit till the moment we want to stop for some reason. The sequence is loaded dynamically by the sequential model and with unload after step executes unload option.
In the sequence we are using limits. The default TS limits looks like below.
All our limits get changed during the execution depending on what unit we are testing and on what stage the unit is.
Problem:
I thought that if the sequence is loaded dynamically and it is unloaded when executed, the next time the next unit will be tested the default values of the limits container will be loaded (as a result of being loaded dynamically and unloaded when step which calls the main sequence is executed). Unfortunately, it looks like when we perform continous testing the test limits are not reverted back to the default, as expected, but they are a superposition of the limits loaded by previous executions. Of course
Questions:
1. Are my expectations regarding TS behaviour are correct?
2. How to impose the default limits to be "reset" to the default for every sequence execution, not only the first sequential model execution?
Solved!
Go to Solution.

Answer 1

MimiKLM wrote:I'm worry about not the speed of loading you mentioned associated with your solution but the potential problems with the memory. Let say, I call the main sequence 1000 times without interrupting of the execution. So instead of having one copy of the sequence called with cleared/reinitialised all variables and properties I have 1000 copies in the memory. I'd call it a waste to have 1000 copies only because I need to have the the properties and variables cleared.
The copy only exists while the sequence is running. Once the execution of the sequence completes, the copy will be destroyed/freed. At least as long as your code modules don't hold their own reference to it somewhere (which typically they should not be doing).
So if you call main sequence 1000 times in a loop, you should still only ever have one runtime copy in memory at a time. The difference is a new copy is created (and destroyed once the sequence is done running) each time, rather than creating a copy only once and reusing it. There is a performance hit to this per call of your sequence that is somewhat proportional to the size of your sequence, but unless your sequence is really huge, or you test execution is extremely fast, you probably will not notice the difference.
Hope this helps clarify things,
-Doug