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 3842, Tue May 10 14:25:30 2016 UTC revision 3843, Tue May 10 15:10:58 2016 UTC
# Line 8  Line 8 
8    
9  structure LowToTree : sig  structure LowToTree : sig
10    
11      val translate : LowIR.program * TreeTypes.vec_layout -> TreeIR.program      val translate : LowIR.program * (int -> TreeTypes.vec_layout) -> TreeIR.program
12    
13    end = struct    end = struct
14    
# Line 25  Line 25 
25      structure TGV = TreeGlobalVar      structure TGV = TreeGlobalVar
26      structure TSV = TreeStateVar      structure TSV = TreeStateVar
27    
   (* translate a type for an in-memory type (i.e., the type of a global or state variable) *)  
     fun trMemoryTy ty = (case ty  
            of Ty.BoolTy => TTy.BoolTy  
             | Ty.IntTy => TTy.IntTy  
             | Ty.StringTy => TTy.StringTy  
             | Ty.TensorTy dd => TTy.TensorTy dd  
             | Ty.TupleTy tys => TTy.TupleTy(List.map trMemoryTy tys)  
             | Ty.SeqTy(ty, dim) => TTy.SeqTy(trMemoryTy ty, dim)  
             | Ty.ImageTy info => TTy.ImageTy info  
           (* end case *))  
   
28    (* associate Tree IL globals variables with Low IL variables using properties *)    (* associate Tree IL globals variables with Low IL variables using properties *)
29      local      local
30        val {setFn, peekFn, ...} =        val {setFn, peekFn, ...} =
# Line 45  Line 34 
34               of NONE => let               of NONE => let
35                      val x' = TGV.new {                      val x' = TGV.new {
36                              name = GV.name x,                              name = GV.name x,
37                              ty = trMemoryTy (GV.ty x),                              ty = Util.trType (GV.ty x),
38                              input = GV.isInput x,                              input = GV.isInput x,
39                              output = false, (* FIXME: change once we support output globals *)                              output = false, (* FIXME: change once we support output globals *)
40                              varying = ??,                              varying = GV.isVarying x,
41                              apiTy = ??                              apiTy = if GV.isInput x
42                                  then SOME(Util.toAPIType (GV.ty x))
43                                  else NONE
44                            }                            }
45                      in                      in
46                        setFn (x, x');                        setFn (x, x');
# Line 63  Line 54 
54      local      local
55        fun mkStateVar x = TSV.new {        fun mkStateVar x = TSV.new {
56                name = SV.name x,                name = SV.name x,
57                ty = trMemoryTy (SV.ty x),                ty = Util.trType (SV.ty x),
58                varying = VA.isVarying x,                varying = SV.isVarying x,
59                apiTy = ??                apiTy = if (SV.isOutput x)
60                    then SOME(Util.toAPIType (SV.ty x))
61                    else NONE
62              }              }
63      in      in
64      val {getFn = getStateVar, ...} = SV.newProp mkStateVar      val {getFn = getStateVar, ...} = SV.newProp mkStateVar
# Line 81  Line 74 
74        | cvtScalarTy ty = raise Fail(concat["cvtScalarTy(", Ty.toString ty, ")"])        | cvtScalarTy ty = raise Fail(concat["cvtScalarTy(", Ty.toString ty, ")"])
75    
76      fun vectorArg (env, x) = (case Env.useVar env x      fun vectorArg (env, x) = (case Env.useVar env x
77             of Env.TREE(ty, e) => ?? (* need to unpack e *)             of Env.TREE e => (case IR.Var.ty x
78                     of Ty.TensorTy[d] => let
79                          val layout = Env.layoutVec env d
80    (* QUESTION: can "e" be a complicated expression or are we guaranteed that it will just
81     * be a memory reference?
82     *)
83                          val es = List.tabulate (
84                                List.length(#pieces layout),
85                                fn i => T.E_VLoad(layout, e, i))
86                          in
87                            (layout, es)
88                          end
89                      | ty => raise Fail("expected TensorTy[_], but found " ^ Ty.toString ty)
90                    (* end case *))
91              | Env.VEC(layout, es) => (layout, es)              | Env.VEC(layout, es) => (layout, es)
92            (* end case *))            (* end case *))
93    
# Line 96  Line 102 
102                  in                  in
103                    ListPair.mapEq (op ::) (exps, argLists)                    ListPair.mapEq (op ::) (exps, argLists)
104                  end                  end
105            val argLists = List.foldl doArg exps xs            val argLists = List.foldl doArg [exps] xs
106            in            in
107              (layout, List.map List.rev argLists)              (layout, List.map List.rev argLists)
108            end            end
109    
110      fun trOp (env, lhs, srcRator, args) = let      fun trOp (env, lhs, srcRator, args) = let
111            fun bindOp rator = Env.TREE(T.E_Op(rator, List.map (Env.useVar env) args))            fun bindOp rator = let
112                    fun getBinding x = (case Env.useVar env x
113                           of Env.TREE e => e
114                            | _ => raise Fail("expected single binding for " ^ IR.Var.toString x)
115                          (* end case *))
116                    in
117                      Env.TREE(T.E_Op(rator, List.map getBinding args))
118                    end
119            fun bindVOp rator = let            fun bindVOp rator = let
120                  val (layout, argss) = vectorArgs (env, args)                  val (layout, argss) = vectorArgs (env, args)
121                  val exps = ListPair.map                  val exps = ListPair.map
# Line 119  Line 132 
132                | Op.IDiv => bindOp TOp.IDiv                | Op.IDiv => bindOp TOp.IDiv
133                | Op.IMod => bindOp TOp.IMod                | Op.IMod => bindOp TOp.IMod
134                | Op.INeg => bindOp TOp.INeg                | Op.INeg => bindOp TOp.INeg
135    (* QUESTION: should we just use VAdd 1, etc ?*)
136                | Op.RAdd => bindOp TOp.RAdd                | Op.RAdd => bindOp TOp.RAdd
137                | Op.RSub => bindOp TOp.RSub                | Op.RSub => bindOp TOp.RSub
138                | Op.RMul => bindOp TOp.RMul                | Op.RMul => bindOp TOp.RMul
# Line 142  Line 156 
156                | Op.VMul _ => bindVOp TOp.VMul                | Op.VMul _ => bindVOp TOp.VMul
157                | Op.VNeg _ => bindVOp TOp.VNeg                | Op.VNeg _ => bindVOp TOp.VNeg
158                | Op.VSum _ => ??                | Op.VSum _ => ??
159                | Op.VProj(d, i) => ??                | Op.VIndex(d, i) => ??
160                | Op.VClamp n => bindVOp TOp.VClamp                | Op.VClamp n => bindVOp TOp.VClamp
161                | Op.VMapClamp n => bindVOp TOp.VMapClamp                | Op.VMapClamp n => bindVOp TOp.VMapClamp
162                | Op.VLerp n => bindVOp TOp.VLerp                | Op.VLerp n => bindVOp TOp.VLerp
# Line 378  Line 392 
392                        (* end case *))                        (* end case *))
393                  (* end case *))                  (* end case *))
394            in            in
395              doNode (Env.new(), CFG.entry cfg, [], [])              doNode (env, CFG.entry cfg, [], [])
396            end            end
397    
398      fun trCFG (prefix, cfg) = trCFGWithEnv (Env.new(), prefix, cfg)      fun trCFG vecLayout (prefix, cfg) = trCFGWithEnv (Env.new vecLayout, prefix, cfg)
399    
400      fun trStrand strand = let      fun trStrand strand = let
401            val IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM} = strand            val IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM} = strand

Legend:
Removed from v.3842  
changed lines
  Added in v.3843

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