Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/low-to-tree/low-to-tree.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/low-to-tree/low-to-tree.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3834, Sat May 7 18:39:53 2016 UTC revision 3835, Sun May 8 13:10:17 2016 UTC
# Line 8  Line 8 
8    
9  structure LowToTree : sig  structure LowToTree : sig
10    
11      val translate : LowIR.program * TreeTypes.vector_layout -> TreeIR.program      val translate : LowIR.program * TreeTypes.vec_layout -> TreeIR.program
12    
13    end = struct    end = struct
14    
# Line 16  Line 16 
16      structure V = LowIR.Var      structure V = LowIR.Var
17      structure Ty = LowTypes      structure Ty = LowTypes
18      structure Op = LowOps      structure Op = LowOps
19        structure GV = IR.GlobalVar
20        structure SV = IR.StateVar
21      structure T = TreeIR      structure T = TreeIR
22      structure TTy = TreeTypes      structure TTy = TreeTypes
23      structure TOp = TreeOps      structure TOp = TreeOps
# Line 23  Line 25 
25      structure TGV = TreeGlobalVar      structure TGV = TreeGlobalVar
26      structure TSV = TreeStateVar      structure TSV = TreeStateVar
27    
28      (* translate a type for an in-memory type (i.e., the type of a global or state variable) *)
29        fun trMemoryTy ty = (case ty
30               of Ty.BoolTy => TTy.BoolTy
31                | Ty.IntTy => TTy.IntTy
32                | Ty.StringTy => TTy.StringTy
33                | Ty.TensorTy dd => TTy.TensorTy dd
34                | Ty.TupleTy tys => TTy.TupleTy(List.map trMemoryTy tys)
35                | Ty.SeqTy(ty, dim) => TTy.SeqTy(trMemoryTy ty, dim)
36                | Ty.ImageTy info => TTy.ImageTy info
37              (* end case *))
38    
39      (* associate Tree IL globals variables with Low IL variables using properties *)
40        local
41          val {setFn, peekFn, ...} =
42                GV.newProp (fn x => raise Fail(concat["getGlobalVar(", GV.uniqueName x, ")"]))
43        in
44          fun mkGlobalVar x = (case peekFn x
45                 of NONE => let
46                        val x' = TGV.new {
47                                name = GV.name x,
48                                ty = trMemoryTy (GV.ty x),
49                                input = GV.isInput x,
50                                output = false, (* FIXME: change once we support output globals *)
51                                varying = ??,
52                                apiTy = ??
53                              }
54                        in
55                          setFn (x, x');
56                          x'
57                        end
58                  | SOME x' => x'
59                (* end case *))
60        end
61    
62      (* associate Tree IL state variables with Low IL variables using properties *)
63        local
64          fun mkStateVar x = TSV.new {
65                  name = SV.name x,
66                  ty = trMemoryTy (SV.ty x),
67                  varying = VA.isVarying x,
68                  apiTy = ??
69                }
70        in
71        val {getFn = getStateVar, ...} = SV.newProp mkStateVar
72        end
73    
74      fun mkBlock stms = T.Block{locals=[], body=stms}      fun mkBlock stms = T.Block{locals=[], body=stms}
75      fun mkIf (x, stms, []) = T.S_IfThen(x, mkBlock stms)      fun mkIf (x, stms, []) = T.S_IfThen(x, mkBlock stms)
76        | mkIf (x, stms1, stms2) = T.S_IfThenElse(x, mkBlock stms1, mkBlock stms2)        | mkIf (x, stms1, stms2) = T.S_IfThenElse(x, mkBlock stms1, mkBlock stms2)
77    
78      fun cvtScalarTy Ty.BoolTy = TTy.BoolTy      fun cvtScalarTy Ty.BoolTy = TTy.BoolTy
79        | cvtScalarTy Ty.IntTy = TTy.IntTy        | cvtScalarTy Ty.IntTy = TTy.IntTy
80        | cvtScalarTy (Ty.TensorTy[]) = TTy.RealTy        | cvtScalarTy (Ty.TensorTy[]) = TTy.realTy
81        | cvtScalarTy ty = raise Fail(concat["cvtScalarTy(", Ty.toString ty, ")"])        | cvtScalarTy ty = raise Fail(concat["cvtScalarTy(", Ty.toString ty, ")"])
82    
83      fun vectorArg (env, x) = (case Env.useVar env x      fun vectorArg (env, x) = (case Env.useVar env x
# Line 54  Line 102 
102            end            end
103    
104      fun trOp (env, lhs, srcRator, args) = let      fun trOp (env, lhs, srcRator, args) = let
105            fun bindOp rator = Env.TREE(DstIR.E_Op(rator, List.map (Env.useVar env) args))            fun bindOp rator = Env.TREE(T.E_Op(rator, List.map (Env.useVar env) args))
106            fun binVOp rator = let            fun bindVOp rator = let
107                  val (layout, argss) = vectorArgs (env, args)                  val (layout, argss) = vectorArgs (env, args)
108                  val exps = ListPair.map                  val exps = ListPair.map
109                        (fn (w, args) => DstIR.E_Op(rator w, args))                        (fn (w, args) => T.E_Op(rator w, args))
110                          (#pieces layout, argss)                          (#pieces layout, argss)
111                  in                  in
112                    Env.VEC(layout, exps)                    Env.VEC(layout, exps)
# Line 130  Line 178 
178                | Op.Round d => ??                | Op.Round d => ??
179                | Op.Trunc 1 => bindOp (TOp.Trunc 1)                | Op.Trunc 1 => bindOp (TOp.Trunc 1)
180                | Op.Trunc d => ??                | Op.Trunc d => ??
181                | Op.IntToReal => bindOp Op.IntToReal                | Op.IntToReal => bindOp TOp.IntToReal
182                | Op.RealToInt 1 => ??                | Op.RealToInt 1 => ??
183                | Op.RealToInt d => ??                | Op.RealToInt d => ??
184                | Op.R_All ty => ??                | Op.R_All ty => ??
# Line 143  Line 191 
191                | Op.R_Variance ty => ??                | Op.R_Variance ty => ??
192                | Op.Transform info => ??                | Op.Transform info => ??
193                | Op.Translate info => ??                | Op.Translate info => ??
194                | Op.ControlIndex(info, ctl) => ??                | Op.ControlIndex(info, ctl, d) => ??
195                | Op.LoadVoxel info => ??                | Op.LoadVoxel info => ??
196                | Op.Inside(info, s) => ??                | Op.Inside(info, s) => ??
197                | Op.ImageDim(info, d) => ??                | Op.ImageDim(info, d) => bindOp(TOp.ImageDim(info, d))
198                | Op.LoadSeq(ty, file) => ??                | Op.LoadSeq(ty, file) => ??
199                | Op.LoadImage(ty, file) => ??                | Op.LoadImage(ty, file) => ??
200                | Op.MathFn f => bindOp (TOp.MathFn f)                | Op.MathFn f => bindOp (TOp.MathFn f)
# Line 183  Line 231 
231       *)       *)
232        | ELSE_BR of T.stm list * T.exp * T.stm list * IR.node_kind        | ELSE_BR of T.stm list * T.exp * T.stm list * IR.node_kind
233    
234      fun trCFG cfg = let      fun trCFGWithEnv (env, prefix, cfg) = let
235              fun useScalar x = (case Env.useVar env x
236                     of Env.TREE e => e
237                      | _ => raise Fail("expected scalar binding for " ^ V.toString x)
238                    (* end case *))
239            val _ = UnifyVars.analyze cfg            val _ = UnifyVars.analyze cfg
240          (* join (env, stk, stms, k): handle a control-flow join, where env is the          (* join (env, stk, stms, k): handle a control-flow join, where env is the
241           * current environment, stk is the stack of open ifs (the top of stk specifies           * current environment, stk is the stack of open ifs (the top of stk specifies
# Line 191  Line 243 
243           * on the current path, and k is the kind of the join node (either JOIN or EXIT).           * on the current path, and k is the kind of the join node (either JOIN or EXIT).
244           *)           *)
245            fun join (env, [], _, IR.JOIN _) = raise Fail "JOIN with no open if"            fun join (env, [], _, IR.JOIN _) = raise Fail "JOIN with no open if"
246              | join (env, [], stms, _) = endScope (env, prefix @ List.rev stms)              | join (env, [], stms, _) = Env.endScope (env, prefix @ List.rev stms)
247              | join (env, THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let              | join (env, THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let
248                  val (env, thenBlk) = flushPending (env, thenBlk)                  val (env, thenBlk) = flushPending (env, thenBlk)
249                  in                  in
# Line 227  Line 279 
279                          end                          end
280                    (* end case *)                    (* end case *)
281                  end                  end
282            and doNode (env, nd : IR.node, ifStk : open_if list, stms) = (case  Nd.kind nd            and doNode (env, nd : IR.node, ifStk : open_if list, stms) = (case IR.Node.kind nd
283                   of IR.NULL => raise Fail "unexpected NULL"                   of IR.NULL => raise Fail "unexpected NULL"
284                    | IR.ENTRY{succ} => doNode (env, !succ, ifStk, stms)                    | IR.ENTRY{succ} => doNode (env, !succ, ifStk, stms)
285                    | k as IR.JOIN _ => join (env, ifStk, stms, k)                    | k as IR.JOIN _ => join (env, ifStk, stms, k)
286                    | IR.COND{cond, trueBranch, falseBranch, ...} => let                    | IR.COND{cond, trueBranch, falseBranch, ...} => let
287                        val cond = useVar env cond                        val cond = useScalar (!cond)
288                        val (env, stms) = flushPending (env, stms)                        val (env, stms) = flushPending (env, stms)
289                        in                        in
290                          doNode (env, !trueBranch, THEN_BR(stms, cond, !falseBranch)::ifStk, [])                          doNode (env, !trueBranch, THEN_BR(stms, cond, !falseBranch)::ifStk, [])
291                        end                        end
292                    | IR.FOREACH{var, src, bodyExit, succ, ...} => let                    | IR.FOREACH{var, src, bodyEntry, succ, ...} => let
293                        val src = useVar (env, src)                        val src = useScalar (!src)
294                        val var = ??                        val var = ??
295                        val (env, stms) = flushPending (env, stms)                        val (env, stms) = flushPending (env, stms)
296                        val body = doNode (env, !bodyEntry, [], [])                        val body = doNode (env, !bodyEntry, [], [])
# Line 246  Line 298 
298                        in                        in
299                          doNode (env, !succ, ifStk, stm::stms)                          doNode (env, !succ, ifStk, stm::stms)
300                        end                        end
301                    | IR.NEXT _ => ??                    | IR.NEXT _ => Env.endScope (env, List.rev stms)
302                    | IR.COM {text, succ, ...} =>                    | IR.COM {text, succ, ...} =>
303                        doNode (env, !succ, ifStk, T.S_Comment text :: stms)                        doNode (env, !succ, ifStk, T.S_Comment text :: stms)
304                    | IR.ASSIGN{stm=(lhs, rhs), succ, ...} => let                    | IR.ASSIGN{stm=(lhs, rhs), succ, ...} => let
# Line 292  Line 344 
344                        end                        end
345                    | k as IR.EXIT{kind, succ, ...} => (case (!succ, kind)                    | k as IR.EXIT{kind, succ, ...} => (case (!succ, kind)
346                         of (NONE, ExitKind.RETURN) => let                         of (NONE, ExitKind.RETURN) => let
347  (* FIXME: we should probably call flushPending here! *)                              val suffix = [T.S_Exit]
                             val suffix = finish env @ [T.S_Exit(List.map (useVar env) live)]  
348                              in                              in
349                                Env.endScope (env, prefix @ List.revAppend(stms, suffix))                                Env.endScope (env, prefix @ List.revAppend(stms, suffix))
350                              end                              end
351                          | (NONE, ExitKind.ACTIVE) => let                          | (NONE, ExitKind.ACTIVE) => let
352  (* FIXME: we should probably call flushPending here! *)                              val suffix = [T.S_Active]
                             val suffix = finish env @ [T.S_Active]  
353                              in                              in
354                                Env.endScope  (env, prefix @ List.revAppend(stms, suffix))                                Env.endScope  (env, prefix @ List.revAppend(stms, suffix))
355                              end                              end
356                          | (NONE, ExitKind.STABILIZE) => let                          | (NONE, ExitKind.STABILIZE) => let
 (* FIXME: we should probably call flushPending here! *)  
357                              val stms = T.S_Stabilize :: stms                              val stms = T.S_Stabilize :: stms
358                              in                              in
359                                join (env, ifStk, stms, k)                                join (env, ifStk, stms, k)
# Line 322  Line 371 
371              doNode (Env.new(), CFG.entry cfg, [], [])              doNode (Env.new(), CFG.entry cfg, [], [])
372            end            end
373    
374        fun trCFG (prefix, cfg) = trCFGWithEnv (Env.new(), prefix, cfg)
375    
376        fun trStrand strand = let
377              val IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM} = strand
378              val params' = List.map newParam params
379              val env = ListPair.foldlEq
380                    (fn (x, x', env) => rename(env, x, x')) ?? (params, params')
381              val state' = List.map getStateVar state
382              in
383                T.Strand{
384                    name = name,
385                    params = params',
386                    state = state',
387                    stateInit = trCFGWithEnv (env, stateInit),
388                    initM = Option.map (fn cfg => trCFG ([], cfg)) initM,
389                    updateM = trCFG ([], updateM),
390                    stabilizeM = Option.map (fn cfg => trCFG ([], cfg)) stabilizeM
391                  }
392              end
393    
394      fun translate (prog, vecLayout) = let      fun translate (prog, vecLayout) = let
395            val LowIR.Program{            val LowIR.Program{
396                    props, consts, inputs, constInit, globals, globalInit, strand, create, update                    props, consts, inputs, constInit, globals, globalInit, strand, create, update

Legend:
Removed from v.3834  
changed lines
  Added in v.3835

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0