Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/cxx-util/tree-to-cxx.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/cxx-util/tree-to-cxx.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3876, Wed May 18 17:25:47 2016 UTC revision 3886, Fri May 20 15:10:11 2016 UTC
# Line 11  Line 11 
11    
12  structure TreeToCxx : sig  structure TreeToCxx : sig
13    
14      val trType : TreeTypes.t -> CLang.ty      val trType : CodeGenEnv.t * TreeTypes.t -> CLang.ty
15    
16      val trBlock : CodeGenEnv.t * TreeIR.block -> CLang.stm      val trBlock : CodeGenEnv.t * TreeIR.block -> CLang.stm
17    
# Line 33  Line 33 
33      structure V = TreeVar      structure V = TreeVar
34      structure Env = CodeGenEnv      structure Env = CodeGenEnv
35    
36      datatype var = datatype CL.typed_var      fun trType (env, ty) = (case ty
37               of Ty.BoolTy => CL.boolTy
38                | Ty.StringTy => CL.T_Named "std::string"
39                | Ty.IntTy => Env.intTy env
40                | (Ty.VecTy(1, 1)) => Env.realTy env
41                | (Ty.VecTy(d, _)) => CL.T_Named("vec" ^ Int.toString d)
42                | (Ty.TensorTy dd) => CL.T_Array(Env.realTy env, SOME(List.foldl Int.* 1 dd))
43                | (Ty.SeqTy(t, NONE)) => CL.T_Template("diderot::dynseq", [trType(env, t)])
44                | (Ty.SeqTy(t, SOME n)) => CL.T_Array(trType(env, t), SOME n)
45                | (Ty.ImageTy info) =>
46                    CL.T_Template(
47                      concat["diderot::image", Int.toString(ImageInfo.dim info), "d"],
48                      [Env.realTy env])
49                | (Ty.StrandTy name) => CL.T_Named("strand_" ^ Atom.toString name)
50              (* end case *))
51    
52    (* translate a local variable that occurs in an l-value context *)    (* translate a local variable that occurs in an l-value context *)
53      fun lvalueVar (env, x) = CL.mkVar(Env.lookup(env, x))      fun lvalueVar (env, x) = CL.mkVar(Env.lookup(env, x))
# Line 77  Line 91 
91      fun mkDiderotCall (f, args) = CL.mkCall("diderot::" ^ f, args)      fun mkDiderotCall (f, args) = CL.mkCall("diderot::" ^ f, args)
92    
93    (* Translate a TreeIR operator application to a CLang expression *)    (* Translate a TreeIR operator application to a CLang expression *)
94      fun trOp (rator, args) = (case (rator, args)      fun trOp (env, rator, args) = (case (rator, args)
95             of (Op.IAdd, [a, b]) => CL.mkBinOp(a, CL.#+, b)             of (Op.IAdd, [a, b]) => CL.mkBinOp(a, CL.#+, b)
96              | (Op.ISub, [a, b]) => CL.mkBinOp(a, CL.#-, b)              | (Op.ISub, [a, b]) => CL.mkBinOp(a, CL.#-, b)
97              | (Op.IMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)              | (Op.IMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)
# Line 91  Line 105 
105              | (Op.RNeg, [a]) => CL.mkUnOp(CL.%-, a)              | (Op.RNeg, [a]) => CL.mkUnOp(CL.%-, a)
106              | (Op.RClamp, [a, b, c]) => CL.mkApply("clamp", [a, b, c])              | (Op.RClamp, [a, b, c]) => CL.mkApply("clamp", [a, b, c])
107              | (Op.RLerp, [a, b, c]) => CL.mkApply("lerp", [a, b, c])              | (Op.RLerp, [a, b, c]) => CL.mkApply("lerp", [a, b, c])
108                | (Op.RCeiling, [a]) => mkStdApply("ceil", [a])
109                | (Op.RFloor, [a]) => mkStdApply("floor", [a])
110                | (Op.RRound, [a]) => mkStdApply("round", [a])
111                | (Op.RTrunc, [a]) => mkStdApply("trunc", [a])
112                | (Op.RealToInt, [a]) => mkStdApply("lround", [a])
113              | (Op.LT ty, [a, b]) => CL.mkBinOp(a, CL.#<, b)              | (Op.LT ty, [a, b]) => CL.mkBinOp(a, CL.#<, b)
114              | (Op.LTE ty, [a, b]) => CL.mkBinOp(a, CL.#<=, b)              | (Op.LTE ty, [a, b]) => CL.mkBinOp(a, CL.#<=, b)
115              | (Op.EQ ty, [a, b]) => CL.mkBinOp(a, CL.#==, b)              | (Op.EQ ty, [a, b]) => CL.mkBinOp(a, CL.#==, b)
# Line 107  Line 126 
126              | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)              | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)
127              | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)              | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)
128              | (Op.VSum d, [a]) => CL.mkApply("vsum", [a])              | (Op.VSum d, [a]) => CL.mkApply("vsum", [a])
129              | (Op.VIndex(d, i), [a]) => CL.mkSubscript(a, intExp i)              | (Op.VIndex(w, p, i), [a]) => CL.mkSubscript(a, intExp i)
130              | (Op.VClamp d, [a, b, c]) => CL.mkApply("clamp", [a, b, c])              | (Op.VClamp d, [a, b, c]) => CL.mkApply("vclamp", [a, b, c])
131              | (Op.VMapClamp d, [a, b, c]) => CL.mkApply("clamp", [a, b, c])              | (Op.VMapClamp d, [a, b, c]) => CL.mkApply("vclamp", [a, b, c])
132              | (Op.VLerp d, [a, b, c]) => CL.mkApply("lerp", [a, b, c])              | (Op.VLerp d, [a, b, c]) => CL.mkApply("vlerp", [a, b, c])
133              | (Op.TensorIndex(ty, idxs), [a]) => ??              | (Op.VCeiling d, [a]) => CL.mkApply("vceiling", [a])
134              | (Op.ProjectLast(ty, idxs), [a]) => ??              | (Op.VFloor d, [a]) => CL.mkApply("vfloor", [a])
135              | (Op.EigenVals2x2, [a]) => ??              | (Op.VRound d, [a]) => CL.mkApply("vround", [a])
136              | (Op.EigenVals3x3, [a]) => ??              | (Op.VTrunc d, [a]) => CL.mkApply("vtrunc", [a])
137              | (Op.Zero ty, []) => ??              | (Op.VToInt d, [a]) => CL.mkApply("vtoi", [a])
138              | (Op.Select(ty, i), [a]) => ??              | (Op.TensorIndex(Ty.TensorTy(_::dd), idxs), [a]) => let
139              | (Op.Subscript ty, [a, b]) => ??                (* dimensions/indices are slowest to fastest *)
140              | (Op.MkDynamic(ty, i), [a]) => ??                  fun index ([], [i], acc) = acc + i
141              | (Op.Append ty, [a, b]) => ??                    | index (d::dd, i::ii, acc) = index (dd, ii, d * (acc + i))
142              | (Op.Prepend ty, [a, b]) => ??                  in
143              | (Op.Concat ty, [a, b]) => ??                    CL.mkSubscript(a, intExp(index (dd, idxs, 0)))
144              | (Op.Range, [a, b]) => ??                  end
145              | (Op.Length ty, [a]) => ??              | (Op.ProjectLast(Ty.TensorTy(_::dd), idxs), [a]) => let
146              | (Op.SphereQuery(ty1, ty2), []) => ??                (* dimensions/indices are slowest to fastest *)
147                    fun index ([], [], acc) = acc
148                      | index (d::dd, i::ii, acc) = index (dd, ii, d * (acc + i))
149                    in
150                      CL.mkAddrOf(CL.mkSubscript(a, intExp(index (dd, idxs, 0))))
151                    end
152                | (Op.EigenVals2x2, [a]) => raise Fail "FIXME: EigenVals2x2"
153                | (Op.EigenVals3x3, [a]) => raise Fail "FIXME: EigenVals3x3"
154                | (Op.Select(ty, i), [a]) => raise Fail "FIXME: Select"
155                | (Op.Subscript ty, [a, b]) => CL.mkSubscript(a, b)
156                | (Op.MkDynamic(ty, i), [a]) => raise Fail "FIXME: MkDynamic"
157                | (Op.Append ty, [a, b]) => raise Fail "FIXME: Append"
158                | (Op.Prepend ty, [a, b]) => raise Fail "FIXME: Prepend"
159                | (Op.Concat ty, [a, b]) => raise Fail "FIXME: Concat"
160                | (Op.Range, [a, b]) => raise Fail "FIXME: Range"
161                | (Op.Length ty, [a]) => raise Fail "FIXME: Length"
162                | (Op.SphereQuery(ty1, ty2), []) => raise Fail "FIXME: SphereQuery"
163              | (Op.Sqrt, [a]) => mkStdApply("sqrt", [a])              | (Op.Sqrt, [a]) => mkStdApply("sqrt", [a])
164              | (Op.Cos, [a]) => mkStdApply("cos", [a])              | (Op.Cos, [a]) => mkStdApply("cos", [a])
165              | (Op.ArcCos, [a]) => mkStdApply("acos", [a])              | (Op.ArcCos, [a]) => mkStdApply("acos", [a])
# Line 133  Line 168 
168              | (Op.Tan, [a]) => mkStdApply("tan", [a])              | (Op.Tan, [a]) => mkStdApply("tan", [a])
169              | (Op.ArcTan, [a]) => mkStdApply("atan", [a])              | (Op.ArcTan, [a]) => mkStdApply("atan", [a])
170              | (Op.Exp, [a]) => mkStdApply("exp", [a])              | (Op.Exp, [a]) => mkStdApply("exp", [a])
171              | (Op.Ceiling 1, [a]) => mkStdApply("ceil", [a])              | (Op.IntToReal, [a]) => CL.mkStaticCast(Env.realTy env, a)
             | (Op.Ceiling d, [a]) => ??  
             | (Op.Floor 1, [a]) => mkStdApply("floor", [a])  
             | (Op.Floor d, [a]) => ??  
             | (Op.Round 1, [a]) => mkStdApply("round", [a])  
             | (Op.Round d, [a]) => ??  
             | (Op.Trunc 1, [a]) => mkStdApply("trunc", [a])  
             | (Op.Trunc d, [a]) => ??  
             | (Op.IntToReal, [a]) => ??  
             | (Op.RealToInt 1, [a]) => ??  
             | (Op.RealToInt d, [a]) => ??  
172  (*  (*
173              | R_All of ty              | R_All of ty
174              | R_Exists of ty              | R_Exists of ty
# Line 154  Line 179 
179              | R_Mean of ty              | R_Mean of ty
180              | R_Variance of ty              | R_Variance of ty
181  *)  *)
182              | (Op.Transform info, [img]) => ??              | (Op.Transform info, [img]) => CL.mkDispatch(img, "world2image", [])
183              | (Op.Translate info, [img]) => ??              | (Op.Translate info, [img]) => CL.mkDispatch(img, "translate", [])
184              | (Op.BaseAddress info, [img]) => ??              | (Op.BaseAddress info, [img]) => CL.mkDispatch(img, "base_addr", [])
185              | (Op.ControlIndex(info, ctl, i), [a]) => ??              | (Op.ControlIndex(info, ctl, d), [img, idx]) =>
186              | (Op.Inside(info, i), [pos, img]) => ??                  CL.mkDispatch(img, IndexCtl.toString ctl, [intExp d, idx])
187              | (Op.ImageDim(info, i), [img]) => ??              | (Op.Inside(info, s), [pos, img]) => CL.mkDispatch(img, "inside", [pos, intExp s])
188              | (Op.LoadSeq(ty, file), []) => ??              | (Op.ImageDim(info, i), [img]) => CL.mkDispatch(img, "size", [intExp i])
             | (Op.LoadImage(ty, file), []) => ??  
189              | (Op.MathFn f, args) => mkStdApply(MathFns.toString f, args)              | (Op.MathFn f, args) => mkStdApply(MathFns.toString f, args)
190              | _ => raise Fail(concat[              | _ => raise Fail(concat[
191                     "unknown or incorrect operator ", Op.toString rator                     "unknown or incorrect operator ", Op.toString rator
# Line 177  Line 201 
201              | IR.E_Lit(Literal.Bool b) => CL.mkBool b              | IR.E_Lit(Literal.Bool b) => CL.mkBool b
202              | IR.E_Lit(Literal.Real f) => CL.mkFlt(f, Env.realTy env)              | IR.E_Lit(Literal.Real f) => CL.mkFlt(f, Env.realTy env)
203              | IR.E_Lit(Literal.String s) => CL.mkStr s              | IR.E_Lit(Literal.String s) => CL.mkStr s
204              | IR.E_Op(rator, args) => trOp (rator, trExps(env, args))              | IR.E_Op(rator, args) => trOp (env, rator, trExps(env, args))
205              | IR.E_Vec(d, args) => ??              | IR.E_Vec(d, args) => ??
206              | IR.E_Cons(args, Ty.TensorTy shape) => ??              | IR.E_Cons(args, Ty.TensorTy shape) => ??
207              | IR.E_Seq(args, ty) => ??              | IR.E_Seq(args, ty) => ??
# Line 233  Line 257 
257                          (env, stm::stms)                          (env, stm::stms)
258                        end                        end
259                    | IR.S_MAssign(xs, exp) =>                    | IR.S_MAssign(xs, exp) =>
260                        (env, trMultiAssign (env, List.map (fn x => lvalueVar (env, x)) xs, exp) @ stms)                        (env, trMultiAssign (env, List.map (fn x => lvalueVar (env, x)) xs, exp) :: stms)
261                    | IR.S_GAssign(x, exp) =>                    | IR.S_GAssign(x, exp) =>
262                        (env, trAssign (env, lvalueGlobalVar (env, x), exp) :: stms)                        (env, trAssign (env, lvalueGlobalVar (env, x), exp) :: stms)
263                    | IR.S_IfThen(cond, thenBlk) =>                    | IR.S_IfThen(cond, thenBlk) =>
# Line 251  Line 275 
275                        val loop = CL.mkFor(                        val loop = CL.mkFor(
276                              [(CL.int32, x', lo')],                              [(CL.int32, x', lo')],
277                              CL.mkBinOp(CL.mkVar x', CL.#<=, hi'),                              CL.mkBinOp(CL.mkVar x', CL.#<=, hi'),
278                              CL.mkUnOp(CL.%++, CL.mkVar x'),                              [CL.mkUnOp(CL.%++, CL.mkVar x')],
279                              trBlock (env', blk))                              trBlock (env', blk))
280                        in                        in
281                          (env, loop :: stms)                          (env, loop :: stms)
# Line 259  Line 283 
283                    | IR.S_Foreach(x, e, blk) => ??                    | IR.S_Foreach(x, e, blk) => ??
284                    | IR.S_New(strand, args) => ??                    | IR.S_New(strand, args) => ??
285                    | IR.S_Save(x, exp) => trAssign (env, lvalueStateVar(env, x), exp)                    | IR.S_Save(x, exp) => trAssign (env, lvalueStateVar(env, x), exp)
286                    | IR.S_LoadNrrd(lhs, Ty.SeqTy(ty, NONE), nrrd) =>                    | IR.S_LoadNrrd(lhs, nrrd) => let
287                        (env, GenLoadNrrd.loadSeqFromFile (lvalueVar (env, lhs), ty, CL.mkStr nrrd) :: stms)                        val stm = (case V.ty lhs
288                    | IR.S_LoadNrrd(lhs, Ty.ImageTy info, nrrd) =>                               of Ty.SeqTy(ty, NONE) =>
289                        (env, GenLoadNrrd.loadImage (lvalueVar (env, lhs), info, CL.mkStr nrrd) :: stms)                                    GenLoadNrrd.loadSeqFromFile (lvalueVar (env, lhs), ty, CL.mkStr nrrd)
290                                  | Ty.ImageTy info =>
291                                      GenLoadNrrd.loadImage (lvalueVar (env, lhs), info, CL.mkStr nrrd)
292                                (* end case *))
293                          in
294                            (env, stm :: stms)
295                          end
296                    | IR.S_Input(_, _, _, NONE) => (env, stms)                    | IR.S_Input(_, _, _, NONE) => (env, stms)
297                    | IR.S_Input(gv, name, _, SOME dflt) =>                    | IR.S_Input(gv, name, _, SOME dflt) =>
298                        (env, CL.mkAssign(lvalueGlobalVar (env, gv), trExp(env, dflt)) :: stms)                        (env, CL.mkAssign(lvalueGlobalVar (env, gv), trExp(env, dflt)) :: stms)
# Line 287  Line 317 
317      and trBlock (env, IR.Block{locals, body}) = let      and trBlock (env, IR.Block{locals, body}) = let
318            fun trLocal (x, (env, dcls)) = let            fun trLocal (x, (env, dcls)) = let
319                  val x' = V.name x                  val x' = V.name x
320                    val dcl = CL.mkDecl(trType(env, V.ty x), x', NONE)
321                  in                  in
322                    (Env.insert(env, x, x'), CL.mkDecl(ty, x', NONE) :: dcls)                    (Env.insert(env, x, x'), dcl :: dcls)
323                  end                  end
324            val (env, dcls) = List.foldl trLocal (env, []) (!locals)            val (env, dcls) = List.foldl trLocal (env, []) (!locals)
325            in            in

Legend:
Removed from v.3876  
changed lines
  Added in v.3886

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