Parallel Compilation Problem

                    Compiling "FlowCharts like" Lang. into arrays of parallel "nodes"
                    ----------------------------------------------------------------


Can you help ?


This is a parallel compilation problem.


Two of my friends (with Elect. Eng. background) are interested in how to
compile from (possibly) Flow Charts (need NOT be graphical, just a
representation) with logical (and, or, conditional, etc.) & numerical
(integratin, differentiation, addition, etc) "boxes" (operations) into N x
M arrays of (parallel) "smart" nodes. The flow chart may look like this:


                    <input>
                        |
                      \|/
              |-->[Compare with 1]-YES->[integrate]---> Output
              | |
              | NO
              | \|/
              | [Differentiate]
              | |
              ---<---


Note that, the representation of flowcharts is unimportant, since they can
be regarded as just another language. The point is that it has loops and
high level instructions eg. integration, as well as low level logical ones
eg. AND, OR, conditionals, etc.


Each node has a set of instructions (microcoded) with eg. Inc, Dec, ADD ,
SUB, AND, OR, Buffer etc. Codes at each node are not fixed but determined
at compiled time. Also, the connection between each node is determined at
compiled time. Eg.


                          [#](1,1) [#](2,1) ......... [#](N,1)


                          [#](1,2)


                            .
                            .
                            .
                          [#](1,M) [#](2,M) ......... [#](N,M)


where each node [#](x,y), for all x<=N, y<=M, may contain:


                          ---------------
                          | AND | OR | |
                          ---------------
                          | INC | DEC |
                          ---------------
                          | Buffer | and many other possible instructions
                          ---------------


Node that, a node [#](i,j) may be connected with [#](c,b), where i =/= j
=/= c =/= b, for one particular "flowchart" description, but it may NOT be
the case for another. One may regard each node as a mini "naive
processor".


My friends have a "virtual" machine which can execute the instructions of
the nodes in parallel. They want it to be generic so that even if the flow
charts changed, such that the compiled codes on each node and connections
among nodes changed, the underlying architecture (arrays of parallel
"smart" node) remains.


This seems obvious. But I am not a "compiler person".


They have a rather naive approach to this problem.


Do you know anyone, textbook or paper that describe something similar,
and/or with methodology (and algorithms/programs/packages for automated
compilation) doing such thing?




I hope my description is sufficiently clear!


Thank you in advance.


******Please answer by email: hfc@doc.ic.ac.uk***********


Yours,
Hilfred CHAU
--
Hilfred (Hiu Fai) CHAU Email: JANET hfc@doc.ic.ac.uk
Department of Computing UUCP ...ukc!icdoc!hfc
Imperial College Tel(office):(+44)(0)71 589 5111 ext.4990
--

Return to the comp.compilers page.
Search the comp.compilers archives again.