Related articles 

Parallel Compilation Problem hfc@doc.ic.ac.uk (19930202) 
Newsgroups:  comp.ai.neuralnets,comp.arch,comp.compilers 
From:  hfc@doc.ic.ac.uk (Hilfred Chau) 
Keywords:  question 
Organization:  Dept. of Computing, Imperial College, University of London, UK. 
Date:  Tue, 2 Feb 1993 17:28:05 GMT 
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.