Mercurial > repos > rhope
annotate nworker.rhope @ 21:e9272f7ebd26
Limited compilation from dataflow graph to C backend
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Tue, 23 Jun 2009 01:16:04 -0400 |
parents | b715532225c0 |
children | 914ad38f9b59 |
rev | line source |
---|---|
2 | 1 Import extendlib.rhope |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
2 Import cbackend.rhope |
2 | 3 |
4 Set@Range[range,index,val:out] | |
5 { | |
6 out <- [[()]Concatenate[range] | |
7 ]Set[index,val] | |
8 } | |
9 | |
10 List of Lists[num:out] | |
11 { | |
12 out <- Fold[["Append"]Set Input[1, ()],(), Range[0,num]] | |
13 } | |
14 | |
15 Blueprint Worker Ref | |
16 { | |
17 Name | |
18 Convention | |
19 Inputs | |
20 Outputs | |
21 } | |
22 | |
23 Worker Ref[name,convention,inputs,outputs:out] | |
24 { | |
25 out <- [[[[Build["Worker Ref"]]Name <<[name]]Convention <<[convention]]Inputs <<[inputs]]Outputs <<[outputs] | |
26 } | |
27 | |
28 Blueprint Node Ref | |
29 { | |
30 Index | |
31 IO Num | |
32 } | |
33 | |
34 Node Ref[index,ionum:out] | |
35 { | |
36 out <- [[Build["Node Ref"]]Index <<[index]]IO Num <<[ionum] | |
37 } | |
38 | |
39 =@Node Ref[left,right:out] | |
40 { | |
41 ,out <- If[[[left]Index >>] = [[right]Index >>]] | |
42 { | |
43 out <- [[left]IO Num>>] = [[right]IO Num >>] | |
44 } | |
45 } | |
46 | |
47 Blueprint NWorker Node | |
48 { | |
49 Type | |
50 Data | |
51 Inputs | |
52 Outputs | |
53 Wires From | |
54 Wires To | |
55 } | |
56 | |
57 Wire To@NWorker Node[node,from,output,input:out] | |
58 { | |
59 out <- [node]Wires To <<[ | |
60 [[node]Wires To >>]Set[input, | |
61 [[[node]Wires To >>]Index[input] | |
62 ]Append[Node Ref[from,output]] | |
63 ] | |
64 ] | |
65 } | |
66 | |
67 Wire From@NWorker Node[node,to,input,output:out] | |
68 { | |
69 out <- [node]Wires From <<[ | |
70 [[node]Wires From >>]Set[output, | |
71 [[[node]Wires From >>]Index[output] | |
72 ]Append[Node Ref[to,input]] | |
73 ] | |
74 ] | |
75 } | |
76 | |
77 _Dependency[dlist,ref:out] | |
78 { | |
79 [dlist]Find[ref] | |
80 { | |
81 out <- dlist | |
82 }{ | |
83 out <- [dlist]Append[ref] | |
84 } | |
85 } | |
86 | |
87 Dependencies@NWorker Node[node:out] | |
88 { | |
89 out <- Fold[["Fold"]Set Input[0, "_Dependency"], (), [node]Wires To >>] | |
90 } | |
91 | |
92 | |
93 NWorker Node[type,data,inputs,outputs:out] | |
94 { | |
95 out <- [[[[[[Build["NWorker Node"] | |
96 ]Type <<[type] | |
97 ]Data <<[data] | |
98 ]Inputs <<[inputs] | |
99 ]Outputs <<[outputs] | |
100 ]Wires From <<[List of Lists[outputs]] | |
101 ]Wires To <<[List of Lists[inputs]] | |
102 } | |
103 | |
104 Blueprint NWorker | |
105 { | |
106 Convention | |
107 Nodes | |
108 Inputs | |
109 Outputs | |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
110 NodeResults |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
111 Free Temps |
2 | 112 } |
113 | |
114 NWorker[convention:out] | |
115 { | |
116 out <- [[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()] | |
117 } | |
118 | |
119 Add Node@NWorker[worker,type,data,inputs,outputs:out,node index] | |
120 { | |
121 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]] | |
122 node index <- [[worker]Nodes >>]Length | |
123 } | |
124 | |
125 Add Worker Call@NWorker[worker,tocall:out,node index] | |
126 { | |
127 out, node index <- [worker]Add Node["call",tocall,[tocall]Inputs >>,[tocall]Outputs >>] | |
128 } | |
129 | |
130 Add Constant@NWorker[worker,constant:out,node index] | |
131 { | |
132 out, node index <- [worker]Add Node["const",constant,0,1] | |
133 } | |
134 | |
135 Add Input@NWorker[worker,name,number:out,node index] | |
136 { | |
137 ,node index <- [worker]Add Node["input",number,0,1] | |
138 { out <- [~]Inputs <<[[[~]Inputs >>]Set[number,name]] } | |
139 } | |
140 | |
141 Add Output@NWorker[worker,name,number:out,node index] | |
142 { | |
143 ,node index <- [worker]Add Node["output",number,1,0] | |
144 { out <- [~]Outputs <<[[[~]Outputs >>]Set[number,name]] } | |
145 } | |
146 | |
147 Add Wire@NWorker[worker,from,output,to,input:out] | |
148 { | |
149 fromw <- [[[worker]Nodes >>]Index[from]]Wire From[to,input,output] | |
150 tow <- [[[worker]Nodes >>]Index[to]]Wire To[from,output,input] | |
151 nodes <- [[[worker]Nodes >>]Set[from, fromw]]Set[to, tow] | |
152 out <- [worker]Nodes <<[nodes] | |
153 } | |
154 | |
155 _No Dependencies[list,node,index:out] | |
156 { | |
157 [[node]Wires To>>]First | |
158 { | |
159 out <- Val[list] | |
160 }{ | |
161 out <- [list]Append[index] | |
162 } | |
163 } | |
164 | |
165 No Dependencies@NWorker[worker:out] | |
166 { | |
167 out <- Fold["_No Dependencies", (), [worker]Nodes >>] | |
168 } | |
169 | |
170 _Collect Dests[candidates,wire:out] | |
171 { | |
172 out <- [candidates]Set[[wire]Index >>, Yes] | |
173 } | |
174 | |
175 Collect Dests@NWorker[worker,candidates,node index:out] | |
176 { | |
177 out <- Fold[["Fold"]Set Input[0, "_Collect Dests"], candidates, [[[worker]Nodes >>]Index[node index]]Wires From >>] | |
178 } | |
179 | |
180 Check Dependency@NWorker[worker,nodes,wires,wire index:met?] | |
181 { | |
182 ref <- [wires]Index[wire index] | |
183 [nodes]Find[[ref]Index >>] | |
184 { | |
185 [wires]Next[wire index] | |
186 { | |
187 met? <- [worker]Check Dependency[nodes,wires,~] | |
188 }{ | |
189 met? <- Yes | |
190 } | |
191 }{ | |
192 met? <- No | |
193 } | |
194 } | |
195 _Check Dependencies@NWorker[worker,nodes,inputs,input index:met?] | |
196 { | |
197 wires <- [inputs]Index[input index] | |
198 [wires]First | |
199 { | |
200 current met? <- [worker]Check Dependency[nodes, wires, ~] | |
201 }{ | |
202 current met? <- Yes | |
203 } | |
204 If[current met?] | |
205 { | |
206 [inputs]Next[input index] | |
207 { | |
208 met? <- [worker]_Check Dependencies[nodes,inputs,~] | |
209 }{ | |
210 met? <- Yes | |
211 } | |
212 }{ | |
213 met? <- No | |
214 } | |
215 } | |
216 | |
217 Check Dependencies@NWorker[worker,nodes,candidate:met?] | |
218 { | |
219 inputs <- [[[worker]Nodes >>]Index[candidate]]Wires To >> | |
220 [inputs]First | |
221 { | |
222 met? <- [worker]_Check Dependencies[nodes, inputs, ~] | |
223 }{ | |
224 met? <- Yes | |
225 } | |
226 } | |
227 | |
228 Dependants@NWorker[worker,direct nodes,nodes:out] | |
229 { | |
230 candidates <- Keys[Fold[["Collect Dests"]Set Input[0,worker], (), direct nodes]] | |
231 out <- Filter[candidates, [["Check Dependencies"]Set Input[0, worker]]Set Input[1, nodes]] | |
232 } | |
233 | |
234 _Dependency Groups@NWorker[worker,last,all,grouped:out] | |
235 { | |
236 current <- [worker]Dependants[last,all] | |
237 [current]First | |
238 { | |
239 out <- [worker]_Dependency Groups[current, [all]Concatenate[current], [grouped]Append[current]] | |
240 }{ | |
241 out <- grouped | |
242 } | |
243 } | |
244 Dependency Groups@NWorker[worker:out] | |
245 { | |
246 no deps <- [worker]No Dependencies | |
247 out <- [worker]_Dependency Groups[no deps, no deps, [()]Append[no deps]] | |
248 } | |
249 | |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
250 Format Input@NWorker[worker,noderef:out] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
251 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
252 node <- [[worker]Nodes >>]Index[[noderef]Index >>] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
253 If[[[node]Type >>] = ["call"]] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
254 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
255 out <- AddRef[ [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] ] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
256 }{ |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
257 If[[[node]Type >>] = ["input"]] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
258 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
259 input name <- [[worker]Inputs >>]Index[ [node]Data >> ] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
260 out <- AddRef[input name] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
261 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
262 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
263 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
264 |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
265 Collect Input@NWorker[worker,nodeinput:out] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
266 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
267 inputchoices <- Map[nodeinput, ["Format Input"]Set Input[0, worker]] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
268 [inputchoices]First |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
269 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
270 first <- [inputchoices]Index[~] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
271 [inputchoices]Next[~] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
272 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
273 out <- _Fold[inputchoices, ~, first, "OrValue"] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
274 }{ |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
275 out <- Val[first] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
276 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
277 }{ |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
278 out <- No |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
279 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
280 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
281 |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
282 Collect Inputs@NWorker[worker,node:out] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
283 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
284 out <- Map[[node]Wires To>>, ["Collect Input"]Set Input[0, worker]] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
285 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
286 |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
287 Save Result[func,num,node index:out] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
288 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
289 out var <- [[["__result_"]Append[node index]]Append["_"]]Append[num] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
290 out <- [[func]Allocate Var[out var, "Any Type"] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
291 ]Move[Result[num], out var] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
292 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
293 |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
294 Compile Node@NWorker[worker,program,func,nodes,current:out] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
295 { |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
296 Print[[node]Type >>] |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
297 node index <- [nodes]Index[current] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
298 node <- [[worker]Nodes >>]Index[node index] |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
299 If[[[node]Type >>] = ["call"]] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
300 { |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
301 inputs <- [worker]Collect Inputs[node] |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
302 [program]Method?[[[node]Data >>]Name >>] |
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
303 { |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
304 with call <- [func]Method Call[[[node]Data >>]Name >>, inputs] |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
305 }{ |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
306 with call <- [func]Call[[[node]Data >>]Name >>, inputs] |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
307 } |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
308 nfunc <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, [node]Outputs >>]] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
309 }{ |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
310 If[[[node]Type >>] = ["output"]] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
311 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
312 inputs <- [worker]Collect Inputs[node] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
313 nfunc <- [func]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
314 }{ |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
315 nfunc <- Val[func] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
316 } |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
317 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
318 [nodes]Next[current] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
319 { |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
320 out <- [worker]Compile Node[program,nfunc,nodes,~] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
321 }{ |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
322 out <- Val[nfunc] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
323 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
324 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
325 |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
326 Compile Group@NWorker[worker,program,func,groups,current:out] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
327 { |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
328 nodes <- [groups]Index[current] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
329 [nodes]First |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
330 { |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
331 nfunc <- [worker]Compile Node[program,func,nodes,~] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
332 }{ |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
333 nfunc <- Val[func] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
334 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
335 [groups]Next[current] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
336 { |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
337 out <- [worker]Compile Group[program,nfunc,groups,~] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
338 }{ |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
339 out <- Val[nfunc] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
340 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
341 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
342 |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
343 Release Var[func,type,name:out] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
344 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
345 out <- [func]Release[name] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
346 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
347 |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
348 Compile Worker@NWorker[worker,program,name:out] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
349 { |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
350 func <- Fold["Null", [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>], [worker]Outputs >>] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
351 groups <- [worker]Dependency Groups |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
352 [groups]First |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
353 { |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
354 final func <- [worker]Compile Group[program,func,groups, ~] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
355 }{ |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
356 final func <- Val[func] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
357 } |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
358 out <- [program]Store Function[Fold["Release Var", final func, [final func]Variables >>]] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
359 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
360 |
2 | 361 Test[:out] |
362 { | |
363 ref+ <- Worker Ref["+","cdecl",2,1] | |
364 ref* <- Worker Ref["*","cdecl",2,1] | |
365 ,a <- [NWorker["cdecl"] | |
366 ]Add Input["a", 0] { | |
367 ,b <- [~]Add Input["b", 1] { | |
368 ,c <- [~]Add Input["c", 2] { | |
369 ,outref <- [~]Add Output["out", 0] { | |
370 ,call+ <- [~]Add Worker Call[ref+] { | |
371 ,call* <- [~]Add Worker Call[ref*] { | |
372 out <- [[[[[~]Add Wire[a,0,call+,0] | |
373 ]Add Wire[b,0,call+,1] | |
374 ]Add Wire[call+,0,call*,0] | |
375 ]Add Wire[c,0,call*,1] | |
376 ]Add Wire[call*,0,outref,0] | |
377 }}}}}} | |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
378 } |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
379 |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
380 Test Graph to Backend[:out] |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
381 { |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
382 out <- [Test[]]Compile Worker[C Program[], "Test"] |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
383 } |
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
384 |
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
385 Main[] |
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
386 { |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
387 Pretty Print[Test Graph to Backend[], ""] |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
388 } |