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 4039, Fri Jun 24 15:35:09 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 117  Line 117 
117      fun mkDefn (x, e) = T.S_Assign(true, x, e)      fun mkDefn (x, e) = T.S_Assign(true, x, e)
118      val zero = T.E_Lit(Literal.Real(RealLit.zero false))      val zero = T.E_Lit(Literal.Real(RealLit.zero false))
119    
120      (* turn an expression of type TensorTy to one of TensorTyRef *)
121        fun mkRef e = (case TreeTypeOf.exp e
122               of TTy.TensorTy(shp as _::_) => T.E_Op(TOp.TensorRef shp, [e])
123                | _ => e
124             (* end case *))
125    
126      fun cvtScalarTy Ty.BoolTy = TTy.BoolTy      fun cvtScalarTy Ty.BoolTy = TTy.BoolTy
127        | cvtScalarTy Ty.IntTy = TTy.IntTy        | cvtScalarTy Ty.IntTy = TTy.IntTy
128        | cvtScalarTy (Ty.TensorTy[]) = TTy.realTy        | cvtScalarTy (Ty.TensorTy[]) = TTy.realTy
# Line 189  Line 195 
195            fun expToArg (e, stms) = (case V.ty x            fun expToArg (e, stms) = (case V.ty x
196                   of Ty.TensorTy[d] => let                   of Ty.TensorTy[d] => let
197                        val layout = Env.layoutVec env d                        val layout = Env.layoutVec env d
198  (* QUESTION: can "e" be a complicated expression or are we guaranteed that it will just                        val e = mkRef e
  * be a memory reference?  
  *)  
199                        val es = List.tabulate (                        val es = List.tabulate (
200                              List.length(#pieces layout),                              List.length(#pieces layout),
201                              fn i => T.E_VLoad(layout, e, i))                              fn i => T.E_VLoad(layout, e, i))
# Line 248  Line 252 
252            end            end
253    
254      fun trOp (env, srcRator, args) = let      fun trOp (env, srcRator, args) = let
255            fun bindOp rator = let            fun bindTREE rator = let
256                  val (args, stms) = simpleArgs (env, args)                  val (args, stms) = simpleArgs (env, args)
257                  in                  in
258                    (Env.TREE(T.E_Op(rator, args)), stms)                    (Env.TREE(T.E_Op(rator, args)), stms)
# Line 276  Line 280 
280                  end                  end
281            in            in
282              case srcRator              case srcRator
283               of Op.IAdd => bindOp TOp.IAdd               of Op.IAdd => bindTREE TOp.IAdd
284                | Op.ISub => bindOp TOp.ISub                | Op.ISub => bindTREE TOp.ISub
285                | Op.IMul => bindOp TOp.IMul                | Op.IMul => bindTREE TOp.IMul
286                | Op.IDiv => bindOp TOp.IDiv                | Op.IDiv => bindTREE TOp.IDiv
287                | Op.IMod => bindOp TOp.IMod                | Op.IMod => bindTREE TOp.IMod
288                | Op.INeg => bindOp TOp.INeg                | Op.INeg => bindTREE TOp.INeg
289  (* QUESTION: should we just use VAdd 1, etc ?*)  (* QUESTION: should we just use VAdd 1, etc ?*)
290                | Op.RAdd => bindOp TOp.RAdd                | Op.RAdd => bindTREE TOp.RAdd
291                | Op.RSub => bindOp TOp.RSub                | Op.RSub => bindTREE TOp.RSub
292                | Op.RMul => bindOp TOp.RMul                | Op.RMul => bindTREE TOp.RMul
293                | Op.RDiv => bindOp TOp.RDiv                | Op.RDiv => bindTREE TOp.RDiv
294                | Op.RNeg => bindOp TOp.RNeg                | Op.RNeg => bindTREE TOp.RNeg
295                | Op.LT ty => bindOp (TOp.LT (cvtScalarTy ty))                | Op.LT ty => bindTREE (TOp.LT (cvtScalarTy ty))
296                | Op.LTE ty => bindOp (TOp.LTE (cvtScalarTy ty))                | Op.LTE ty => bindTREE (TOp.LTE (cvtScalarTy ty))
297                | Op.EQ ty => bindOp (TOp.EQ (cvtScalarTy ty))                | Op.EQ ty => bindTREE (TOp.EQ (cvtScalarTy ty))
298                | Op.NEQ ty => bindOp (TOp.NEQ (cvtScalarTy ty))                | Op.NEQ ty => bindTREE (TOp.NEQ (cvtScalarTy ty))
299                | Op.GT ty => bindOp (TOp.GT (cvtScalarTy ty))                | Op.GT ty => bindTREE (TOp.GT (cvtScalarTy ty))
300                | Op.GTE ty => bindOp (TOp.GTE (cvtScalarTy ty))                | Op.GTE ty => bindTREE (TOp.GTE (cvtScalarTy ty))
301                | Op.Not => bindOp TOp.Not                | Op.Not => bindTREE TOp.Not
302                | Op.Abs ty => bindOp (TOp.Abs (cvtScalarTy ty))                | Op.Abs ty => bindTREE (TOp.Abs (cvtScalarTy ty))
303                | Op.Max ty => bindOp (TOp.Max (cvtScalarTy ty))                | Op.Max ty => bindTREE (TOp.Max (cvtScalarTy ty))
304                | Op.Min ty => bindOp (TOp.Min (cvtScalarTy ty))                | Op.Min ty => bindTREE (TOp.Min (cvtScalarTy ty))
305                | Op.RClamp => bindOp TOp.RClamp                | Op.RClamp => bindTREE TOp.RClamp
306                | Op.RLerp => bindOp TOp.RLerp                | Op.RLerp => bindTREE TOp.RLerp
307                | Op.VAdd _ => bindVOp TOp.VAdd                | Op.VAdd _ => bindVOp TOp.VAdd
308                | Op.VSub _ => bindVOp TOp.VSub                | Op.VSub _ => bindVOp TOp.VSub
309                | Op.VScale _ => let                | Op.VScale _ => let
# Line 344  Line 348 
348                    end                    end
349                | Op.VMapClamp n => bindVOp TOp.VMapClamp                | Op.VMapClamp n => bindVOp TOp.VMapClamp
350                | Op.VLerp n => bindVOp TOp.VLerp                | Op.VLerp n => bindVOp TOp.VLerp
351                | Op.TensorIndex(ty, idxs) => bindOp(TOp.TensorIndex(U.trType ty, idxs))                | Op.TensorIndex(ty, idxs) => let
352                | Op.ProjectLast(ty, idxs) => bindOp(TOp.ProjectLast(U.trType ty, idxs))                    val ([arg], stms) = simpleArgs (env, args)
353                | Op.Select(ty, i) => bindOp (TOp.Select(U.trType ty, i))                    val ty = TreeTypeOf.exp arg
354                | Op.Subscript ty => bindOp (TOp.Subscript(U.trType ty))                    in
355                | Op.MkDynamic(ty, n) => bindOp (TOp.MkDynamic(U.trType ty, n))                      (Env.TREE(T.E_Op(TOp.TensorIndex(ty, idxs), [arg])), stms)
356                | Op.Append ty => bindOp (TOp.Append(U.trType ty))                    end
357                | Op.Prepend ty => bindOp (TOp.Prepend(U.trType ty))                | Op.ProjectLast(_, idxs) => let
358                | Op.Concat ty => bindOp (TOp.Concat(U.trType ty))                    val ([arg], stms) = simpleArgs (env, args)
359                | Op.Range => bindOp TOp.Range                    val ty = TreeTypeOf.exp arg
360                | Op.Length ty => bindOp (TOp.Length(U.trType ty))                    in
361                | Op.SphereQuery(ty1, ty2) => raise Fail "FIXME: SphereQuery"                      (Env.TREE(T.E_Op(TOp.ProjectLast(ty, idxs), [arg])), stms)
362                | Op.Sqrt => bindOp TOp.Sqrt                    end
363                | Op.Cos => bindOp TOp.Cos                | Op.Select(ty, i) => bindTREE (TOp.Select(U.trType ty, i))
364                | Op.ArcCos => bindOp TOp.ArcCos                | Op.Subscript ty => bindTREE (TOp.Subscript(U.trType ty))
365                | Op.Sin => bindOp TOp.Sin                | Op.MkDynamic(ty, n) => bindTREE (TOp.MkDynamic(U.trType ty, n))
366                | Op.ArcSin => bindOp TOp.ArcSin                | Op.Append ty => bindTREE (TOp.Append(U.trType ty))
367                | Op.Tan => bindOp TOp.Tan                | Op.Prepend ty => bindTREE (TOp.Prepend(U.trType ty))
368                | Op.ArcTan => bindOp TOp.ArcTan                | Op.Concat ty => bindTREE (TOp.Concat(U.trType ty))
369                | Op.Ceiling 1 => bindOp TOp.RCeiling                | Op.Range => bindTREE TOp.Range
370                  | Op.Length ty => bindTREE (TOp.Length(U.trType ty))
371                  | Op.SphereQuery(ty1, ty2) => bindTREE (TOp.SphereQuery(U.trType ty1, U.trType ty2))
372                  | Op.Sqrt => bindTREE TOp.Sqrt
373                  | Op.Cos => bindTREE TOp.Cos
374                  | Op.ArcCos => bindTREE TOp.ArcCos
375                  | Op.Sin => bindTREE TOp.Sin
376                  | Op.ArcSin => bindTREE TOp.ArcSin
377                  | Op.Tan => bindTREE TOp.Tan
378                  | Op.ArcTan => bindTREE TOp.ArcTan
379                  | Op.Exp  => bindTREE TOp.Exp
380                  | Op.Ceiling 1 => bindTREE TOp.RCeiling
381                | Op.Ceiling d => bindVOp TOp.VCeiling                | Op.Ceiling d => bindVOp TOp.VCeiling
382                | Op.Floor 1 => bindOp TOp.RFloor                | Op.Floor 1 => bindTREE TOp.RFloor
383                | Op.Floor d => bindVOp TOp.VFloor                | Op.Floor d => bindVOp TOp.VFloor
384                | Op.Round 1 => bindOp TOp.RRound                | Op.Round 1 => bindTREE TOp.RRound
385                | Op.Round d => bindVOp TOp.VRound                | Op.Round d => bindVOp TOp.VRound
386                | Op.Trunc 1 => bindOp TOp.RTrunc                | Op.Trunc 1 => bindTREE TOp.RTrunc
387                | Op.Trunc d => bindVOp TOp.VTrunc                | Op.Trunc d => bindVOp TOp.VTrunc
388                | Op.IntToReal => bindOp TOp.IntToReal                | Op.IntToReal => bindTREE TOp.IntToReal
389                | Op.RealToInt 1 => bindOp TOp.RealToInt                | Op.RealToInt 1 => bindTREE TOp.RealToInt
390                | Op.RealToInt d => let                | Op.RealToInt d => let
391                    val layout = Env.layoutVec env d                    val [v] = args
392                    val (_, args, stms) = vectorArg (env, hd args)                    val (layout, args, stms) = vectorArg (env, v)
393                    in                    in
394                      case #pieces layout                      case #pieces layout
395                       of [w] => (Env.TREE(T.E_Op(TOp.VToInt(d, w), args)), stms)                       of [w] => (Env.TREE(T.E_Op(TOp.VToInt(d, w), args)), stms)
396                        | _ => raise Fail(concat["FIXME: RealToInt<", Int.toString d, ">"])                        | _ => raise Fail(concat["FIXME: RealToInt<", Int.toString d, ">"])
397                      (* end case *)                      (* end case *)
398                    end                    end
399  (* FIXME  (* FIXME: reduction operators
400                | Op.R_All ty => ??                | Op.R_All ty => ??
401                | Op.R_Exists ty => ??                | Op.R_Exists ty => ??
402                | Op.R_Max ty => ??                | Op.R_Max ty => ??
# Line 391  Line 406 
406                | Op.R_Mean ty => ??                | Op.R_Mean ty => ??
407                | Op.R_Variance ty => ??                | Op.R_Variance ty => ??
408  *)  *)
409                | Op.Transform info => bindOp (TOp.Transform info)                | Op.Transform info => bindTREE (TOp.Transform info)
410                | Op.Translate info => bindOp (TOp.Translate info)                | Op.Translate info => bindTREE (TOp.Translate info)
411                | Op.ControlIndex(info, ctl, d) => bindOp (TOp.ControlIndex(info, ctl, d))                | Op.ControlIndex(info, ctl, d) => bindTREE (TOp.ControlIndex(info, ctl, d))
412                | Op.LoadVoxel info => bindOp (TOp.LoadVoxel info)                | Op.LoadVoxel info => bindTREE (TOp.LoadVoxel info)
413                | Op.Inside(info, s) => bindOp (TOp.Inside(info, s))                | Op.Inside(info, s) => bindTREE (TOp.Inside(info, s))
414                | Op.ImageDim(info, d) => bindOp(TOp.ImageDim(info, d))                | Op.ImageDim(info, d) => bindTREE(TOp.ImageDim(info, d))
415                | Op.MathFn f => bindOp (TOp.MathFn f)                | Op.MathFn f => bindTREE (TOp.MathFn f)
416                | rator => raise Fail("bogus operator " ^ Op.toString srcRator)                | rator => raise Fail("bogus operator " ^ Op.toString srcRator)
417              (* end case *)              (* end case *)
418            end            end
419    
420    (* FIXME: we need to defer the copy when possible *)
421      (* if required, add a TensorCopy operation to the rhs of an assignment *)
422        fun mkAssignRHS (TTy.TensorTy _, rhs) = (case TreeTypeOf.exp rhs
423               of TTy.TensorRefTy shp => T.E_Op(TOp.TensorCopy shp, [rhs])
424                | _ => rhs
425              (* end case *))
426          | mkAssignRHS (_, rhs) = rhs
427    
428        fun mkDefn' (x, rhs) = mkDefn (x, mkAssignRHS(TV.ty x, rhs))
429        fun mkAssign' (x, rhs) = mkAssign (x, mkAssignRHS(TV.ty x, rhs))
430    
431  (* cases:  (* cases:
432          x in EqClass          x in EqClass
433                  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 436 
436          rhs is vector          rhs is vector
437  *)  *)
438      fun trAssign (env, lhs, rhs) = let      fun trAssign (env, lhs, rhs) = let
439            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)
440              fun bindRHS rhs = Env.bindVar (env, getLHS(), Env.RHS(U.trTempType(V.ty lhs), rhs))
441          (* 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
442           * 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
443           * assigment(s)           * assigment(s)
444           *)           *)
445            fun bindSimple rhs = (case eqClassRepOf(env, lhs)            fun bindSimple rhs = (case eqClassRepOf(env, lhs)
446                   of NOEQ => (Env.bindSimple (env, lhs, rhs); [])                   of NOEQ => (Env.bindSimple (env, lhs, rhs); [])
447                    | VAR x' => [mkAssign(x', rhs)]                    | VAR x' => [mkAssign' (x', rhs)]
448                    | VEC xs' => (case V.ty lhs                    | VEC xs' => (case V.ty lhs
449                         of Ty.TensorTy[d] => let                         of Ty.TensorTy[d] => let
450                              val layout = Env.layoutVec env d                              val layout = Env.layoutVec env d
451                                val rhs = mkRef rhs
452                              in                              in
453                                List.mapi                                List.mapi
454                                  (fn (i, x') => mkAssign(x', T.E_VLoad(layout, rhs, i)))                                  (fn (i, x') => mkAssign(x', T.E_VLoad(layout, rhs, i)))
# Line 436  Line 464 
464                     of NOEQ => (                     of NOEQ => (
465                          bindRHS (T.E_Op(rator, args));                          bindRHS (T.E_Op(rator, args));
466                          stms)                          stms)
467                      | VAR x' => stms @ [mkAssign(x', T.E_Op(rator, args))]                      | VAR x' => stms @ [mkAssign' (x', T.E_Op(rator, args))]
468                      | VEC _ => raise Fail ("unexpected VEC for lhs " ^ V.toString lhs)                      | VEC _ => raise Fail ("unexpected VEC for lhs " ^ V.toString lhs)
469                    (* end case *)                    (* end case *)
470                  end                  end
# Line 453  Line 481 
481                    end                    end
482                | IR.VAR x => raise Fail "FIXME: VAR"                | IR.VAR x => raise Fail "FIXME: VAR"
483                | IR.LIT lit => bindSimple (T.E_Lit lit)                | IR.LIT lit => bindSimple (T.E_Lit lit)
484    (* FIXME: use the general IR.OP case for eigen-things, since the target info says that they
485     * are not inline.
486     *)
487                | IR.OP(Op.EigenVecs2x2, args) => assignOp (TOp.EigenVecs2x2, args)                | IR.OP(Op.EigenVecs2x2, args) => assignOp (TOp.EigenVecs2x2, args)
488                | IR.OP(Op.EigenVecs3x3, args) => assignOp (TOp.EigenVecs3x3, args)                | IR.OP(Op.EigenVecs3x3, args) => assignOp (TOp.EigenVecs3x3, args)
489                | IR.OP(Op.EigenVals2x2, args) => assignOp (TOp.EigenVals2x2, args)                | IR.OP(Op.EigenVals2x2, args) => assignOp (TOp.EigenVals2x2, args)
# Line 465  Line 496 
496                      []                      []
497                    end                    end
498                | IR.OP(Op.LoadSeq(ty, file), []) => let                | IR.OP(Op.LoadSeq(ty, file), []) => let
499                    val lhs = newLocal (env, lhs)                    val lhs = newLocal (env, getLHS ())
500                    in                    in
501                      [T.S_LoadNrrd(lhs, U.toAPIType ty, file)]                      [T.S_LoadNrrd(lhs, U.toAPIType ty, file)]
502                    end                    end
503                | IR.OP(Op.LoadImage(ty, file), []) => let                | IR.OP(Op.LoadImage(ty, file), []) => let
504                    val lhs = newLocal (env, lhs)                    val lhs = newLocal (env, getLHS ())
505                    in                    in
506                      [T.S_LoadNrrd(lhs, U.toAPIType ty, file)]                      [T.S_LoadNrrd(lhs, U.toAPIType ty, file)]
507                    end                    end
508                | IR.OP(rator, args) => let                | IR.OP(rator, args) => let
509                    val (rhs, stms) = trOp (env, rator, args)                    val (rhs, stms) = trOp (env, rator, args)
510                      val emitBind = (V.useCount lhs > 1) orelse not(Env.isInlineOp env rator)
511                    in                    in
512                      case (rhs, eqClassRepOf(env, lhs), V.useCount lhs > 1)                      case (rhs, eqClassRepOf(env, lhs), emitBind)
513                       of (_, NOEQ, false) => (Env.bindVar (env, lhs, rhs); stms)                       of (_, NOEQ, false) => (Env.bindVar (env, lhs, rhs); stms)
514                        | (Env.TREE e, NOEQ, true) => mkDefn(newLocal(env, lhs), e) :: stms  (* FIXME: if the rhs has TensorRef type, then we should make the lhs TensorRef too! *)
515                        | (Env.TREE e, VAR x', _) => mkAssign(x', e) :: stms                        | (Env.TREE e, NOEQ, true) => mkDefn'(newLocal(env, lhs), e) :: stms
516                          | (Env.TREE e, VAR x', _) => mkAssign'(x', e) :: stms
517                        | (Env.VEC(layout, es), NOEQ, true) => let                        | (Env.VEC(layout, es), NOEQ, true) => let
518                            val vs = U.newVectorVars layout                            val vs = U.newVectorVars layout
519                            in                            in
# Line 528  Line 561 
561                    val (es, stms) = singleArgs (env, args)                    val (es, stms) = singleArgs (env, args)
562                    val ty = U.trType ty                    val ty = U.trType ty
563                    in                    in
564                      Env.bindVar (env, lhs, Env.RHS(ty, T.E_Cons(es, ty)));                      Env.bindVar (env, getLHS (), Env.RHS(ty, T.E_Cons(es, ty)));
565                      stms                      stms
566                    end                    end
567                | IR.SEQ(args, ty) => let                | IR.SEQ(args, ty) => let
568                    val (es, stms) = singleArgs (env, args)                    val (es, stms) = singleArgs (env, args)
569                    val ty = U.trType ty                    val ty = U.trType ty
570                    in                    in
571                      Env.bindVar (env, lhs, Env.RHS(ty, T.E_Seq(es, ty)));                      Env.bindVar (env, getLHS (), Env.RHS(ty, T.E_Seq(es, ty)));
572                      stms                      stms
573                    end                    end
574                | 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 646  Line 679 
679                        end                        end
680                    | IR.MASSIGN{stm=([], Op.Print tys, xs), succ, ...} => let                    | IR.MASSIGN{stm=([], Op.Print tys, xs), succ, ...} => let
681                        val (es, stms') = singleArgs (env, xs)                        val (es, stms') = singleArgs (env, xs)
682                        val stm = T.S_Print(List.map U.trType tys, es)                      (* translate TensorTy to TensorRefTy in the type list *)
683                          fun trType (Ty.TensorTy(shp as _::_)) = TTy.TensorRefTy shp
684                            | trType ty = U.trType ty
685                          val tys = List.map trType tys
686                          val stm = T.S_Print(tys, List.map mkRef es)
687                        in                        in
688                          doNode (!succ, ifStk, stm :: List.revAppend (stms', stms))                          doNode (!succ, ifStk, stm :: List.revAppend (stms', stms))
689                        end                        end
# Line 655  Line 692 
692                        ])                        ])
693                    | IR.GASSIGN{lhs, rhs, succ, ...} => let                    | IR.GASSIGN{lhs, rhs, succ, ...} => let
694                        val gv = mkGlobalVar lhs                        val gv = mkGlobalVar lhs
695                          fun mkGAssign (gv, e) = T.S_GAssign(gv, mkAssignRHS(TGV.ty gv, e))
696                        val stm = (case useVar env rhs                        val stm = (case useVar env rhs
697                               of Env.RHS(_, e) => T.S_GAssign(gv, e)                               of Env.RHS(_, e) => mkGAssign(gv, e)
698                                | Env.TREE e => T.S_GAssign(gv, e)                                | Env.TREE e => mkGAssign(gv, e)
699                                | Env.VEC(layout, es) => let                                | Env.VEC(layout, es) => let
700                                    val tmp = U.newTempVar("_arg", TTy.TensorTy[#wid layout])                                    val tmp = U.newTempVar("_arg", TTy.TensorTy[#wid layout])
701                                    in                                    in
# Line 675  Line 713 
713                        end                        end
714                    | IR.SAVE{lhs, rhs, succ, ...} => let                    | IR.SAVE{lhs, rhs, succ, ...} => let
715                        val sv = getStateVar lhs                        val sv = getStateVar lhs
716                          fun mkSAssign (sv, e) = T.S_Save(sv, mkAssignRHS(TSV.ty sv, e))
717                        val stm = (case useVar env rhs                        val stm = (case useVar env rhs
718                               of Env.RHS(_, e) => T.S_Save(sv, e)                               of Env.RHS(_, e) => mkSAssign(sv, e)
719                                | Env.TREE e => T.S_Save(sv, e)                                | Env.TREE e => mkSAssign(sv, e)
720                                | Env.VEC(layout, es) => let                                | Env.VEC(layout, es) => let
721                                    val tmp = U.newTempVar("_arg", TTy.TensorTy[#wid layout])                                    val tmp = U.newTempVar("_arg", TTy.TensorTy[#wid layout])
722                                    in                                    in
# Line 710  Line 749 
749    
750      fun trCFG info cfg = ScopeVars.assignScopes ([], trCFGWithEnv (Env.new info, cfg))      fun trCFG info cfg = ScopeVars.assignScopes ([], trCFGWithEnv (Env.new info, cfg))
751    
752      (* Build a strand method from a TreeIR block.  We need to check for language features
753       * that require the world pointer (e.g., printing) and for references to global variables.
754       *)
755      fun mkMethod body = let      fun mkMethod body = let
756            fun chkBlock (T.Block{body, ...}, uG, nW) =            fun chkBlock (T.Block{body, ...}, uG, nW) =
757                  chkStms (body, uG, nW)                  chkStms (body, uG, nW)
# Line 725  Line 767 
767                      | T.S_IfThen(e, blk) => let                      | T.S_IfThen(e, blk) => let
768                          val (uG, nW) = chkExp (e, uG, nW)                          val (uG, nW) = chkExp (e, uG, nW)
769                          in                          in
770                            chkBlock (blk, uG, nW)                            next (chkBlock (blk, uG, nW))
771                          end                          end
772                      | T.S_IfThenElse(e, blk1, blk2) => let                      | T.S_IfThenElse(e, blk1, blk2) => let
773                          val (uG, nW) = chkExp (e, uG, nW)                          val (uG, nW) = chkExp (e, uG, nW)
774                          val (uG, nW) = chkBlock (blk1, uG, nW)                          val (uG, nW) = chkBlock (blk1, uG, nW)
775                          in                          in
776                            chkBlock (blk2, uG, nW)                            next (chkBlock (blk2, uG, nW))
777                          end                          end
778                      | T.S_For(_, e1, e2, blk) => let                      | T.S_For(_, e1, e2, blk) => let
779                          val (uG, nW) = chkExp (e1, uG, nW)                          val (uG, nW) = chkExp (e1, uG, nW)
780                          val (uG, nW) = chkExp (e2, uG, nW)                          val (uG, nW) = chkExp (e2, uG, nW)
781                          in                          in
782                            chkBlock (blk, uG, nW)                            next (chkBlock (blk, uG, nW))
783                          end                          end
784                      | T.S_Foreach(_, e, blk) => let                      | T.S_Foreach(_, e, blk) => let
785                          val (uG, nW) = chkExp (e, uG, nW)                          val (uG, nW) = chkExp (e, uG, nW)
786                          in                          in
787                            chkBlock (blk, uG, nW)                            next (chkBlock (blk, uG, nW))
788                          end                          end
789                      | T.S_LoadNrrd _ => raise Fail "unexpected LoadNrrd"                      | T.S_LoadNrrd _ => raise Fail "unexpected LoadNrrd"
790                      | T.S_Input _ => raise Fail "unexpected Input"                      | T.S_Input _ => raise Fail "unexpected Input"
# Line 760  Line 802 
802                  in                  in
803                    chkExps (es, uG, nW)                    chkExps (es, uG, nW)
804                  end                  end
805            and chkExp (T.E_Global _, uG, nW) = (true, nW)            and chkExp (T.E_Global gv, _, nW) = (true, nW)
806              | chkExp (T.E_State(SOME e, _), uG, nW) =              | chkExp (T.E_State(SOME e, _), uG, nW) = chkExp (e, uG, nW)
                 chkExp (e, uG, nW)  
807              | chkExp (T.E_Op(TOp.SphereQuery _, es), uG, nW) = chkExps (es, uG, true)              | chkExp (T.E_Op(TOp.SphereQuery _, es), uG, nW) = chkExps (es, uG, true)
808              | chkExp (T.E_Op(_, es), uG, nW) = chkExps (es, uG, nW)              | chkExp (T.E_Op(_, es), uG, nW) = chkExps (es, uG, nW)
809              | chkExp (T.E_Vec(_, _, es), uG, nW) = chkExps (es, uG, nW)              | chkExp (T.E_Vec(_, _, es), uG, nW) = chkExps (es, uG, nW)
# Line 805  Line 846 
846          (* first step is to flatten any nested CONS nodes *)          (* first step is to flatten any nested CONS nodes *)
847            val prog = Flatten.transform prog            val prog = Flatten.transform prog
848            val LowIR.Program{            val LowIR.Program{
849                    props, consts, inputs, constInit, globals, globalInit, strand, create, update                    props, consts, inputs, constInit, globals,
850                      globInit, strand, create, init, update
851                  } = prog                  } = prog
852            val trCFG = trCFG info            val trCFG = trCFG info
853            in            in
# Line 816  Line 858 
858                  inputs = List.map (Inputs.map mkGlobalVar) inputs,                  inputs = List.map (Inputs.map mkGlobalVar) inputs,
859                  constInit = trCFG constInit,                  constInit = trCFG constInit,
860                  globals = List.map mkGlobalVar globals,                  globals = List.map mkGlobalVar globals,
861                  globalInit = trCFG globalInit,                  globInit = trCFG globInit,
862                  strand = trStrand info strand,                  strand = trStrand info strand,
863                  create = let                  create = let
864                    val IR.Create{dim, code} = create                    val IR.Create{dim, code} = create
865                    in                    in
866                      T.Create{dim = dim, code = trCFG code}                      T.Create{dim = dim, code = trCFG code}
867                    end,                    end,
868                    init = Option.map trCFG init,
869                  update = Option.map trCFG update                  update = Option.map trCFG update
870                }                }
871            end            end

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

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