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 4077, Tue Jun 28 14:56:14 2016 UTC revision 4091, Wed Jun 29 02:44:36 2016 UTC
# Line 78  Line 78 
78                | NONE => let                | NONE => let
79                    val rep = (case V.ty x                    val rep = (case V.ty x
80                           of Ty.TensorTy[d] => VEC(U.newVectorVars(Env.layoutVec env d))                           of Ty.TensorTy[d] => VEC(U.newVectorVars(Env.layoutVec env d))
81    (* FIXME: we should analyse the assignments to x and determine if the type should be TensorTy
82     * or TensorRefTy.
83     *)
84                              | Ty.TensorTy(_::_) => VAR(U.newMemVar x)
85                            | ty => VAR(U.newLocalVar x)                            | ty => VAR(U.newLocalVar x)
86                          (* end case *))                          (* end case *))
87                    in                    in
# Line 142  Line 146 
146              x'              x'
147            end            end
148    
149      (* define a new local variable and bind x to it in the environment. *)
150        fun newMemLocal (env, x) = let
151              val x' = U.newMemVar x
152              in
153                Env.bindSimple (env, x, T.E_Var x');
154                x'
155              end
156    
157    (* 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
158     * if x is bound to a vector of expressions, then we need to pack it.  Since     * if x is bound to a vector of expressions, then we need to pack it.  Since
159     * Pack gets translated to an array, we need to create a new temp.     * Pack gets translated to an array, we need to create a new temp.
# Line 472  Line 484 
484          rhs is simple          rhs is simple
485          rhs is vector          rhs is vector
486  *)  *)
487      fun trAssign (env, lhs, rhs) = let      fun trAssign (env, lhs, rhs : IR.rhs) = let
488            fun getLHS () = (case UnifyVars.eqClassOf lhs of SOME x => x | _ => lhs)            fun getLHS () = (case UnifyVars.eqClassOf lhs of SOME x => x | _ => lhs)
           fun bindRHS rhs = Env.bindVar (env, getLHS(), Env.RHS(U.trTempType(V.ty lhs), rhs))  
489          (* binding for the lhs variable, where the rhs is a simple expression.  We check to          (* binding for the lhs variable, where the rhs is a simple expression.  We check to
490           * see if it is part of an merged equivalence class, in which case we need to generate           * see if it is part of an merged equivalence class, in which case we need to generate
491           * assigment(s)           * assigment(s)
# Line 499  Line 510 
510                  in                  in
511                    case eqClassRepOf(env, lhs)                    case eqClassRepOf(env, lhs)
512                     of NOEQ => (                     of NOEQ => (
513                          bindRHS (T.E_Op(rator, args));                          Env.bindVar (env, lhs, Env.RHS(U.trTempType(V.ty lhs), T.E_Op(rator, args)));
514                          stms)                          stms)
515                      | VAR x' => stms @ [mkAssign' (x', T.E_Op(rator, args))]                      | VAR x' => stms @ [mkAssign' (x', T.E_Op(rator, args))]
516                      | VEC _ => raise Fail ("unexpected VEC for lhs " ^ V.toString lhs)                      | VEC _ => raise Fail ("unexpected VEC for lhs " ^ V.toString lhs)
517                    (* end case *)                    (* end case *)
518                  end                  end
519            (* bind the lhs to a tensor cons expression (including Op.Zero) *)
520              fun bindCons (args, Ty.TensorTy[d], stms) = let
521                    val layout = Env.layoutVec env d
522                    fun mkVecs (args, w::ws) = let
523                        (* take arguments from args to build a vector value of width w; pad as
524                         * necessary.
525                         *)
526                          fun take (0, args, es) = T.E_Vec(w, w, List.rev es) :: mkVecs (args, ws)
527                            | take (i, [], es) = if #padded layout andalso null ws
528                                then [T.E_Vec(w-i, w, List.rev es)]
529                                else raise Fail "too few arguments for CONS"
530                            | take (i, arg::args, es) = take (i-1, args, arg :: es)
531                          in
532                            take (w, args, [])
533                          end
534                      | mkVecs ([], []) = []
535                      | mkVecs (_, []) = raise Fail "too many arguments for CONS"
536                    val es = mkVecs (args, #pieces layout)
537                    in
538                      case (eqClassRepOf(env, lhs), V.useCount lhs > 1)
539                       of (NOEQ, false) => (Env.bindVar(env, lhs, Env.VEC(layout, es)); stms)
540                        | (NOEQ, true) => let
541                            val vs = U.newVectorVars layout
542                            in
543                              Env.bindVar (env, lhs, Env.VEC(layout, List.map T.E_Var vs));
544                              ListPair.foldl (fn (v, e, stms) => mkDefn(v, e)::stms) stms (vs, es)
545                            end
546                        | (VEC xs, _) =>
547                            ListPair.foldl (fn (x, e, stms) => mkAssign(x, e)::stms) stms (xs, es)
548                        | _ => raise Fail "inconsistent"
549                      (* end case *)
550                    end
551                | bindCons (args, ty as Ty.TensorTy _, stms) = let
552                    val ty = U.trType ty
553                    val cons = T.E_Cons(args, ty)
554                    in
555                      case eqClassRepOf(env, lhs)
556                       of NOEQ => mkDefn (newMemLocal (env, lhs), cons) :: stms
557                        | VAR x => mkAssign (x, cons) :: stms
558                        | VEC xs => raise Fail "inconsistent"
559                      (* end case *)
560                    end
561            in            in
562              case rhs              case rhs
563               of IR.GLOBAL x => bindSimple (T.E_Global(mkGlobalVar x))               of IR.GLOBAL x => bindSimple (T.E_Global(mkGlobalVar x))
# Line 529  Line 582 
582                    val z = T.E_Lit(Literal.Real(RealLit.zero false))                    val z = T.E_Lit(Literal.Real(RealLit.zero false))
583                    val sz = List.foldl Int.* 1 dd                    val sz = List.foldl Int.* 1 dd
584                    in                    in
585                      bindRHS (T.E_Cons(List.tabulate(sz, fn _ => z), U.trType ty));                      bindCons (List.tabulate(sz, fn _ => z), ty, [])
                     []  
586                    end                    end
587                | IR.OP(Op.LoadSeq(ty, file), []) => let                | IR.OP(Op.LoadSeq(ty, file), []) => let
588                    val lhs = newLocal (env, getLHS ())                    val lhs = newLocal (env, getLHS ())
# Line 562  Line 614 
614                        | _ => raise Fail "inconsistent"                        | _ => raise Fail "inconsistent"
615                      (* end case *)                      (* end case *)
616                    end                    end
               | IR.CONS(args, Ty.TensorTy[d]) => let  
                   val layout = Env.layoutVec env d  
                   val (args, stms) = simpleArgs (env, args)  
                   fun mkVecs (args, w::ws) = let  
                       (* take arguments from args to build a vector value of width w; pad as  
                        * necessary.  
                        *)  
                         fun take (0, args, es) = T.E_Vec(w, w, List.rev es) :: mkVecs (args, ws)  
                           | take (i, [], es) = if #padded layout andalso null ws  
                               then [T.E_Vec(w-i, w, List.rev es)]  
                               else raise Fail "too few arguments for CONS"  
                           | take (i, arg::args, es) = take (i-1, args, arg :: es)  
                         in  
                           take (w, args, [])  
                         end  
                     | mkVecs ([], []) = []  
                     | mkVecs (_, []) = raise Fail "too many arguments for CONS"  
                   val es = mkVecs (args, #pieces layout)  
                   in  
                     case (eqClassRepOf(env, lhs), V.useCount lhs > 1)  
                      of (NOEQ, false) => (Env.bindVar(env, lhs, Env.VEC(layout, es)); stms)  
                       | (NOEQ, true) => let  
                           val vs = U.newVectorVars layout  
                           in  
                             Env.bindVar (env, lhs, Env.VEC(layout, List.map T.E_Var vs));  
                             ListPair.foldl (fn (v, e, stms) => mkDefn(v, e)::stms) stms (vs, es)  
                           end  
                       | (VEC xs, _) =>  
                           ListPair.foldl (fn (x, e, stms) => mkAssign(x, e)::stms) stms (xs, es)  
                       | _ => raise Fail "inconsistent"  
                     (* end case *)  
                   end  
617                | IR.CONS(args, ty) => let                | IR.CONS(args, ty) => let
618                    val (es, stms) = singleArgs (env, args)                    val (es, stms) = simpleArgs (env, args)
                   val ty = U.trType ty  
619                    in                    in
620                      Env.bindVar (env, getLHS (), Env.RHS(ty, T.E_Cons(es, ty)));                      bindCons (es, ty, stms)
                     stms  
621                    end                    end
622                | IR.SEQ(args, ty) => let                | IR.SEQ(args, ty) => let
623                    val (es, stms) = singleArgs (env, args)                    val (es, stms) = singleArgs (env, args)
# Line 609  Line 627 
627                           of TTy.SeqTy(TTy.TensorTy _, _) => List.map mkDeref es                           of TTy.SeqTy(TTy.TensorTy _, _) => List.map mkDeref es
628                            | _ => es                            | _ => es
629                          (* end case *))                          (* end case *))
630                      val seq = T.E_Seq(es, ty)
631                    in                    in
632                      Env.bindVar (env, getLHS (), Env.RHS(ty, T.E_Seq(es, ty)));                      case eqClassRepOf(env, lhs)
633                      stms                       of NOEQ => mkDefn (newMemLocal (env, lhs), seq) :: stms
634                          | VAR x => mkAssign (x, seq) :: stms
635                          | VEC xs => raise Fail "inconsistent"
636                        (* end case *)
637                    end                    end
638                | rhs => raise Fail(concat["unexpected ", IR.RHS.toString rhs, " in LowIR code"])                | rhs => raise Fail(concat["unexpected ", IR.RHS.toString rhs, " in LowIR code"])
639              (* end case *)              (* end case *)

Legend:
Removed from v.4077  
changed lines
  Added in v.4091

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