[great-users] Serial vs Parallel execution

[Gürkan Özhan]

I have provided a simplified version of my exercise in the attachment.
The versions of GME and GReAT are the latest releases, namely, version
4.11.10 for GME and version 1.3.3 for GReAT ( and UDM version is
2.21).

I am having difficulting in writing parallel transformation
definitions. The problem is, I need to start two parallel branches,
construct them independently in their own branches, but then need to
use some parts from both branches in a further rule. I use a block to
function as a synchronizer for the parallel branches, so that
inputs from both branches are available for the rule following the
block. Unfortunately I could not succeed in achieving this. The
scenario only works as expected if I carry all the references serially
through a single branch, hence loosing space efficiency and
introducing unnecessary and confusing complexity.

I have provided three start rules in the configuration. Of these
three, only StartSerial block works successfully, while
StartMoreParallel and StartParallel do not. Details are below:

(This is the point where the Initialize block ends in a debug session.
I expect the execution of the next rule, but it does not execute.)

Start Rule Name: StartMoreParallel

Snapshot of Debug Step 9 (end of block Initialize):
In Variables
   Tgt_RF
      has no value
   Src_Rf 
      has no value
Out Variables
   S_T1_Part
      NewSrcMain.PartA
      NewSrcMain.PartB
   S_T2_Part
      NewSrcMain.PartC
      NewSrcMain.PartD
   T_DataStore
      TgtMain.TgtDataStore
   TypeSystem
      TgtMain.TgtTypeSystem
      
At Debug Step 4 (CreateTgtType1Data(dataStore:I, Part:I, typeSystem:I,
type1:P, type1Ref:P, tgtPart1:P)
   No match and skip :-(
At Debug Step 3 (CreateTgtType2Data(dataStore:I, Part:I, typeSystem:I,
type2:P, type2Ref:P, tgtPart2:P)
   No match and skip :-(
   
Eventhough the input ports are provided with matching data, neither
CreateTgtType1Data, nor CreateTgtType2Data match and execute. I
thought that a block stacks all of its packets at its output ports
until the last packet is produced, and  only after that,the next rule
following the block starts.

Also, isn't there a mechaism to make a port repeat its value n times?
Let me explain this with the above example:
In our case S_T1_Part has 2 packets, whereas, T_DataStore and
TypeSystem have 1 packet. Therefore T_DataStore and TypeSystem should
repeat their data as many times as S_T1_Part's packet count(in this
case 2 times)

A similar scenario is with start block StartParallel. Here we are
stuck after the rule CreateTgtDataStoreAndData. The following rules
CreateTgtType1Data and CreateTgtType2Data just don't execute.

The transformation only succeeds with the start block StartSerial. In
this scenario we carry all the necessary references serially through a
single path till the end of CreateTgtDataStoreAndData block. However,
this sort of implementation results in unnecessary carrying of packets
through previous rules that will be required in some other rule that
is farther away. This is really a space efficiency killer and
complicates understanding of the rules in scenarios where the target
model is huge and has modular subparts that can be constructed
independently, but pieces of those subparts are used as inputs in some
rule that is further away in the rule execution sequence.

Thanks in advance.

Gürkan Özhan
-------------- next part --------------
A non-text attachment was scrubbed...
Name: Sample_BranchedVsSerial.zip
Type: application/zip
Size: 136958 bytes
Desc: not available
Url : http://list.isis.vanderbilt.edu/pipermail/great-users/attachments/20050405/5b65ce35/Sample_BranchedVsSerial.zip