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 3887, Fri May 20 15:43:47 2016 UTC revision 3889, Sat May 21 14:32:02 2016 UTC
# Line 114  Line 114 
114        | mkIf (x, stms1, stms2) = T.S_IfThenElse(x, mkBlock stms1, mkBlock stms2)        | mkIf (x, stms1, stms2) = T.S_IfThenElse(x, mkBlock stms1, mkBlock stms2)
115      fun mkAssign (x, e) = T.S_Assign(false, x, e)      fun mkAssign (x, e) = T.S_Assign(false, x, e)
116      fun mkDefn (x, e) = T.S_Assign(true, x, e)      fun mkDefn (x, e) = T.S_Assign(true, x, e)
117        val zero = T.E_Lit(Literal.Real(RealLit.zero false))
118    
119      fun cvtScalarTy Ty.BoolTy = TTy.BoolTy      fun cvtScalarTy Ty.BoolTy = TTy.BoolTy
120        | cvtScalarTy Ty.IntTy = TTy.IntTy        | cvtScalarTy Ty.IntTy = TTy.IntTy
# Line 136  Line 137 
137              | Env.VEC(layout, es) => T.E_Pack(layout, es)              | Env.VEC(layout, es) => T.E_Pack(layout, es)
138            (* end case *))            (* end case *))
139    
140      fun scalarArg env x = (case useVar env x      fun simpleArg env x = (case useVar env x
141             of Env.TREE e => e             of Env.TREE e => e
142              | _ => raise Fail("expected scalar binding for " ^ IR.Var.toString x)              | _ => raise Fail("expected simple binding for " ^ IR.Var.toString x)
143            (* end case *))            (* end case *))
144    
145      fun vectorArg (env, x) = (case useVar env x      fun vectorArg (env, x) = (case useVar env x
# Line 178  Line 179 
179            end            end
180    
181      fun trOp (env, srcRator, args) = let      fun trOp (env, srcRator, args) = let
182            fun bindOp rator = Env.TREE(T.E_Op(rator, List.map (scalarArg env) args))            fun bindOp rator = Env.TREE(T.E_Op(rator, List.map (simpleArg env) args))
183            fun bindVOp rator = let            fun bindVOp rator = let
184                  val (layout, argss) = vectorArgs (env, args)                  val (layout, argss) = vectorArgs (env, args)
185                  fun mkArgs (_, [], []) = []                  fun mkArgs (_, [], []) = []
# Line 225  Line 226 
226                | Op.VSub _ => bindVOp TOp.VSub                | Op.VSub _ => bindVOp TOp.VSub
227                | Op.VScale _ => let                | Op.VScale _ => let
228                    val [s, v] = args                    val [s, v] = args
229                    val s = scalarArg env s                    val s = simpleArg env s
230                    val (layout, vs) = vectorArg (env, v)                    val (layout, vs) = vectorArg (env, v)
231                    val exps = mkArgs (fn (w, p, x) => (TOp.VScale(w, p), [s, x])) (layout, vs)                    val exps = mkArgs (fn (w, p, x) => (TOp.VScale(w, p), [s, x])) (layout, vs)
232                    in                    in
# Line 255  Line 256 
256                | Op.VClamp n => let                | Op.VClamp n => let
257                    val [v, lo, hi] = args                    val [v, lo, hi] = args
258                    val (layout, vs) = vectorArg (env, v)                    val (layout, vs) = vectorArg (env, v)
259                    val lo = scalarArg env lo                    val lo = simpleArg env lo
260                    val hi = scalarArg env hi                    val hi = simpleArg env hi
261                    val exps = mkArgs                    val exps = mkArgs
262                          (fn (w, p, x) => (TOp.VClamp(w, p), [x, lo, hi]))                          (fn (w, p, x) => (TOp.VClamp(w, p), [x, lo, hi]))
263                            (layout, vs)                            (layout, vs)
# Line 331  Line 332 
332          rhs is vector          rhs is vector
333  *)  *)
334      fun trAssign (env, lhs, rhs) = let      fun trAssign (env, lhs, rhs) = let
335          (* simple binding for lhs variable; we check to see if it is part of an merged          (* binding for the lhs variable, where the rhs is a simple expression.  We check to
336           * equivalence class, in which case we need to generate the assigment.           * see if it is part of an merged equivalence class, in which case we need to generate
337             * assigment(s)
338           *)           *)
339            fun bindSimple rhs = (case eqClassRepOf(env, lhs)            fun bindSimple rhs = (case eqClassRepOf(env, lhs)
340                   of NOEQ => (Env.bindSimple (env, lhs, Env.TREE rhs); [])                   of NOEQ => (Env.bindSimple (env, lhs, Env.TREE rhs); [])
341                    | VAR x' => [mkAssign(x', rhs)]                    | VAR x' => [mkAssign(x', rhs)]
342                    | VEC _ => raise Fail "unexpected VEC"                    | VEC xs' => (case V.ty lhs
343                           of Ty.TensorTy[d] => let
344                                val layout = Env.layoutVec env d
345                                in
346                                  List.mapi
347                                    (fn (i, x') => mkAssign(x', T.E_VLoad(layout, rhs, i)))
348                                      xs'
349                                end
350                            | _ => raise Fail "inconsistent"
351                          (* end case *))
352                  (* end case *))                  (* end case *))
353            fun assignOp (rator, args) = (case eqClassRepOf(env, lhs)            fun assignOp (rator, args) = (case eqClassRepOf(env, lhs)
354                   of NOEQ =>                   of NOEQ =>
355                        [mkDefn(newLocal (env, lhs), T.E_Op(rator, List.map (scalarArg env) args))]                        [mkDefn(newLocal (env, lhs), T.E_Op(rator, List.map (simpleArg env) args))]
356                    | VAR x' => [mkAssign(x', T.E_Op(rator, List.map (scalarArg env) args))]                    | VAR x' => [mkAssign(x', T.E_Op(rator, List.map (simpleArg env) args))]
357                    | VEC _ => raise Fail "unexpected VEC"                    | VEC _ => raise Fail ("unexpected VEC for lhs " ^ V.toString lhs)
358                  (* end case *))                  (* end case *))
359            in            in
360              case rhs              case rhs
# Line 351  Line 362 
362                | IR.STATE(NONE, fld) =>                | IR.STATE(NONE, fld) =>
363                    bindSimple (T.E_State(NONE, getStateVar fld))                    bindSimple (T.E_State(NONE, getStateVar fld))
364                | IR.STATE(SOME x, fld) =>                | IR.STATE(SOME x, fld) =>
365                    bindSimple (T.E_State(SOME(scalarArg env x), getStateVar fld))                    bindSimple (T.E_State(SOME(simpleArg env x), getStateVar fld))
366                | IR.VAR x => raise Fail "FIXME: VAR"                | IR.VAR x => raise Fail "FIXME: VAR"
367                | IR.LIT lit => bindSimple (T.E_Lit lit)                | IR.LIT lit => bindSimple (T.E_Lit lit)
368                | IR.OP(Op.EigenVecs2x2, args) => assignOp (TOp.EigenVecs2x2, args)                | IR.OP(Op.EigenVecs2x2, args) => assignOp (TOp.EigenVecs2x2, args)
# Line 378  Line 389 
389                    end                    end
390                | IR.OP(rator, args) => let                | IR.OP(rator, args) => let
391                    val rhs = trOp (env, rator, args)                    val rhs = trOp (env, rator, args)
392                    val needAssignment = (V.useCount lhs > 1) orelse (Env.isInlineOp env rator)                    val needAssignment = (V.useCount lhs > 1) orelse not(Env.isInlineOp env rator)
393                    in                    in
394                      case (rhs, eqClassRepOf(env, lhs), needAssignment)                      case (rhs, eqClassRepOf(env, lhs), needAssignment)
395                       of (_, NOEQ, false) => (Env.bindSimple (env, lhs, rhs); [])                       of (_, NOEQ, false) => (Env.bindSimple (env, lhs, rhs); [])
# Line 400  Line 411 
411                        (* take arguments from args to build a vector value of width w; pad as                        (* take arguments from args to build a vector value of width w; pad as
412                         * necessary.                         * necessary.
413                         *)                         *)
414                          fun take (0, args, es) = T.E_Vec(w, List.rev es) :: mkVecs (args, ws)                          fun take (0, args, es) = T.E_Vec(w, w, List.rev es) :: mkVecs (args, ws)
415                            | take (i, [], es) = if #padded layout andalso null ws                            | take (i, [], es) = if #padded layout andalso null ws
416                                then [T.E_Vec(w, List.rev es)]                                then [T.E_Vec(w-i, w, List.rev es)]
417                                else raise Fail "too few arguments for CONS"                                else raise Fail "too few arguments for CONS"
418                            | take (i, arg::args, es) = take (i-1, args, scalarArg env arg :: es)                            | take (i, arg::args, es) = take (i-1, args, simpleArg env arg :: es)
419                          in                          in
420                            take (w, args, [])                            take (w, args, [])
421                          end                          end

Legend:
Removed from v.3887  
changed lines
  Added in v.3889

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