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 3850, Thu May 12 18:05:47 2016 UTC revision 3851, Thu May 12 19:27:43 2016 UTC
# Line 8  Line 8 
8    
9  structure LowToTree : sig  structure LowToTree : sig
10    
11      val translate : LowIR.program * (int -> TreeTypes.vec_layout) -> TreeIR.program      val translate : LowIR.program * Env.target_info -> TreeIR.program
12    
13    end = struct    end = struct
14    
# Line 113  Line 113 
113            end            end
114    
115      fun trOp (env, lhs, srcRator, args) = let      fun trOp (env, lhs, srcRator, args) = let
           fun bindOp rator = let  
116                  fun getBinding x = (case Env.useVar env x                  fun getBinding x = (case Env.useVar env x
117                         of Env.TREE e => e                         of Env.TREE e => e
118                          | _ => raise Fail("expected single binding for " ^ IR.Var.toString x)                          | _ => raise Fail("expected single binding for " ^ IR.Var.toString x)
119                        (* end case *))                        (* end case *))
120              fun assignOp rator = let
121                    val stm = T.S_Assign(??, T.E_Op(rator, List.map getBinding args))
122                  in                  in
123                    Env.TREE(T.E_Op(rator, List.map getBinding args))                    [stm]
124                  end                  end
125    (* FIXME: if the use count of lhs is > 1, then we should bind to a local variable *)
126              fun bindOp rator = (
127                    Env.bindVar (env, lhs, Env.TREE(T.E_Op(rator, List.map getBinding args)));
128                    [])
129            fun bindVOp rator = let            fun bindVOp rator = let
130                  val (layout, argss) = vectorArgs (env, args)                  val (layout, argss) = vectorArgs (env, args)
131                  val exps = ListPair.map                  val exps = ListPair.map
132                        (fn (w, args) => T.E_Op(rator w, args))                        (fn (w, args) => T.E_Op(rator w, args))
133                          (#pieces layout, argss)                          (#pieces layout, argss)
134                  in                  in
135                    Env.VEC(layout, exps)                    Env.bindVar (env, lhs, Env.VEC(layout, exps));
136                      []
137                  end                  end
138            in            in
139              case srcRator              case srcRator
# Line 166  Line 172 
172                    val ({pieces, ...}, es) = vectorArg (env, hd args)                    val ({pieces, ...}, es) = vectorArg (env, hd args)
173                    fun select (i, w::ws, e::es) =                    fun select (i, w::ws, e::es) =
174                          if (i < w)                          if (i < w)
175                            then Env.TREE(T.E_Op(TOp.VIndex(w, i), [e]))  (* FIXME: what if lhs is used more than once? *)
176                              then Env.bindVar (env, lhs, Env.TREE(T.E_Op(TOp.VIndex(w, i), [e])))
177                            else select (i-w, ws, es)                            else select (i-w, ws, es)
178                      | select _ = raise Fail("bogus " ^ Op.toString srcRator)                      | select _ = raise Fail("bogus " ^ Op.toString srcRator)
179                    in                    in
180                      select (i, pieces, es)                      select (i, pieces, es);
181                        []
182                    end                    end
183                | Op.VClamp n => bindVOp TOp.VClamp                | Op.VClamp n => bindVOp TOp.VClamp
184                | Op.VMapClamp n => bindVOp TOp.VMapClamp                | Op.VMapClamp n => bindVOp TOp.VMapClamp
185                | Op.VLerp n => bindVOp TOp.VLerp                | Op.VLerp n => bindVOp TOp.VLerp
186                | Op.TensorIndex(ty, idxs) => ??                | Op.TensorIndex(ty, idxs) => ??
187                | Op.ProjectLast(ty, idxs) => ??                | Op.ProjectLast(ty, idxs) => ??
188                | Op.EigenVecs2x2 => ??                | Op.EigenVecs2x2 => assignOp TOp.EigenVecs2x2
189                | Op.EigenVecs3x3 => ??                | Op.EigenVecs3x3 => assignOp TOp.EigenVecs3x3
190                | Op.EigenVals2x2 => ??                | Op.EigenVals2x2 => assignOp TOp.EigenVals2x2
191                | Op.EigenVals3x3 => ??                | Op.EigenVals3x3 => assignOp TOp.EigenVals3x3
192                | Op.Zero ty => ??                | Op.Zero ty => ??
193                | Op.Select(Ty.TupleTy tys, i) => ??                | Op.Select(Ty.TupleTy tys, i) => ??
194                | Op.Subscript(Ty.SeqTy(ty, NONE)) => ??                | Op.Subscript(Ty.SeqTy(ty, NONE)) => ??
# Line 200  Line 208 
208                | Op.Tan => bindOp TOp.Tan                | Op.Tan => bindOp TOp.Tan
209                | Op.ArcTan => bindOp TOp.ArcTan                | Op.ArcTan => bindOp TOp.ArcTan
210                | Op.Ceiling 1 => bindOp (TOp.Ceiling 1)                | Op.Ceiling 1 => bindOp (TOp.Ceiling 1)
211                | Op.Ceiling d => ??                | Op.Ceiling d => bindVOp TOp.Ceiling
212                | Op.Floor 1 => bindOp (TOp.Floor 1)                | Op.Floor 1 => bindOp (TOp.Floor 1)
213                | Op.Floor d => ??                | Op.Floor d => bindVOp TOp.Floor
214                | Op.Round 1 => bindOp (TOp.Floor 1)                | Op.Round 1 => bindOp (TOp.Round 1)
215                | Op.Round d => ??                | Op.Round d => bindVOp TOp.Round
216                | Op.Trunc 1 => bindOp (TOp.Trunc 1)                | Op.Trunc 1 => bindOp (TOp.Trunc 1)
217                | Op.Trunc d => ??                | Op.Trunc d => bindVOp TOp.Trunc
218                | Op.IntToReal => bindOp TOp.IntToReal                | Op.IntToReal => bindOp TOp.IntToReal
219                | Op.RealToInt 1 => ??                | Op.RealToInt 1 => bindOp (TOp.RealToInt 1)
220                | Op.RealToInt d => ??                | Op.RealToInt d => ??
221  (* FIXME  (* FIXME
222                | Op.R_All ty => ??                | Op.R_All ty => ??
# Line 220  Line 228 
228                | Op.R_Mean ty => ??                | Op.R_Mean ty => ??
229                | Op.R_Variance ty => ??                | Op.R_Variance ty => ??
230  *)  *)
231                | Op.Transform info => ??                | Op.Transform info => bindOp (TOp.Transform info)
232                | Op.Translate info => ??                | Op.Translate info => bindOp (TOp.Translate info)
233                | Op.ControlIndex(info, ctl, d) => ??                | Op.ControlIndex(info, ctl, d) => bindOp (TOp.ControlIndex(info, ctl, d))
234                | Op.LoadVoxel info => ??                | Op.LoadVoxel info => bindOp (TOp.LoadVoxel info)
235                | Op.Inside(info, s) => ??                | Op.Inside(info, s) => ??
236                | Op.ImageDim(info, d) => bindOp(TOp.ImageDim(info, d))                | Op.ImageDim(info, d) => bindOp(TOp.ImageDim(info, d))
237                | Op.LoadSeq(ty, file) => ??                | Op.LoadSeq(ty, file) => ??
# Line 239  Line 247 
247           *)           *)
248            fun bindSimple rhs = (case UnifyVars.eqClassOf lhs            fun bindSimple rhs = (case UnifyVars.eqClassOf lhs
249                   of SOME x => ??                   of SOME x => ??
250                    | NONE => (Env.bindSimple (env, lhs, rhs); (env, []))                    | NONE => (Env.bindSimple (env, lhs, rhs); [])
251                  (* end case *))                  (* end case *))
252            in            in
253              case rhs              case rhs
# Line 279  Line 287 
287                    | _ => raise Fail("expected scalar binding for " ^ V.toString x)                    | _ => raise Fail("expected scalar binding for " ^ V.toString x)
288                  (* end case *))                  (* end case *))
289            val _ = UnifyVars.analyze cfg            val _ = UnifyVars.analyze cfg
290          (* join (env, stk, stms, k): handle a control-flow join, where env is the          (* join (stk, stms, k): handle a control-flow join, where env is the
291           * 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
292           * which branch we are in), stms are the TreeIL statements preceding the join           * which branch we are in), stms are the TreeIL statements preceding the join
293           * 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).
294           *)           *)
295            fun join (env, [], _, IR.JOIN _) = raise Fail "JOIN with no open if"            fun join ([], _, IR.JOIN _) = raise Fail "JOIN with no open if"
296              | join (env, [], stms, _) = mkBlock (prefix @ List.rev stms)              | join ([], stms, _) = mkBlock (prefix @ List.rev stms)
297              | join (env, THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let              | join (THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let
298                  val (env, thenBlk) = Env.flushPending (env, thenBlk)                  val thenBlk = Env.flushPending (env, thenBlk)
299                  in                  in
300                    doNode (env, elseBr, ELSE_BR(stms1, cond, thenBlk, k)::stk, [])                    doNode (elseBr, ELSE_BR(stms1, cond, thenBlk, k)::stk, [])
301                  end                  end
302              | join (env, ELSE_BR(stms, cond, thenBlk, k1)::stk, elseBlk, k2) = let              | join (ELSE_BR(stms, cond, thenBlk, k1)::stk, elseBlk, k2) = let
303                  val (env, elseBlk) = Env.flushPending (env, elseBlk)                  val elseBlk = Env.flushPending (env, elseBlk)
304                  in                  in
305                    case (k1, k2)                    case (k1, k2)
306                     of (IR.JOIN{succ, ...}, IR.JOIN _) => let                     of (IR.JOIN{succ, ...}, IR.JOIN _) => let
307                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)
308                          in                          in
309                            doNode (env, !succ, stk, stm::stms)                            doNode (!succ, stk, stm::stms)
310                          end                          end
311                      | (IR.JOIN{succ, ...}, _) => let                      | (IR.JOIN{succ, ...}, _) => let
312                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)
313                          in                          in
314                            doNode (env, !succ, stk, stm::stms)                            doNode (!succ, stk, stm::stms)
315                          end                          end
316                      | (_, IR.JOIN{succ, ...}) => let                      | (_, IR.JOIN{succ, ...}) => let
317                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)
318                          in                          in
319                            doNode (env, !succ, stk, stm::stms)                            doNode (!succ, stk, stm::stms)
320                          end                          end
321                      | (_, _) => let                      | (_, _) => let
322                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)
# Line 317  Line 325 
325                          end                          end
326                    (* end case *)                    (* end case *)
327                  end                  end
328            and doNode (env, nd : IR.node, ifStk : open_if list, stms) = (case IR.Node.kind nd            and doNode (nd : IR.node, ifStk : open_if list, stms) = (case IR.Node.kind nd
329                   of IR.NULL => raise Fail "unexpected NULL"                   of IR.NULL => raise Fail "unexpected NULL"
330                    | IR.ENTRY{succ} => doNode (env, !succ, ifStk, stms)                    | IR.ENTRY{succ} => doNode (!succ, ifStk, stms)
331                    | k as IR.JOIN _ => join (env, ifStk, stms, k)                    | k as IR.JOIN _ => join (ifStk, stms, k)
332                    | IR.COND{cond, trueBranch, falseBranch, ...} => let                    | IR.COND{cond, trueBranch, falseBranch, ...} => let
333                        val cond = useScalar (!cond)                        val cond = useScalar (!cond)
334                        val (env, stms) = Env.flushPending (env, stms)                        val stms = Env.flushPending (env, stms)
335                        in                        in
336                          doNode (env, !trueBranch, THEN_BR(stms, cond, !falseBranch)::ifStk, [])                          doNode (!trueBranch, THEN_BR(stms, cond, !falseBranch)::ifStk, [])
337                        end                        end
338                    | IR.FOREACH{var, src, bodyEntry, succ, ...} => let                    | IR.FOREACH{var, src, bodyEntry, succ, ...} => let
339                        val src = useScalar (!src)                        val src = useScalar (!src)
340                        val var = Util.newIterVar var                        val var = Util.newIterVar var
341                        val (env, stms) = Env.flushPending (env, stms)                        val stms = Env.flushPending (env, stms)
342                        val body = doNode (env, !bodyEntry, [], [])                        val body = doNode (!bodyEntry, [], [])
343                        val stm = T.S_Foreach(var, src, body)                        val stm = T.S_Foreach(var, src, body)
344                        in                        in
345                          doNode (env, !succ, ifStk, stm::stms)                          doNode (!succ, ifStk, stm::stms)
346                        end                        end
347                    | IR.NEXT _ => mkBlock (List.rev stms)                    | IR.NEXT _ => mkBlock (List.rev stms)
348                    | IR.COM {text, succ, ...} =>                    | IR.COM {text, succ, ...} =>
349                        doNode (env, !succ, ifStk, T.S_Comment text :: stms)                        doNode (!succ, ifStk, T.S_Comment text :: stms)
350                    | IR.ASSIGN{stm=(lhs, rhs), succ, ...} => let                    | IR.ASSIGN{stm=(lhs, rhs), succ, ...} => let
351                        val (env, stms') = trAssign (env, lhs, rhs)                        val (env, stms') = trAssign (env, lhs, rhs)
352                        in                        in
353                          doNode (env, !succ, ifStk, stms' @ stms)                          doNode (!succ, ifStk, stms' @ stms)
354                        end                        end
355                    | IR.MASSIGN{stm=(ys, rator, xs), succ, ...} => let                    | IR.MASSIGN{stm=(ys, rator, xs), succ, ...} => let
356                        fun doLHSVar (y, (env, ys)) = let                        fun doLHSVar (y, (env, ys)) = let
# Line 359  Line 367 
367                              (* end case *))                              (* end case *))
368                        val stm = T.S_MAssign(ys, T.E_Op(rator, List.map (singleArg env) xs))                        val stm = T.S_MAssign(ys, T.E_Op(rator, List.map (singleArg env) xs))
369                        in                        in
370                          doNode (env, !succ, ifStk, stm :: stms)                          doNode (!succ, ifStk, stm :: stms)
371                        end                        end
372                    | IR.GASSIGN{lhs, rhs, succ, ...} => let                    | IR.GASSIGN{lhs, rhs, succ, ...} => let
373                        val stm = (case useAsInput(env, rhs)                        val stm = (case useAsInput(env, rhs)
# Line 367  Line 375 
375                                | SOME mkStm => mkStm(mkGlobalVar lhs)                                | SOME mkStm => mkStm(mkGlobalVar lhs)
376                              (* end case *))                              (* end case *))
377                        in                        in
378                          doNode (env, !succ, ifStk, stm::stms)                          doNode (!succ, ifStk, stm::stms)
379                          end
380                      | IR.NEW{strand, args, succ, ...} => let
381                          val stm = T.S_New(strand, List.map (singleArg env) args)
382                          in
383                            doNode (!succ, ifStk, stm::stms)
384                        end                        end
                   | IR.NEW{strand, args, succ, ...} => raise Fail "NEW unimplemented"  
385                    | IR.SAVE{lhs, rhs, succ, ...} => let                    | IR.SAVE{lhs, rhs, succ, ...} => let
386                        val stm = T.S_Save(getStateVar lhs, singleArg env rhs)                        val stm = T.S_Save(getStateVar lhs, singleArg env rhs)
387                        in                        in
388                          doNode (env, !succ, ifStk, stm::stms)                          doNode (!succ, ifStk, stm::stms)
389                        end                        end
390                    | k as IR.EXIT{kind, succ, ...} => (case (!succ, kind)                    | k as IR.EXIT{kind, succ, ...} => (case (!succ, kind)
391                         of (NONE, ExitKind.RETURN) => let                         of (NONE, ExitKind.RETURN) => let
# Line 389  Line 401 
401                          | (NONE, ExitKind.STABILIZE) => let                          | (NONE, ExitKind.STABILIZE) => let
402                              val stms = T.S_Stabilize :: stms                              val stms = T.S_Stabilize :: stms
403                              in                              in
404                                join (env, ifStk, stms, k)                                join (ifStk, stms, k)
405                              end                              end
406                          | (NONE, ExitKind.DIE) => join (env, ifStk, T.S_Die :: stms, k)                          | (NONE, ExitKind.DIE) => join (ifStk, T.S_Die :: stms, k)
407                          | (NONE, ExitKind.UNREACHABLE) => join (env, ifStk, stms, k)                          | (NONE, ExitKind.UNREACHABLE) => join (ifStk, stms, k)
408                          | (SOME nd, ExitKind.ACTIVE) => doNode (env, nd, ifStk, T.S_Active :: stms)                          | (SOME nd, ExitKind.ACTIVE) => doNode (nd, ifStk, T.S_Active :: stms)
409                          | (SOME nd, ExitKind.STABILIZE) => doNode (env, nd, ifStk, T.S_Stabilize :: stms)                          | (SOME nd, ExitKind.STABILIZE) => doNode (nd, ifStk, T.S_Stabilize :: stms)
410                          | (SOME nd, ExitKind.DIE) => doNode (env, nd, ifStk, T.S_Die :: stms)                          | (SOME nd, ExitKind.DIE) => doNode (nd, ifStk, T.S_Die :: stms)
411                          | (SOME nd, ExitKind.UNREACHABLE) => doNode (env, nd, ifStk, stms)                          | (SOME nd, ExitKind.UNREACHABLE) => doNode (nd, ifStk, stms)
412                          | _ => raise Fail("unexpected continuation edge from "^IR.Node.toString nd)                          | _ => raise Fail("unexpected continuation edge from "^IR.Node.toString nd)
413                        (* end case *))                        (* end case *))
414                  (* end case *))                  (* end case *))
415            in            in
416              ScopeVars.assignScopes (doNode (env, IR.CFG.entry cfg, [], []))              ScopeVars.assignScopes (doNode (IR.CFG.entry cfg, [], []))
417            end            end
418    
419      fun trCFG vecLayout (prefix, cfg) = trCFGWithEnv (Env.new vecLayout, prefix, cfg)      fun trCFG info (prefix, cfg) = trCFGWithEnv (Env.new info, prefix, cfg)
420    
421      fun trStrand layout strand = let      fun trStrand info strand = let
422            val trCFG = trCFG layout            val trCFG = trCFG info
423            val IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM} = strand            val IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM} = strand
424            val params' = List.map Util.newParamVar params            val params' = List.map Util.newParamVar params
425            val env = ListPair.foldlEq            val env = ListPair.foldlEq
426                  (fn (x, x', env) => rename(env, x, x')) (Env.new layout) (params, params')                  (fn (x, x', env) => rename(env, x, x')) (Env.new info) (params, params')
427            val state' = List.map getStateVar state            val state' = List.map getStateVar state
428            in            in
429              T.Strand{              T.Strand{
# Line 425  Line 437 
437                }                }
438            end            end
439    
440      fun translate (prog, vecLayout) = let      fun translate (prog, info) = let
441            val LowIR.Program{            val LowIR.Program{
442                    props, consts, inputs, constInit, globals, globalInit, strand, create, update                    props, consts, inputs, constInit, globals, globalInit, strand, create, update
443                  } = prog                  } = prog
# Line 437  Line 449 
449                  constInit = ??,                  constInit = ??,
450                  globals = ??,                  globals = ??,
451                  globalInit = ??,                  globalInit = ??,
452                  strand = trStrand vecLayout strand,                  strand = trStrand info strand,
453                  create = ??,                  create = ??,
454                  update = ??                  update = ??
455                }                }

Legend:
Removed from v.3850  
changed lines
  Added in v.3851

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