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 3843, Tue May 10 15:10:58 2016 UTC revision 3849, Thu May 12 17:36:28 2016 UTC
# Line 64  Line 64 
64      val {getFn = getStateVar, ...} = SV.newProp mkStateVar      val {getFn = getStateVar, ...} = SV.newProp mkStateVar
65      end      end
66    
67      fun mkBlock stms = T.Block{locals=[], body=stms}      fun mkBlock stms = T.Block{locals = ref [], body = stms}
68      fun mkIf (x, stms, []) = T.S_IfThen(x, mkBlock stms)      fun mkIf (x, stms, []) = T.S_IfThen(x, mkBlock stms)
69        | mkIf (x, stms1, stms2) = T.S_IfThenElse(x, mkBlock stms1, mkBlock stms2)        | mkIf (x, stms1, stms2) = T.S_IfThenElse(x, mkBlock stms1, mkBlock stms2)
70    
# Line 156  Line 156 
156                | Op.VMul _ => bindVOp TOp.VMul                | Op.VMul _ => bindVOp TOp.VMul
157                | Op.VNeg _ => bindVOp TOp.VNeg                | Op.VNeg _ => bindVOp TOp.VNeg
158                | Op.VSum _ => ??                | Op.VSum _ => ??
159                | Op.VIndex(d, i) => ??                | Op.VIndex(_, i) => let
160    (* FIXME: more efficient to lookup the variable and avoid expanding TREE args *)
161                      val ({pieces, ...}, es) = vectorArg (env, hd args)
162                      fun select (i, w::ws, e::es) =
163                            if (i < w)
164                              then Env.TREE(T.E_Op(TOp.VIndex(w, i), [e]))
165                              else select (i-w, ws, es)
166                        | select _ = raise Fail("bogus " ^ Op.toString srcRator)
167                      in
168                        select (i, pieces, es)
169                      end
170                | Op.VClamp n => bindVOp TOp.VClamp                | Op.VClamp n => bindVOp TOp.VClamp
171                | Op.VMapClamp n => bindVOp TOp.VMapClamp                | Op.VMapClamp n => bindVOp TOp.VMapClamp
172                | Op.VLerp n => bindVOp TOp.VLerp                | Op.VLerp n => bindVOp TOp.VLerp
# Line 195  Line 205 
205                | Op.IntToReal => bindOp TOp.IntToReal                | Op.IntToReal => bindOp TOp.IntToReal
206                | Op.RealToInt 1 => ??                | Op.RealToInt 1 => ??
207                | Op.RealToInt d => ??                | Op.RealToInt d => ??
208    (* FIXME
209                | Op.R_All ty => ??                | Op.R_All ty => ??
210                | Op.R_Exists ty => ??                | Op.R_Exists ty => ??
211                | Op.R_Max ty => ??                | Op.R_Max ty => ??
# Line 203  Line 214 
214                | Op.R_Product ty => ??                | Op.R_Product ty => ??
215                | Op.R_Mean ty => ??                | Op.R_Mean ty => ??
216                | Op.R_Variance ty => ??                | Op.R_Variance ty => ??
217    *)
218                | Op.Transform info => ??                | Op.Transform info => ??
219                | Op.Translate info => ??                | Op.Translate info => ??
220                | Op.ControlIndex(info, ctl, d) => ??                | Op.ControlIndex(info, ctl, d) => ??
# Line 212  Line 224 
224                | Op.LoadSeq(ty, file) => ??                | Op.LoadSeq(ty, file) => ??
225                | Op.LoadImage(ty, file) => ??                | Op.LoadImage(ty, file) => ??
226                | Op.MathFn f => bindOp (TOp.MathFn f)                | Op.MathFn f => bindOp (TOp.MathFn f)
227                | rator => raise Fail("bogus operator " ^ Op.toString rator)                | rator => raise Fail("bogus operator " ^ Op.toString srcRator)
228              (* end case *)              (* end case *)
229            end            end
230    
# Line 226  Line 238 
238                  (* end case *))                  (* end case *))
239            in            in
240              case rhs              case rhs
241               of IR.GLOBAL x => bindSimple (T.E_Global(getGlobalVar x))               of IR.GLOBAL x => bindSimple (T.E_Global(mkGlobalVar x))
242                | IR.STATE x => bindSimple (T.E_State(getStateVar x))                | IR.STATE(NONE, fld) => bindSimple (T.E_State(NONE, getStateVar fld))
243                  | IR.STATE(SOME x, fld) => ??
244                | IR.VAR x => (case Env.useVar env x                | IR.VAR x => (case Env.useVar env x
245                     of Env.TREE e => ??                     of Env.TREE e => ??
246                      | Env.VEC(layout, es) => ??                      | Env.VEC(layout, es) => ??
247                    (* end case *))                    (* end case *))
248                | IR.LIT lit => bindSimple (env, lhs, T.E_Lit lit)                | IR.LIT lit => bindSimple (env, lhs, T.E_Lit lit)
249                | IR.OP(rator, args) => ??                | IR.OP(rator, args) => trOp (env, lhs, rator, args)
250                | IR.CONS(args, ty) => ??                | IR.CONS(args, ty) => ??
251                | IR.SEQ(args, ty) => ??                | IR.SEQ(args, ty) => ??
252                | IR.EINAPP _ => raise Fail "unexpected EINAPP in LowIR code"                | IR.EINAPP _ => raise Fail "unexpected EINAPP in LowIR code"
# Line 267  Line 280 
280           * 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).
281           *)           *)
282            fun join (env, [], _, IR.JOIN _) = raise Fail "JOIN with no open if"            fun join (env, [], _, IR.JOIN _) = raise Fail "JOIN with no open if"
283              | join (env, [], stms, _) = Env.endScope (env, prefix @ List.rev stms)              | join (env, [], stms, _) = mkBlock (prefix @ List.rev stms)
284              | join (env, THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let              | join (env, THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let
285                  val (env, thenBlk) = Env.flushPending (env, thenBlk)                  val (env, thenBlk) = Env.flushPending (env, thenBlk)
286                  in                  in
# Line 277  Line 290 
290                  val (env, elseBlk) = Env.flushPending (env, elseBlk)                  val (env, elseBlk) = Env.flushPending (env, elseBlk)
291                  in                  in
292                    case (k1, k2)                    case (k1, k2)
293                     of (IR.JOIN{phis, succ, ...}, IR.JOIN _) => let                     of (IR.JOIN{succ, ...}, IR.JOIN _) => let
                         val (env, [thenBlk, elseBlk]) =  
                               List.foldl doPhi (env, [thenBlk, elseBlk]) (!phis)  
294                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)
295                          in                          in
296                            doNode (env, !succ, stk, stm::stms)                            doNode (env, !succ, stk, stm::stms)
297                          end                          end
298                      | (IR.JOIN{phis, succ, ...}, _) => let                      | (IR.JOIN{succ, ...}, _) => let
                         val (env, [thenBlk]) = List.foldl doPhi (env, [thenBlk]) (!phis)  
299                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)
300                          in                          in
301                            doNode (env, !succ, stk, stm::stms)                            doNode (env, !succ, stk, stm::stms)
302                          end                          end
303                      | (_, IR.JOIN{phis, succ, ...}) => let                      | (_, IR.JOIN{succ, ...}) => let
                         val (env, [elseBlk]) = List.foldl doPhi (env, [elseBlk]) (!phis)  
304                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)
305                          in                          in
306                            doNode (env, !succ, stk, stm::stms)                            doNode (env, !succ, stk, stm::stms)
# Line 299  Line 308 
308                      | (_, _) => let                      | (_, _) => let
309                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)
310                          in                          in
311                            Env.endScope (env, prefix @ List.rev(stm::stms))                            mkBlock (prefix @ List.rev(stm::stms))
312                          end                          end
313                    (* end case *)                    (* end case *)
314                  end                  end
# Line 315  Line 324 
324                        end                        end
325                    | IR.FOREACH{var, src, bodyEntry, succ, ...} => let                    | IR.FOREACH{var, src, bodyEntry, succ, ...} => let
326                        val src = useScalar (!src)                        val src = useScalar (!src)
327                        val var = ??                        val var = Util.newIterVar var
328                        val (env, stms) = Env.flushPending (env, stms)                        val (env, stms) = Env.flushPending (env, stms)
329                        val body = doNode (env, !bodyEntry, [], [])                        val body = doNode (env, !bodyEntry, [], [])
330                        val stm = T.S_Foreach(var, src, body)                        val stm = T.S_Foreach(var, src, body)
331                        in                        in
332                          doNode (env, !succ, ifStk, stm::stms)                          doNode (env, !succ, ifStk, stm::stms)
333                        end                        end
334                    | IR.NEXT _ => Env.endScope (env, List.rev stms)                    | IR.NEXT _ => mkBlock (List.rev stms)
335                    | IR.COM {text, succ, ...} =>                    | IR.COM {text, succ, ...} =>
336                        doNode (env, !succ, ifStk, T.S_Comment text :: stms)                        doNode (env, !succ, ifStk, T.S_Comment text :: stms)
337                    | IR.ASSIGN{stm=(lhs, rhs), succ, ...} => let                    | IR.ASSIGN{stm=(lhs, rhs), succ, ...} => let
338                        val (env, stms') = doAssign (env, lhs, rhs)                        val (env, stms') = trAssign (env, lhs, rhs)
339                        in                        in
340                          doNode (env, !succ, ifStk, stms' @ stms)                          doNode (env, !succ, ifStk, stms' @ stms)
341                        end                        end
342                    | IR.MASSIGN{stm=(ys, rator, xs), succ, ...} => let                    | IR.MASSIGN{stm=(ys, rator, xs), succ, ...} => let
                       fun doit () = let  
343                              fun doLHSVar (y, (env, ys)) = let                              fun doLHSVar (y, (env, ys)) = let
344                                    val t = newLocal y                              val t = Util.newLocalVar y
345                                    in                                    in
346                                      (rename (addLocal(env, t), y, t), t::ys)                                (rename (Env.addLocal(env, t), y, t), t::ys)
347                                    end                                    end
348                              val (env, ys) = List.foldr doLHSVar (env, []) ys                              val (env, ys) = List.foldr doLHSVar (env, []) ys
349  (* FIXME: need to translate the operator *)                        val rator = (case rator
350                              val exp = T.E_Op(rator, List.map (useVar env) xs)                               of Op.Print tys => TOp.Print(List.map Util.trType tys)
351                              val stm = T.S_Assign(ys, exp)                                | _ => raise Fail(concat[
352                                        "unexepected operator ", Op.toString rator, " for MASSIGN"
353                                      ])
354                                (* end case *))
355                          val stm = T.S_MAssign(ys, T.E_Op(rator, List.map (Env.useVar env) xs))
356                              in                              in
357                                doNode (env, !succ, ifStk, stm :: stms)                                doNode (env, !succ, ifStk, stm :: stms)
358                              end                              end
                       in  
                         case rator  
                          of Op.Print _ => if Target.supportsPrinting()  
                               then doit ()  
                               else doNode (env, !succ, ifStk, stms)  
                           | _ => doit()  
                         (* end case *)  
                       end  
359                    | IR.GASSIGN{lhs, rhs, succ, ...} => let                    | IR.GASSIGN{lhs, rhs, succ, ...} => let
360                        val stm = (case useAsInput(env, rhs)                        val stm = (case useAsInput(env, rhs)
361                               of NONE => T.S_GAssign(getGlobalVar lhs, useVar env rhs)                               of NONE => T.S_GAssign(mkGlobalVar lhs, Env.useVar env rhs)
362                                | SOME mkStm => mkStm(getGlobalVar lhs)                                | SOME mkStm => mkStm(mkGlobalVar lhs)
363                              (* end case *))                              (* end case *))
364                        in                        in
365                          doNode (env, !succ, ifStk, stm::stms)                          doNode (env, !succ, ifStk, stm::stms)
366                        end                        end
367                    | IR.NEW{strand, args, succ, ...} => raise Fail "NEW unimplemented"                    | IR.NEW{strand, args, succ, ...} => raise Fail "NEW unimplemented"
368                    | IR.SAVE{lhs, rhs, succ, ...} => let                    | IR.SAVE{lhs, rhs, succ, ...} => let
369                        val stm = T.S_Save([getStateVar lhs], useVar env rhs)                        val stm = T.S_Save([getStateVar lhs], Env.useVar env rhs)
370                        in                        in
371                          doNode (env, !succ, ifStk, stm::stms)                          doNode (env, !succ, ifStk, stm::stms)
372                        end                        end
# Line 370  Line 374 
374                         of (NONE, ExitKind.RETURN) => let                         of (NONE, ExitKind.RETURN) => let
375                              val suffix = [T.S_Exit]                              val suffix = [T.S_Exit]
376                              in                              in
377                                Env.endScope (env, prefix @ List.revAppend(stms, suffix))                                mkBlock (prefix @ List.revAppend(stms, suffix))
378                              end                              end
379                          | (NONE, ExitKind.ACTIVE) => let                          | (NONE, ExitKind.ACTIVE) => let
380                              val suffix = [T.S_Active]                              val suffix = [T.S_Active]
381                              in                              in
382                                Env.endScope  (env, prefix @ List.revAppend(stms, suffix))                                mkBlock (prefix @ List.revAppend(stms, suffix))
383                              end                              end
384                          | (NONE, ExitKind.STABILIZE) => let                          | (NONE, ExitKind.STABILIZE) => let
385                              val stms = T.S_Stabilize :: stms                              val stms = T.S_Stabilize :: stms
# Line 392  Line 396 
396                        (* end case *))                        (* end case *))
397                  (* end case *))                  (* end case *))
398            in            in
399              doNode (env, CFG.entry cfg, [], [])              ScopeVars.assignScopes (doNode (env, IR.CFG.entry cfg, [], []))
400            end            end
401    
402      fun trCFG vecLayout (prefix, cfg) = trCFGWithEnv (Env.new vecLayout, prefix, cfg)      fun trCFG vecLayout (prefix, cfg) = trCFGWithEnv (Env.new vecLayout, prefix, cfg)
403    
404      fun trStrand strand = let      fun trStrand layout strand = let
405              val trCFG = trCFG layout
406            val IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM} = strand            val IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM} = strand
407            val params' = List.map newParam params            val params' = List.map Util.newParamVar params
408            val env = ListPair.foldlEq            val env = ListPair.foldlEq
409                  (fn (x, x', env) => rename(env, x, x')) ?? (params, params')                  (fn (x, x', env) => rename(env, x, x')) (Env.new layout) (params, params')
410            val state' = List.map getStateVar state            val state' = List.map getStateVar state
411            in            in
412              T.Strand{              T.Strand{
413                  name = name,                  name = name,
414                  params = params',                  params = params',
415                  state = state',                  state = state',
416                  stateInit = trCFGWithEnv (env, stateInit),                  stateInit = trCFGWithEnv (env, [], stateInit),
417                  initM = Option.map (fn cfg => trCFG ([], cfg)) initM,                  initM = Option.map (fn cfg => trCFG ([], cfg)) initM,
418                  updateM = trCFG ([], updateM),                  updateM = trCFG ([], updateM),
419                  stabilizeM = Option.map (fn cfg => trCFG ([], cfg)) stabilizeM                  stabilizeM = Option.map (fn cfg => trCFG ([], cfg)) stabilizeM
# Line 427  Line 432 
432                  constInit = ??,                  constInit = ??,
433                  globals = ??,                  globals = ??,
434                  globalInit = ??,                  globalInit = ??,
435                  strand = ??,                  strand = trStrand vecLayout strand,
436                  create = ??,                  create = ??,
437                  update = ??                  update = ??
438                }                }

Legend:
Removed from v.3843  
changed lines
  Added in v.3849

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