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 3952, Sat Jun 11 17:20:27 2016 UTC revision 3955, Sun Jun 12 15:55:01 2016 UTC
# Line 73  Line 73 
73        val {peekFn : IR.var -> eq_var_rep option, setFn, ...} =        val {peekFn : IR.var -> eq_var_rep option, setFn, ...} =
74              V.newProp (fn x => raise Fail(V.toString x))              V.newProp (fn x => raise Fail(V.toString x))
75    
76        fun repOf (env, x, x') = (case peekFn x'        fun repOf (env, x) = (case peekFn x
77               of SOME b => b               of SOME b => b
78                | NONE => let                | NONE => let
79                    val rep = (case V.ty x                    val rep = (case V.ty x
# Line 88  Line 88 
88      in      in
89    
90      fun eqClassRepOf (env, x) = (case UnifyVars.eqClassOf x      fun eqClassRepOf (env, x) = (case UnifyVars.eqClassOf x
91             of SOME x' => repOf (env, x, x')             of SOME x' => repOf (env, x')
92              | NONE => NOEQ              | NONE => NOEQ
93            (* end case *))            (* end case *))
94    
# Line 96  Line 96 
96            val useV = Env.useVar env            val useV = Env.useVar env
97            in            in
98              fn x => (case UnifyVars.eqClassOf x              fn x => (case UnifyVars.eqClassOf x
99                    of SOME x' => (case repOf (env, x, x')                    of SOME x' => (case repOf (env, x')
100                         of VAR x => Env.TREE(T.E_Var x)                         of VAR x => Env.TREE(T.E_Var x)
101                          | VEC xs => let                          | VEC xs => let
102                              val Ty.TensorTy[d] = V.ty x                              val Ty.TensorTy[d] = V.ty x
# Line 381  Line 381 
381                        | _ => raise Fail(concat["FIXME: RealToInt<", Int.toString d, ">"])                        | _ => raise Fail(concat["FIXME: RealToInt<", Int.toString d, ">"])
382                      (* end case *)                      (* end case *)
383                    end                    end
384  (* FIXME  (* FIXME: reduction operators
385                | Op.R_All ty => ??                | Op.R_All ty => ??
386                | Op.R_Exists ty => ??                | Op.R_Exists ty => ??
387                | Op.R_Max ty => ??                | Op.R_Max ty => ??
# Line 402  Line 402 
402              (* end case *)              (* end case *)
403            end            end
404    
405    (* FIXME: we need to defer the copy when possible *)
406      (* if required, add a TensorCopy operation to the rhs of an assignment *)
407        fun mkAssignRHS (TTy.TensorTy _, rhs) = (case TreeTypeOf.exp rhs
408               of TTy.TensorRefTy shp => T.E_Op(TOp.TensorCopy shp, [rhs])
409                | _ => rhs
410              (* end case *))
411          | mkAssignRHS (_, rhs) = rhs
412    
413        fun mkDefn' (x, rhs) = mkDefn (x, mkAssignRHS(TV.ty x, rhs))
414        fun mkAssign' (x, rhs) = mkAssign (x, mkAssignRHS(TV.ty x, rhs))
415    
416  (* cases:  (* cases:
417          x in EqClass          x in EqClass
418                  issue assignment; lhs is binding of representative (could be multiple vars)                  issue assignment; lhs is binding of representative (could be multiple vars)
# Line 410  Line 421 
421          rhs is vector          rhs is vector
422  *)  *)
423      fun trAssign (env, lhs, rhs) = let      fun trAssign (env, lhs, rhs) = let
424            fun bindRHS rhs = Env.bindVar (env, lhs, Env.RHS(U.trType(V.ty lhs), rhs))            fun getLHS () = (case UnifyVars.eqClassOf lhs of SOME x => x | _ => lhs)
425              fun bindRHS rhs = Env.bindVar (env, getLHS(), Env.RHS(U.trType(V.ty lhs), rhs))
426          (* 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
427           * 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
428           * assigment(s)           * assigment(s)
429           *)           *)
430            fun bindSimple rhs = (case eqClassRepOf(env, lhs)            fun bindSimple rhs = (case eqClassRepOf(env, lhs)
431                   of NOEQ => (Env.bindSimple (env, lhs, rhs); [])                   of NOEQ => (Env.bindSimple (env, lhs, rhs); [])
432                    | VAR x' => [mkAssign(x', rhs)]                    | VAR x' => [mkAssign' (x', rhs)]
433                    | VEC xs' => (case V.ty lhs                    | VEC xs' => (case V.ty lhs
434                         of Ty.TensorTy[d] => let                         of Ty.TensorTy[d] => let
435                              val layout = Env.layoutVec env d                              val layout = Env.layoutVec env d
# Line 436  Line 448 
448                     of NOEQ => (                     of NOEQ => (
449                          bindRHS (T.E_Op(rator, args));                          bindRHS (T.E_Op(rator, args));
450                          stms)                          stms)
451                      | VAR x' => stms @ [mkAssign(x', T.E_Op(rator, args))]                      | VAR x' => stms @ [mkAssign' (x', T.E_Op(rator, args))]
452                      | VEC _ => raise Fail ("unexpected VEC for lhs " ^ V.toString lhs)                      | VEC _ => raise Fail ("unexpected VEC for lhs " ^ V.toString lhs)
453                    (* end case *)                    (* end case *)
454                  end                  end
# Line 465  Line 477 
477                      []                      []
478                    end                    end
479                | IR.OP(Op.LoadSeq(ty, file), []) => let                | IR.OP(Op.LoadSeq(ty, file), []) => let
480                    val lhs = newLocal (env, lhs)                    val lhs = newLocal (env, getLHS ())
481                    in                    in
482                      [T.S_LoadNrrd(lhs, U.toAPIType ty, file)]                      [T.S_LoadNrrd(lhs, U.toAPIType ty, file)]
483                    end                    end
484                | IR.OP(Op.LoadImage(ty, file), []) => let                | IR.OP(Op.LoadImage(ty, file), []) => let
485                    val lhs = newLocal (env, lhs)                    val lhs = newLocal (env, getLHS ())
486                    in                    in
487                      [T.S_LoadNrrd(lhs, U.toAPIType ty, file)]                      [T.S_LoadNrrd(lhs, U.toAPIType ty, file)]
488                    end                    end
# Line 479  Line 491 
491                    in                    in
492                      case (rhs, eqClassRepOf(env, lhs), V.useCount lhs > 1)                      case (rhs, eqClassRepOf(env, lhs), V.useCount lhs > 1)
493                       of (_, NOEQ, false) => (Env.bindVar (env, lhs, rhs); stms)                       of (_, NOEQ, false) => (Env.bindVar (env, lhs, rhs); stms)
494                        | (Env.TREE e, NOEQ, true) => mkDefn(newLocal(env, lhs), e) :: stms                        | (Env.TREE e, NOEQ, true) => mkDefn'(newLocal(env, lhs), e) :: stms
495                        | (Env.TREE e, VAR x', _) => mkAssign(x', e) :: stms                        | (Env.TREE e, VAR x', _) => mkAssign'(x', e) :: stms
496                        | (Env.VEC(layout, es), NOEQ, true) => let                        | (Env.VEC(layout, es), NOEQ, true) => let
497                            val vs = U.newVectorVars layout                            val vs = U.newVectorVars layout
498                            in                            in
# Line 528  Line 540 
540                    val (es, stms) = singleArgs (env, args)                    val (es, stms) = singleArgs (env, args)
541                    val ty = U.trType ty                    val ty = U.trType ty
542                    in                    in
543                      Env.bindVar (env, lhs, Env.RHS(ty, T.E_Cons(es, ty)));                      Env.bindVar (env, getLHS (), Env.RHS(ty, T.E_Cons(es, ty)));
544                      stms                      stms
545                    end                    end
546                | IR.SEQ(args, ty) => let                | IR.SEQ(args, ty) => let
547                    val (es, stms) = singleArgs (env, args)                    val (es, stms) = singleArgs (env, args)
548                    val ty = U.trType ty                    val ty = U.trType ty
549                    in                    in
550                      Env.bindVar (env, lhs, Env.RHS(ty, T.E_Seq(es, ty)));                      Env.bindVar (env, getLHS (), Env.RHS(ty, T.E_Seq(es, ty)));
551                      stms                      stms
552                    end                    end
553                | rhs => raise Fail(concat["unexpected ", IR.RHS.toString rhs, " in LowIR code"])                | rhs => raise Fail(concat["unexpected ", IR.RHS.toString rhs, " in LowIR code"])
# Line 655  Line 667 
667                        ])                        ])
668                    | IR.GASSIGN{lhs, rhs, succ, ...} => let                    | IR.GASSIGN{lhs, rhs, succ, ...} => let
669                        val gv = mkGlobalVar lhs                        val gv = mkGlobalVar lhs
670                          fun mkGAssign (gv, e) = T.S_GAssign(gv, mkAssignRHS(TGV.ty gv, e))
671                        val stm = (case useVar env rhs                        val stm = (case useVar env rhs
672                               of Env.RHS(_, e) => T.S_GAssign(gv, e)                               of Env.RHS(_, e) => mkGAssign(gv, e)
673                                | Env.TREE e => T.S_GAssign(gv, e)                                | Env.TREE e => mkGAssign(gv, e)
674                                | Env.VEC(layout, es) => let                                | Env.VEC(layout, es) => let
675                                    val tmp = U.newTempVar("_arg", TTy.TensorTy[#wid layout])                                    val tmp = U.newTempVar("_arg", TTy.TensorTy[#wid layout])
676                                    in                                    in
# Line 675  Line 688 
688                        end                        end
689                    | IR.SAVE{lhs, rhs, succ, ...} => let                    | IR.SAVE{lhs, rhs, succ, ...} => let
690                        val sv = getStateVar lhs                        val sv = getStateVar lhs
691                          fun mkSAssign (sv, e) = T.S_Save(sv, mkAssignRHS(TSV.ty sv, e))
692                        val stm = (case useVar env rhs                        val stm = (case useVar env rhs
693                               of Env.RHS(_, e) => T.S_Save(sv, e)                               of Env.RHS(_, e) => mkSAssign(sv, e)
694                                | Env.TREE e => T.S_Save(sv, e)                                | Env.TREE e => mkSAssign(sv, e)
695                                | Env.VEC(layout, es) => let                                | Env.VEC(layout, es) => let
696                                    val tmp = U.newTempVar("_arg", TTy.TensorTy[#wid layout])                                    val tmp = U.newTempVar("_arg", TTy.TensorTy[#wid layout])
697                                    in                                    in
# Line 710  Line 724 
724    
725      fun trCFG info cfg = ScopeVars.assignScopes ([], trCFGWithEnv (Env.new info, cfg))      fun trCFG info cfg = ScopeVars.assignScopes ([], trCFGWithEnv (Env.new info, cfg))
726    
727      (* Build a strand method from a TreeIR block.  We need to check for language features
728       * that require the world pointer (e.g., printing) and for references to global variables.
729       *)
730      fun mkMethod body = let      fun mkMethod body = let
731            fun chkBlock (T.Block{body, ...}, uG, nW) =            fun chkBlock (T.Block{body, ...}, uG, nW) =
732                  chkStms (body, uG, nW)                  chkStms (body, uG, nW)

Legend:
Removed from v.3952  
changed lines
  Added in v.3955

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