Mercurial > repos > rhope
view nworker.rhope @ 31:fab5bb137cf9
Added Unix Time worker to interpreter
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Mon, 28 Sep 2009 19:48:45 -0400 |
parents | e9272f7ebd26 |
children | 914ad38f9b59 |
line wrap: on
line source
Import extendlib.rhope Import cbackend.rhope Set@Range[range,index,val:out] { out <- [[()]Concatenate[range] ]Set[index,val] } List of Lists[num:out] { out <- Fold[["Append"]Set Input[1, ()],(), Range[0,num]] } Blueprint Worker Ref { Name Convention Inputs Outputs } Worker Ref[name,convention,inputs,outputs:out] { out <- [[[[Build["Worker Ref"]]Name <<[name]]Convention <<[convention]]Inputs <<[inputs]]Outputs <<[outputs] } Blueprint Node Ref { Index IO Num } Node Ref[index,ionum:out] { out <- [[Build["Node Ref"]]Index <<[index]]IO Num <<[ionum] } =@Node Ref[left,right:out] { ,out <- If[[[left]Index >>] = [[right]Index >>]] { out <- [[left]IO Num>>] = [[right]IO Num >>] } } Blueprint NWorker Node { Type Data Inputs Outputs Wires From Wires To } Wire To@NWorker Node[node,from,output,input:out] { out <- [node]Wires To <<[ [[node]Wires To >>]Set[input, [[[node]Wires To >>]Index[input] ]Append[Node Ref[from,output]] ] ] } Wire From@NWorker Node[node,to,input,output:out] { out <- [node]Wires From <<[ [[node]Wires From >>]Set[output, [[[node]Wires From >>]Index[output] ]Append[Node Ref[to,input]] ] ] } _Dependency[dlist,ref:out] { [dlist]Find[ref] { out <- dlist }{ out <- [dlist]Append[ref] } } Dependencies@NWorker Node[node:out] { out <- Fold[["Fold"]Set Input[0, "_Dependency"], (), [node]Wires To >>] } NWorker Node[type,data,inputs,outputs:out] { out <- [[[[[[Build["NWorker Node"] ]Type <<[type] ]Data <<[data] ]Inputs <<[inputs] ]Outputs <<[outputs] ]Wires From <<[List of Lists[outputs]] ]Wires To <<[List of Lists[inputs]] } Blueprint NWorker { Convention Nodes Inputs Outputs NodeResults Free Temps } NWorker[convention:out] { out <- [[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()] } Add Node@NWorker[worker,type,data,inputs,outputs:out,node index] { out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]] node index <- [[worker]Nodes >>]Length } Add Worker Call@NWorker[worker,tocall:out,node index] { out, node index <- [worker]Add Node["call",tocall,[tocall]Inputs >>,[tocall]Outputs >>] } Add Constant@NWorker[worker,constant:out,node index] { out, node index <- [worker]Add Node["const",constant,0,1] } Add Input@NWorker[worker,name,number:out,node index] { ,node index <- [worker]Add Node["input",number,0,1] { out <- [~]Inputs <<[[[~]Inputs >>]Set[number,name]] } } Add Output@NWorker[worker,name,number:out,node index] { ,node index <- [worker]Add Node["output",number,1,0] { out <- [~]Outputs <<[[[~]Outputs >>]Set[number,name]] } } Add Wire@NWorker[worker,from,output,to,input:out] { fromw <- [[[worker]Nodes >>]Index[from]]Wire From[to,input,output] tow <- [[[worker]Nodes >>]Index[to]]Wire To[from,output,input] nodes <- [[[worker]Nodes >>]Set[from, fromw]]Set[to, tow] out <- [worker]Nodes <<[nodes] } _No Dependencies[list,node,index:out] { [[node]Wires To>>]First { out <- Val[list] }{ out <- [list]Append[index] } } No Dependencies@NWorker[worker:out] { out <- Fold["_No Dependencies", (), [worker]Nodes >>] } _Collect Dests[candidates,wire:out] { out <- [candidates]Set[[wire]Index >>, Yes] } Collect Dests@NWorker[worker,candidates,node index:out] { out <- Fold[["Fold"]Set Input[0, "_Collect Dests"], candidates, [[[worker]Nodes >>]Index[node index]]Wires From >>] } Check Dependency@NWorker[worker,nodes,wires,wire index:met?] { ref <- [wires]Index[wire index] [nodes]Find[[ref]Index >>] { [wires]Next[wire index] { met? <- [worker]Check Dependency[nodes,wires,~] }{ met? <- Yes } }{ met? <- No } } _Check Dependencies@NWorker[worker,nodes,inputs,input index:met?] { wires <- [inputs]Index[input index] [wires]First { current met? <- [worker]Check Dependency[nodes, wires, ~] }{ current met? <- Yes } If[current met?] { [inputs]Next[input index] { met? <- [worker]_Check Dependencies[nodes,inputs,~] }{ met? <- Yes } }{ met? <- No } } Check Dependencies@NWorker[worker,nodes,candidate:met?] { inputs <- [[[worker]Nodes >>]Index[candidate]]Wires To >> [inputs]First { met? <- [worker]_Check Dependencies[nodes, inputs, ~] }{ met? <- Yes } } Dependants@NWorker[worker,direct nodes,nodes:out] { candidates <- Keys[Fold[["Collect Dests"]Set Input[0,worker], (), direct nodes]] out <- Filter[candidates, [["Check Dependencies"]Set Input[0, worker]]Set Input[1, nodes]] } _Dependency Groups@NWorker[worker,last,all,grouped:out] { current <- [worker]Dependants[last,all] [current]First { out <- [worker]_Dependency Groups[current, [all]Concatenate[current], [grouped]Append[current]] }{ out <- grouped } } Dependency Groups@NWorker[worker:out] { no deps <- [worker]No Dependencies out <- [worker]_Dependency Groups[no deps, no deps, [()]Append[no deps]] } Format Input@NWorker[worker,noderef:out] { node <- [[worker]Nodes >>]Index[[noderef]Index >>] If[[[node]Type >>] = ["call"]] { out <- AddRef[ [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] ] }{ If[[[node]Type >>] = ["input"]] { input name <- [[worker]Inputs >>]Index[ [node]Data >> ] out <- AddRef[input name] } } } Collect Input@NWorker[worker,nodeinput:out] { inputchoices <- Map[nodeinput, ["Format Input"]Set Input[0, worker]] [inputchoices]First { first <- [inputchoices]Index[~] [inputchoices]Next[~] { out <- _Fold[inputchoices, ~, first, "OrValue"] }{ out <- Val[first] } }{ out <- No } } Collect Inputs@NWorker[worker,node:out] { out <- Map[[node]Wires To>>, ["Collect Input"]Set Input[0, worker]] } Save Result[func,num,node index:out] { out var <- [[["__result_"]Append[node index]]Append["_"]]Append[num] out <- [[func]Allocate Var[out var, "Any Type"] ]Move[Result[num], out var] } Compile Node@NWorker[worker,program,func,nodes,current:out] { Print[[node]Type >>] node index <- [nodes]Index[current] node <- [[worker]Nodes >>]Index[node index] If[[[node]Type >>] = ["call"]] { inputs <- [worker]Collect Inputs[node] [program]Method?[[[node]Data >>]Name >>] { with call <- [func]Method Call[[[node]Data >>]Name >>, inputs] }{ with call <- [func]Call[[[node]Data >>]Name >>, inputs] } nfunc <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, [node]Outputs >>]] }{ If[[[node]Type >>] = ["output"]] { inputs <- [worker]Collect Inputs[node] nfunc <- [func]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ] }{ nfunc <- Val[func] } } [nodes]Next[current] { out <- [worker]Compile Node[program,nfunc,nodes,~] }{ out <- Val[nfunc] } } Compile Group@NWorker[worker,program,func,groups,current:out] { nodes <- [groups]Index[current] [nodes]First { nfunc <- [worker]Compile Node[program,func,nodes,~] }{ nfunc <- Val[func] } [groups]Next[current] { out <- [worker]Compile Group[program,nfunc,groups,~] }{ out <- Val[nfunc] } } Release Var[func,type,name:out] { out <- [func]Release[name] } Compile Worker@NWorker[worker,program,name:out] { func <- Fold["Null", [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>], [worker]Outputs >>] groups <- [worker]Dependency Groups [groups]First { final func <- [worker]Compile Group[program,func,groups, ~] }{ final func <- Val[func] } out <- [program]Store Function[Fold["Release Var", final func, [final func]Variables >>]] } Test[:out] { ref+ <- Worker Ref["+","cdecl",2,1] ref* <- Worker Ref["*","cdecl",2,1] ,a <- [NWorker["cdecl"] ]Add Input["a", 0] { ,b <- [~]Add Input["b", 1] { ,c <- [~]Add Input["c", 2] { ,outref <- [~]Add Output["out", 0] { ,call+ <- [~]Add Worker Call[ref+] { ,call* <- [~]Add Worker Call[ref*] { out <- [[[[[~]Add Wire[a,0,call+,0] ]Add Wire[b,0,call+,1] ]Add Wire[call+,0,call*,0] ]Add Wire[c,0,call*,1] ]Add Wire[call*,0,outref,0] }}}}}} } Test Graph to Backend[:out] { out <- [Test[]]Compile Worker[C Program[], "Test"] } Main[] { Pretty Print[Test Graph to Backend[], ""] }