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 3853, Fri May 13 18:14:10 2016 UTC revision 3856, Sat May 14 12:49:20 2016 UTC
# Line 71  Line 71 
71      local      local
72        val {peekFn : IR.var -> eq_var_rep option, setFn, ...} =        val {peekFn : IR.var -> eq_var_rep option, setFn, ...} =
73              V.newProp (fn x => raise Fail(V.toString x))              V.newProp (fn x => raise Fail(V.toString x))
74      in  
75      fun eqClassRepOf (env, x) = (case UnifyVars.eqClassOf x        fun repOf (env, x, x') = (case peekFn x'
            of SOME x' => (case peekFn x'  
76                   of SOME b => b                   of SOME b => b
77                    | NONE => let                    | NONE => let
78                        val rep = (case V.ty x'                    val rep = (case V.ty x
79                               of Ty.TensorTy[d] => VEC(Util.newVectorVars(Env.layoutVec env d))                               of Ty.TensorTy[d] => VEC(Util.newVectorVars(Env.layoutVec env d))
80                                | ty => VAR(Util.newLocalVar x)                                | ty => VAR(Util.newLocalVar x)
81                              (* end case *))                              (* end case *))
# Line 85  Line 84 
84                          rep                          rep
85                        end                        end
86                  (* end case *))                  (* end case *))
87        in
88    
89        fun eqClassRepOf (env, x) = (case UnifyVars.eqClassOf x
90               of SOME x' => repOf (env, x, x')
91              | NONE => NOEQ              | NONE => NOEQ
92            (* end case *))            (* end case *))
93    
94        fun useVar env = let
95              val useV = Env.useVar env
96              in
97                fn x => (case UnifyVars.eqClassOf x
98                      of SOME x' => (case repOf (env, x, x')
99                           of VAR x => Env.TREE(T.E_Var x)
100                            | VEC xs => let
101                                val Ty.TensorTy[d] = V.ty x
102                                in
103                                  Env.VEC(Env.layoutVec env d, List.map T.E_Var xs)
104                                end
105                            | NOEQ => raise Fail "impossible"
106                          (* end case *))
107                       | NONE => useV x
108                     (* end case *))
109              end
110      end      end
111    
112      fun mkBlock stms = T.Block{locals = ref [], body = stms}      fun mkBlock stms = T.Block{locals = ref [], body = stms}
# Line 101  Line 121 
121    (* get a variable's binding as a single argument expression.  This means that    (* get a variable's binding as a single argument expression.  This means that
122     * if x is bound to a vector of expressions, then we need to pack it.     * if x is bound to a vector of expressions, then we need to pack it.
123     *)     *)
124      fun singleArg env x = (case Env.useVar env x      fun singleArg env x = (case useVar env x
125             of Env.TREE e => e             of Env.TREE e => e
126              | Env.VEC(layout, es) => T.E_Pack(layout, es)              | Env.VEC(layout, es) => T.E_Pack(layout, es)
127            (* end case *))            (* end case *))
128    
129      fun scalarArg env x = (case Env.useVar env x      fun scalarArg env x = (case useVar env x
130             of Env.TREE e => e             of Env.TREE e => e
131              | _ => raise Fail("expected scalar binding for " ^ IR.Var.toString x)              | _ => raise Fail("expected scalar binding for " ^ IR.Var.toString x)
132            (* end case *))            (* end case *))
133    
134      fun vectorArg (env, x) = (case Env.useVar env x      fun vectorArg (env, x) = (case useVar env x
135             of Env.TREE e => (case IR.Var.ty x             of Env.TREE e => (case V.ty x
136                   of Ty.TensorTy[d] => let                   of Ty.TensorTy[d] => let
137                        val layout = Env.layoutVec env d                        val layout = Env.layoutVec env d
138  (* QUESTION: can "e" be a complicated expression or are we guaranteed that it will just  (* QUESTION: can "e" be a complicated expression or are we guaranteed that it will just
# Line 124  Line 144 
144                        in                        in
145                          (layout, es)                          (layout, es)
146                        end                        end
147                    | ty => raise Fail("expected TensorTy[_], but found " ^ Ty.toString ty)                    | ty => raise Fail(concat[
148                            "expected ", V.toString x, " : TensorTy[_], but found " ^ Ty.toString ty
149                          ])
150                  (* end case *))                  (* end case *))
151              | Env.VEC(layout, es) => (layout, es)              | Env.VEC(layout, es) => (layout, es)
152            (* end case *))            (* end case *))
# Line 184  Line 206 
206                | Op.RLerp => bindOp TOp.RLerp                | Op.RLerp => bindOp TOp.RLerp
207                | Op.VAdd _ => bindVOp TOp.VAdd                | Op.VAdd _ => bindVOp TOp.VAdd
208                | Op.VSub _ => bindVOp TOp.VSub                | Op.VSub _ => bindVOp TOp.VSub
209                | Op.VScale _ => bindVOp TOp.VScale                | Op.VScale _ => let
210                      val [s, v] = args
211                      val s = scalarArg env s
212                      val (layout, vs) = vectorArg (env, v)
213                      val exps = ListPair.map
214                          (fn (w, x) => T.E_Op(TOp.VScale w, [s, x]))
215                            (#pieces layout, vs)
216                      in
217                        Env.VEC(layout, exps)
218                      end
219                | Op.VMul _ => bindVOp TOp.VMul                | Op.VMul _ => bindVOp TOp.VMul
220                | Op.VNeg _ => bindVOp TOp.VNeg                | Op.VNeg _ => bindVOp TOp.VNeg
221                | Op.VSum _ => raise Fail "FIXME: VSum"                | Op.VSum _ => let
222                      val [v] = args
223                      val ({pieces, ...}, es) = vectorArg (env, v)
224                      val e::es = ListPair.map (fn (w, v) => T.E_Op(TOp.VSum w, [v])) (pieces, es)
225                      in
226                        Env.TREE(List.foldr (fn (e, es) => T.E_Op(TOp.RAdd, [e, es])) e es)
227                      end
228                | Op.VIndex(_, i) => let                | Op.VIndex(_, i) => let
229                      val [v] = args
230  (* FIXME: more efficient to lookup the variable and avoid expanding TREE args *)  (* FIXME: more efficient to lookup the variable and avoid expanding TREE args *)
231                    val ({pieces, ...}, es) = vectorArg (env, hd args)                    val ({pieces, ...}, es) = vectorArg (env, v)
232                    fun select (i, w::ws, e::es) =                    fun select (i, w::ws, e::es) =
233                          if (i < w)                          if (i < w)
234  (* FIXME: what if lhs is used more than once? *)  (* FIXME: what if lhs is used more than once? *)
# Line 200  Line 238 
238                    in                    in
239                      select (i, pieces, es)                      select (i, pieces, es)
240                    end                    end
241                | Op.VClamp n => bindVOp TOp.VClamp                | Op.VClamp n => let
242                      val [v, lo, hi] = args
243                      val (layout, vs) = vectorArg (env, v)
244                      val lo = scalarArg env lo
245                      val hi = scalarArg env hi
246                      val exps = ListPair.map
247                          (fn (w, x) => T.E_Op(TOp.VClamp w, [x, lo, hi]))
248                            (#pieces layout, vs)
249                      in
250                        Env.VEC(layout, exps)
251                      end
252                | Op.VMapClamp n => bindVOp TOp.VMapClamp                | Op.VMapClamp n => bindVOp TOp.VMapClamp
253                | Op.VLerp n => bindVOp TOp.VLerp                | Op.VLerp n => bindVOp TOp.VLerp
254                | Op.TensorIndex(ty, idxs) => bindOp(TOp.TensorIndex(Util.trType ty, idxs))                | Op.TensorIndex(ty, idxs) => bindOp(TOp.TensorIndex(Util.trType ty, idxs))
# Line 287  Line 335 
335                    bindSimple (T.E_State(NONE, getStateVar fld))                    bindSimple (T.E_State(NONE, getStateVar fld))
336                | IR.STATE(SOME x, fld) =>                | IR.STATE(SOME x, fld) =>
337                    bindSimple (T.E_State(SOME(scalarArg env x), getStateVar fld))                    bindSimple (T.E_State(SOME(scalarArg env x), getStateVar fld))
338                | IR.VAR x => (case Env.useVar env x                | IR.VAR x => raise Fail "FIXME: VAR"
                    of Env.TREE e => ??  
                     | Env.VEC(layout, es) => ??  
                   (* end case *))  
339                | IR.LIT lit => bindSimple (T.E_Lit lit)                | IR.LIT lit => bindSimple (T.E_Lit lit)
340                | IR.OP(Op.EigenVecs2x2, args) => assignOp (TOp.EigenVecs2x2, args)                | IR.OP(Op.EigenVecs2x2, args) => assignOp (TOp.EigenVecs2x2, args)
341                | IR.OP(Op.EigenVecs3x3, args) => assignOp (TOp.EigenVecs3x3, args)                | IR.OP(Op.EigenVecs3x3, args) => assignOp (TOp.EigenVecs3x3, args)
# Line 298  Line 343 
343                | IR.OP(Op.EigenVals3x3, args) => assignOp (TOp.EigenVals3x3, args)                | IR.OP(Op.EigenVals3x3, args) => assignOp (TOp.EigenVals3x3, args)
344                | IR.OP(rator, args) => let                | IR.OP(rator, args) => let
345                    val rhs = trOp (env, rator, args)                    val rhs = trOp (env, rator, args)
346                      val needAssignment = (V.useCount lhs > 1) orelse (Env.isInlineOp env rator)
347                    in                    in
348                      if Env.isInlineOp env rator                      case (rhs, eqClassRepOf(env, lhs), needAssignment)
                       then (case (rhs, eqClassRepOf(env, lhs), V.useCount lhs > 1)  
349                            of (_, NOEQ, false) => (Env.bindSimple (env, lhs, rhs); [])                            of (_, NOEQ, false) => (Env.bindSimple (env, lhs, rhs); [])
350                             | (Env.TREE e, NOEQ, true) => let                             | (Env.TREE e, NOEQ, true) => let
351                                  val t = Util.newLocalVar lhs                                  val t = Util.newLocalVar lhs
# Line 315  Line 360 
360                                    Env.bindSimple (env, lhs, Env.VEC(layout, List.map T.E_Var vs));                                    Env.bindSimple (env, lhs, Env.VEC(layout, List.map T.E_Var vs));
361                                    ListPair.mapEq T.S_Assign (vs, es)                                    ListPair.mapEq T.S_Assign (vs, es)
362                                  end                                  end
363                             | (Env.VEC(layout, es), VEC xs, _) => ??                        | (Env.VEC(layout, es), VEC xs, _) => ListPair.mapEq T.S_Assign (xs, es)
364                             | _ => raise Fail "inconsistent"                             | _ => raise Fail "inconsistent"
365                           (* end case *))                      (* end case *)
                       else ??  
366                    end                    end
367                | IR.CONS(args, Ty.TensorTy[d]) => let                | IR.CONS(args, Ty.TensorTy[d]) => let
368                    val {padded, pieces, ...} = Env.layoutVec env d                    val layout = Env.layoutVec env d
369                      fun mkVecs (args, w::ws) = let
370    (* FIXME: what about padding? *)
371                            fun take (0, args, es) = T.E_Vec(List.rev es) :: mkVecs (args, ws)
372                              | take (i, [], es) = if #padded layout andalso null ws
373                                  then let
374                                    val zero = T.E_Lit(Literal.Real(RealLit.zero false))
375                                    in
376                                      [T.E_Vec(List.rev(List.tabulate(i, fn _ => zero)))]
377                                    end
378                                  else raise Fail "too few arguments for CONS"
379                              | take (i, arg::args, es) = take (i-1, args, scalarArg env arg :: es)
380                            in
381                              take (w, args, [])
382                            end
383                        | mkVecs ([], []) = []
384                        | mkVecs (_, []) = raise Fail "too many arguments for CONS"
385                      val es = mkVecs (args, #pieces layout)
386                      in
387                        case (eqClassRepOf(env, lhs), V.useCount lhs > 1)
388                         of (NOEQ, false) => (Env.bindVar(env, lhs, Env.VEC(layout, es)); [])
389                          | (NOEQ, true) => let
390                              val vs = Util.newVectorVars layout
391                    in                    in
392                      ??                              Env.bindSimple (env, lhs, Env.VEC(layout, List.map T.E_Var vs));
393                                ListPair.mapEq T.S_Assign (vs, es)
394                              end
395                          | (VEC xs, _) => ListPair.mapEq T.S_Assign (xs, es)
396                          | _ => raise Fail "inconsistent"
397                        (* end case *)
398                    end                    end
399                | IR.CONS(args, Ty.TensorTy shape) => ??                | IR.CONS(args, Ty.TensorTy shape) => raise Fail "FIXME: CONS"
400                | IR.SEQ(args, ty) => ??                | IR.SEQ(args, ty) => raise Fail "FIXME: SEQ"
401                | rhs => raise Fail(concat["unexpected ", IR.RHS.toString rhs, " in LowIR code"])                | rhs => raise Fail(concat["unexpected ", IR.RHS.toString rhs, " in LowIR code"])
402              (* end case *)              (* end case *)
403            end            end
404    handle ex => (
405    print(concat["trAssign: ", V.toString lhs, " = ", IR.RHS.toString rhs, "\n"]);
406    raise ex)
407    
408    (* In order to reconstruct the block-structure from the CFG, we keep a stack of open ifs.    (* In order to reconstruct the block-structure from the CFG, we keep a stack of open ifs.
409     * the items on this stack distinguish between when we are processing the then and else     * the items on this stack distinguish between when we are processing the then and else
# Line 347  Line 421 
421        | 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
422    
423      fun trCFGWithEnv (env, cfg) = let      fun trCFGWithEnv (env, cfg) = let
424            fun useScalar x = (case Env.useVar env x            fun useScalar x = (case useVar env x
425                   of Env.TREE e => e                   of Env.TREE e => e
426                    | _ => raise Fail("expected scalar binding for " ^ V.toString x)                    | _ => raise Fail("expected scalar binding for " ^ V.toString x)
427                  (* end case *))                  (* end case *))
# Line 402  Line 476 
476                        end                        end
477                    | IR.FOREACH{var, src, bodyEntry, succ, ...} => let                    | IR.FOREACH{var, src, bodyEntry, succ, ...} => let
478                        val src = useScalar (!src)                        val src = useScalar (!src)
479                        val var = Util.newIterVar var                        val var' = Util.newIterVar var
480                        val stms = Env.flushPending (env, stms)                        val stms = Env.flushPending (env, stms)
481                          val _ = Env.bindSimple (env, var, Env.TREE(T.E_Var var'))
482                        val body = doNode (!bodyEntry, [], [])                        val body = doNode (!bodyEntry, [], [])
483                        val stm = T.S_Foreach(var, src, body)                        val stm = T.S_Foreach(var', src, body)
484                        in                        in
485                          doNode (!succ, ifStk, stm::stms)                          doNode (!succ, ifStk, stm::stms)
486                        end                        end

Legend:
Removed from v.3853  
changed lines
  Added in v.3856

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