Mercurial > repos > rhope
view nworker.rhope @ 35:3498713c3dc9
C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Wed, 30 Sep 2009 23:55:04 -0400 |
parents | df038cef648b |
children | 495dddadd058 |
line wrap: on
line source
Import extendlib.rhope Import cbackend.rhope Blueprint Condition Set { Variables Subsets Condition Type } AndSet[:out] { out <- [[[Build["Condition Set"]]Variables <<[New@Dictionary[]]]Subsets <<[New@Dictionary[]]]Condition Type <<["And"] } OrSet[:out] { out <- [[[Build["Condition Set"]]Variables <<[New@Dictionary[]]]Subsets <<[New@Dictionary[]]]Condition Type <<["Or"] } To String@Condition Set[set:out] { out <- [[[[[set]Condition Type >> ]Append["Set:\n\tVariables:\n\t\t"] ]Append[ Join[Keys[[set]Variables >>], "\n\t\t"] ] ]Append["\n\tSubsets:\n\t\t"] ]Append[ Join[Keys[[set]Subsets >>], "\n\t\t"] ] } Add Condition@Condition Set[set,cond:out] { If[[Type Of[cond]] = ["Condition Set"]] { out <- [set]Subsets <<[ [[set]Subsets>>]Set[[cond]To String, cond] ] }{ out <- [set]Variables <<[ [[set]Variables >>]Set[cond, Yes] ] } } =@Condition Set[set1,set2:out] { ,out <- If[[[set1]Condition Type >>] = [[set2]Condition Type >>]] { ,out <- If[[[set1]Variables >>] = [[set2]Variables >>]] { out,out <- If[[[set1]Subsets >>] = [[set2]Subsets >>]] } } } _For Backend Var[current,junk,variable,type:out] { out <- [[<String@Worker[[type]Append["Cond"]]]Do[ [[()]Append[current]]Append[variable] ]]Index[0] } _For Backend Subset[current,subset,type:out] { Print["Calling For Backend on subset"] { [subset]For Backend { Print["Got output from for backend"] out <- [[<String@Worker[[type]Append["Cond"]]]Do[ [[()]Append[current]]Append[~] ]]Index[0] { Print["done _For Backend Subset with condition"] } }{ Print["none output from for backend"] out <- current } } } Empty?@Condition Set[set:not empty,empty] { [[set]Variables >>]First { not empty <- Yes }{ ,empty <- [[set]Subsets >>]First Non-empty Set { not empty <- Yes } } } _First Non-empty Set[setlist,index:out,none] { current <- [setlist]Index[index] [[current]Variables >>]First { out <- index }{ ,trynext <- [[current]Subsets >>]First Non-empty Set { out <- index } } Val[trynext] { ,none <- [setlist]Next[index] { out,none <- _First Non-empty Set[setlist, ~] } } } First Non-empty Set[setlist:index,none] { ,none <- [setlist]First { index,none <- _First Non-empty Set[setlist,~] } } For Backend@Condition Set[set:out,none] { Print["For Backend"] firstvar <- [[set]Variables >>]First { Print["At least one var"] [[set]Variables >>]Next[~] { Print["at least two vars"] vars <- _Fold[[set]Variables >>, ~, firstvar, ["_For Backend Var"]Set Input[3, [set]Condition Type >>]] }{ Print["just one var"] vars <- Val[firstvar] } out <- Fold[["_For Backend Subset"]Set Input[2, [set]Condition Type >>], vars, [set]Subsets >>] { Print["done For Backend, with vars"] } }{ Print["no vars"] [[set]Subsets >>]First Non-empty Set { Print[["At least one non-empty subset: "]Append[~]] firstsub <- [[[set]Subsets >>]Index[~]]For Backend [[set]Subsets >>]Next[~] { Print["at least two subsets"] out <- _Fold[[set]Subsets >>, ~, firstsub, ["_For Backend Subset"]Set Input[2, [set]Condition Type >>]] { Print["done with subsets, but no vars"] } }{ out <- Val[firstsub] { Pretty Print[~, "1s:\t"] } } }{ Print["done with none"] none <- Yes } } } 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 Conditions } Wire To@NWorker Node[node,from,output,pre input:out] { input <- [pre input]+[1] 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]+[1]]] ]Conditions <<[AndSet[]] } Blueprint NWorker { Convention Nodes Inputs Outputs Uses 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] { Print[[[[[[[[["Add Wire@NWorker["]Append[from]]Append[","]]Append[output]]Append[","]]Append[to]]Append[","]]Append[input]]Append["]"]] { fromw <- [[[worker]Nodes >>]Index[from]]Wire From[to,input,output] { Print["fromw"] } tow <- [[[worker]Nodes >>]Index[to]]Wire To[from,output,input] { Print["tow"] } nodes <- [[[worker]Nodes >>]Set[from, fromw]]Set[to, tow] { Print["nodes"] } out <- [worker]Nodes <<[nodes] { Print["Add Wire@NWorker done"] } } } Uses@NWorker[worker,uses:out] { out <- [worker]Uses <<[uses] } _No Dependencies[list,node,index:out] { [[node]Wires To>>]Index[1] { out <- Val[list] }{ [[[node]Wires To>>]Index[0]]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] }{ If[[[node]Type >>] = ["const"]] { out <- Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[[node]Data >>]] } } } } 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[Tail[[node]Wires To>>, 1], ["Collect Input"]Set Input[0, worker]] } Collect Input Condition@NWorker[worker,set,noderef:out] { node <- [[worker]Nodes >>]Index[ [noderef]Index >> ] If[[[node]Outputs >>] > [1]] { out <- [set]Add Condition[ [["__result_"]Append[[noderef]Index >>]]Append[["_"]Append[[noderef]IO Num >>]] ] }{ out <- [set]Add Condition[[node]Conditions >>] } } Collect Condition@NWorker[worker,set,nodeinput:out] { out <- [set]Add Condition[Fold[["Collect Input Condition"]Set Input[0, worker], OrSet[], nodeinput]] } Collect Conditions@NWorker[worker,node:out] { Print["Collect Conditions"] { out <- Fold[["Collect Condition"]Set Input[0, worker], AndSet[], [node]Wires To>>] { Print["done Collect Conditions"] } } } Save Result[func,num,node index:out] { Print["Save Result"] out var <- [[["__result_"]Append[node index]]Append["_"]]Append[num] Print[out var] /*out <- [[func]Allocate Var[out var, "Any Type"] ]Move[Result[num], out var] */ out <- [func]Move[Result[num], out var] } Compile Call Node[node,program,func,inputs,node index:out] { [program]Method?[[[node]Data >>]Name >>] { Print["Method!"] with call <- [func]Method Call[[[node]Data >>]Name >>, inputs] { Print["Method Call done"] } }{ Print["Function!"] with call <- [func]Call[[[node]Data >>]Name >>, inputs] } out <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, [node]Outputs >>]] } Compile Node@NWorker[worker,program,func,nodes,current:out,out worker] { Print[["Compile Node: "]Append[[node]Type >>]] node index <- [nodes]Index[current] node <- [[worker]Nodes >>]Index[node index] conditions <- [worker]Collect Conditions[node] If[[[node]Type >>] = ["call"]] { Print[["Call: "]Append[[[node]Data >>]Name >>]] inputs <- [worker]Collect Inputs[node] [conditions]For Backend { Print["Conditional execution, do if"] stream <- [func]Instruction Stream nfunc <- [func]Do If[~, nstream] }{ Print["No conditions, full steam ahead"] stream <- Val[func] nfunc <- Val[nstream] } nstream <- Compile Call Node[node, program, stream, inputs, node index] }{ If[[[node]Type >>] = ["output"]] { inputs <- [worker]Collect Inputs[node] [conditions]For Backend { stream <- [func]Instruction Stream nfunc <- [func]Do If[~, nstream] }{ stream <- Val[func] nfunc <- Val[nstream] } nstream <- [stream]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ] }{ If[[[node]Type >>] = ["const"]] { //TODO: Handle list constants nfunc <- [func]Register Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[[node]Data >>], [node]Data >>] }{ nfunc <- Val[func] } } } If[[[node]Outputs >>] = [0]] { nworker <- Val[worker] }{ nworker <- [worker]Nodes <<[ [[worker]Nodes >>]Set[node index, [node]Conditions <<[conditions]] ] } [nodes]Next[current] { out,out worker <- [nworker]Compile Node[program,nfunc,nodes,~] }{ out <- Val[nfunc] out worker <- Val[nworker] } } Compile Group@NWorker[worker,program,func,groups,current:out,out worker] { nodes <- [groups]Index[current] [nodes]First { nfunc,nworker <- [worker]Compile Node[program,func,nodes,~] }{ nfunc <- Val[func] nworker <- Val[worker] } [groups]Next[current] { out,out worker <- [nworker]Compile Group[program,nfunc,groups,~] }{ out <- Val[nfunc] out worker <- Val[nworker] } } Release Var@NWorker[worker,func,name:out] { //_result_index_ionum parts <- [name]Split["_"] index <- <String@Whole Number[ [parts]Index[2] ] io num <- <String@Whole Number[ [parts]Index[3] ] node <- [[worker]Nodes >>]Index[index] do if <- If[[[node]Outputs >>] > [1]] {} { ,do if <- [[node]Conditions >>]Empty? { out <- [func]Release[name] } } Val[do if] { stream <- [[func]Instruction Stream]Release[name] out <- [func]Do If[name, stream] } } Result Var[vars,io num,index:out] { out <- [vars]Append[[[["__result_"]Append[index]]Append["_"]]Append[io num]] } Node Result Vars[vars,node,index:out] { If[[[node]Type >>] = ["call"]] { out <- Fold[["Result Var"]Set Input[2, index], vars, Range[0, [node]Outputs >>]] }{ out <- vars } } Result Vars@NWorker[worker:out] { out <- Fold["Node Result Vars", (), [worker]Nodes >>] } Compile Worker@NWorker[worker,program,name:out] { Print[["Compiling: "]Append[name]] { ifunc <- [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>] res vars <- [worker]Result Vars func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, res vars], res vars], [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"]Set Input[0, worker], final func, res vars]] } } Test[:out] { ref+ <- Worker Ref["+","rhope",2,1] ref* <- Worker Ref["*","rhope",2,1] ,a <- [NWorker["rhope"] ]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"] } Blueprint NProgram { Blueprints Workers Worker Refs } NProgram[:out] { out <- [[[Build["NProgram"]]Blueprints <<[New@Dictionary[]]]Workers <<[New@Dictionary[]]]Worker Refs <<[New@Dictionary[]] } Bind Worker@NProgram[prog,name,worker:out] { out <- [prog]Workers << [ [[prog]Workers >>]Set[name, worker] ] } Bind Blueprint@NProgram[prog,name,blueprint:out] { out <- [prog]Blueprints << [ [[prog]Blueprints >>]Set[name, blueprint] ] } _Compile Program[backend, worker, name:out] { out <- [worker]Compile Worker[backend, name] } Compile Program@NProgram[prog, backend:out] { out <- Fold["_Compile Program", backend, [prog]Workers >>] } Register Worker@NProgram[prog, name, convention, inputs, outputs: out] { Print[["Register Worker "]Append[name]] out <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs]]] } Register Builtins@NProgram[prog:out] { out <- [[[[[[[[[prog]Register Worker["+", "rhope", 2, 1] ]Register Worker["-", "rhope", 2, 1] ]Register Worker["*", "rhope", 2, 1] ]Register Worker["/", "rhope", 2, 1] ]Register Worker["Print", "rhope", 1, 1] ]Register Worker["Index", "rhope", 2, 1] ]Register Worker["If", "rhope", 1, 2] ]Register Worker["<", "rhope", 2, 1] ]Register Worker[">", "rhope", 1, 1] } Find Worker@NProgram[prog, name:out,notfound] { Print[ ["Find Worker@NProgram: "]Append[name] ] out,notfound <- [[prog]Worker Refs >>]Index[name] }