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

# SCM Repository

[diderot] Diff of /branches/vis12/src/compiler/simplify/simplify.sml
 [diderot] / branches / vis12 / src / compiler / simplify / simplify.sml

# Diff of /branches/vis12/src/compiler/simplify/simplify.sml

trunk/src/compiler/simplify/simplify.sml revision 511, Tue Feb 8 17:01:43 2011 UTC branches/vis12/src/compiler/simplify/simplify.sml revision 2014, Mon Oct 8 14:58:19 2012 UTC
# Line 8  Line 8
8
9  structure Simplify : sig  structure Simplify : sig
10
11      val transform : AST.program -> Simple.program      val transform : Error.err_stream * AST.program -> Simple.program
12
13    end = struct    end = struct
14
15      structure Ty = Types      structure Ty = Types
16      structure S = Simple      structure S = Simple
17        structure InP = Inputs
18
19      local      local
20        val tempName = Atom.atom "_t"        val tempName = Atom.atom "_t"
# Line 24  Line 25
25    (* make a block out of a list of statements that are in reverse order *)    (* make a block out of a list of statements that are in reverse order *)
26      fun mkBlock stms = S.Block(List.rev stms)      fun mkBlock stms = S.Block(List.rev stms)
27
28      (* convert an AST expression to an input initialization.  Note that the Diderot grammar
29       * limits the forms of expression that we might encounter in this context.
30       *)
31        fun expToInit exp = (case exp
32               of AST.E_Lit(Literal.Int n) => InP.Int n
33                | AST.E_Lit(Literal.Float f) => InP.Real f
34                | AST.E_Lit(Literal.String s) => InP.String s
35                | AST.E_Lit(Literal.Bool b) => InP.Bool b
36                | AST.E_Tuple es => raise Fail "E_Tuple not yet implemented"
37    (*
38                | AST.E_Cons es => let
39                    fun toReal (AST.E_Lit(Literal.Int n)) = FloatLit.fromInt n
40                      | toReal (AST.E_Lit(Literal.Float f)) = f
41                      | toReal (AST.E_Coerce{e, ...}) = toReal e
42                      | toReal _ = raise Fail "impossible"
43                    fun toTensor [e] = ??
44                      | toTensor (es as e1::_) = (case e1
45                           of AST.E_Cons _ => let
46                                val (shp, vs) = ??
47                                in
48                                  (List.length es :: shp, List.concat vs)
49                                end
50                            | _ => ([List.length es], List.map toReal (e1::es))
51                          (* end case *))
52                    in
53                      InP.Tensor(shp, Vector.fromList vs)
54                    end
55                | AST.E_Seq es => ??
56                | AST.E_Coerce{srcTy, dstTy, e} => ??
57    *)
58                | _ => raise Fail "impossible initialization expression"
59              (* end case *))
60
61        fun inputImage (nrrd, dim, shape) = let
62              val dim = TypeUtil.monoDim dim
63              val shp = TypeUtil.monoShape shape
64              in
65                case ImageInfo.fromNrrd(NrrdInfo.getInfo nrrd, dim, shp)
66                 of NONE => raise Fail(concat["nrrd file \"", nrrd, "\" does not have expected type"])
67                  | SOME info => InP.Proxy(nrrd, info)
68                (* end case *)
69              end
70
71      fun simplifyProgram (AST.Program dcls) = let      fun simplifyProgram (AST.Program dcls) = let
72              val inputs = ref []
73            val globals = ref []            val globals = ref []
74            val globalInit = ref []            val globalInit = ref []
75              val initially = ref NONE
76            val strands = ref []            val strands = ref []
77              fun setInitially init = (case !initially
78                     of NONE => initially := SOME init
79    (* FIXME: the check for multiple initially decls should happen in type checking *)
80                      | SOME _ => raise Fail "multiple initially declarations"
81                    (* end case *))
82            fun simplifyDecl dcl = (case dcl            fun simplifyDecl dcl = (case dcl
83                   of AST.D_Input(x, NONE) => let                   of AST.D_Input(x, desc, NONE) => let
84                        val e' = S.E_Input(Var.monoTypeOf x, Var.nameOf x, NONE)                        val (ty, init) = (case Var.monoTypeOf x
85                                 of ty as Ty.T_Image{dim, shape} => let
86                                      val info = ImageInfo.mkInfo(TypeUtil.monoDim dim, TypeUtil.monoShape shape)
87                        in                        in
88                          globals := x :: !globals;                                      (ty, SOME(InP.Image info))
globalInit := S.S_Assign(x, e') :: !globalInit
89                        end                        end
90                    | AST.D_Input(x, SOME e) => let                                | ty => (ty, NONE)
91                        val (stms, x') = simplifyExpToVar (e, [])                              (* end case *))
92                        val e' = S.E_Input(Var.monoTypeOf x, Var.nameOf x, SOME x')                        val inp = InP.INP{
93                                  ty = ty,
94                                  name = Var.nameOf x,
95                                  desc = desc,
96                                  init = init
97                                }
98                        in                        in
99                          globals := x :: !globals;                          inputs := (x, inp) :: !inputs
100                          globalInit := S.S_Assign(x, e') :: (stms @ !globalInit)                        end
101                      | AST.D_Input(x, desc, SOME(AST.E_LoadNrrd(tvs, nrrd, ty))) => let
102                        (* load the nrrd proxy here *)
103                          val info = NrrdInfo.getInfo nrrd
104                          val (ty, init) = (case Var.monoTypeOf x
105                                 of ty as Ty.T_DynSequence _ => (ty, InP.DynSeq nrrd)
106                                  | ty as Ty.T_Image{dim, shape} => (ty, inputImage(nrrd, dim, shape))
107                                  | _ => raise Fail "impossible"
108                                (* end case *))
109                          val inp = InP.INP{
110                                  ty = ty,
111                                  name = Var.nameOf x,
112                                  desc = desc,
113                                  init = SOME init
114                                }
115                          in
116                            inputs := (x, inp) :: !inputs
117                          end
118                      | AST.D_Input(x, desc, SOME e) => let
119                          val inp = InP.INP{
120                                  ty = Var.monoTypeOf x,
121                                  name = Var.nameOf x,
122                                  desc = desc,
123                                  init = SOME(expToInit e)
124                                }
125                          in
126                            inputs := (x, inp) :: !inputs
127                        end                        end
128                    | AST.D_Var(AST.VD_Decl(x, e)) => let                    | AST.D_Var(AST.VD_Decl(x, e)) => let
129                        val (stms, e') = simplifyExp (e, [])                        val (stms, e') = simplifyExp (e, [])
# Line 49  Line 132
132                          globalInit := S.S_Assign(x, e') :: (stms @ !globalInit)                          globalInit := S.S_Assign(x, e') :: (stms @ !globalInit)
133                        end                        end
134                    | AST.D_Strand info => strands := simplifyStrand info :: !strands                    | AST.D_Strand info => strands := simplifyStrand info :: !strands
135                    | AST.D_InitialArray(e, iters) => () (* FIXME *)                    | AST.D_InitialArray(creat, iters) =>
136                    | AST.D_InitialCollection(e, iters) => () (* FIXME *)                        setInitially (simplifyInit(true, creat, iters))
137                      | AST.D_InitialCollection(creat, iters) =>
138                          setInitially (simplifyInit(false, creat, iters))
139                  (* end case *))                  (* end case *))
140            in            in
141              List.app simplifyDecl dcls;              List.app simplifyDecl dcls;
142              S.Program{              S.Program{
143                    inputs = List.rev(!inputs),
144                  globals = List.rev(!globals),                  globals = List.rev(!globals),
145                  globalInit = mkBlock (!globalInit),                  globalInit = mkBlock (!globalInit),
146                    init = (case !initially
147    (* FIXME: the check for the initially block should really happen in typechecking *)
148                       of NONE => raise Fail "missing initially declaration"
149                        | SOME blk => blk
150                      (* end case *)),
151                  strands = List.rev(!strands)                  strands = List.rev(!strands)
152                }                }
153            end            end
154
155        and simplifyInit (isArray, AST.C_Create(strand, exps), iters) = let
156              val (stms, xs) = simplifyExpsToVars (exps, [])
157              val creat = S.C_Create{
158                      argInit = mkBlock stms,
159                      name = strand,
160                      args = xs
161                    }
162              fun simplifyIter (AST.I_Range(x, e1, e2), (iters, stms)) = let
163                    val (stms, lo) = simplifyExpToVar (e1, stms)
164                    val (stms, hi) = simplifyExpToVar (e2, stms)
165                    in
166                      ({param=x, lo=lo, hi=hi}::iters, stms)
167                    end
168              val (iters, stms) = List.foldl simplifyIter ([], []) iters
169              in
170                S.Initially{
171                    isArray = isArray,
172                    rangeInit = mkBlock stms,
173                    iters = List.rev iters,
174                    create = creat
175                  }
176              end
177
178      and simplifyStrand {name, params, state, methods} = let      and simplifyStrand {name, params, state, methods} = let
179            fun simplifyState ([], xs, stms) = (List.rev xs, mkBlock stms)            fun simplifyState ([], xs, stms) = (List.rev xs, mkBlock stms)
180              | simplifyState (AST.VD_Decl(x, e) :: r, xs, stms) = let              | simplifyState (AST.VD_Decl(x, e) :: r, xs, stms) = let
# Line 81  Line 195
195      and simplifyMethod (AST.M_Method(name, body)) =      and simplifyMethod (AST.M_Method(name, body)) =
196            S.Method(name, simplifyBlock body)            S.Method(name, simplifyBlock body)
197
198    (* simplify a statement into a single statement (i.e., a block if it expands into more    (* simplify a statement into a single statement (i.e., a block if it expands
199     * than one new statement.     * into more than one new statement).
200     *)     *)
201      and simplifyBlock stm = mkBlock (simplifyStmt (stm, []))      and simplifyBlock stm = mkBlock (simplifyStmt (stm, []))
202
# Line 117  Line 231
231                  end                  end
232              | AST.S_Die => S.S_Die :: stms              | AST.S_Die => S.S_Die :: stms
233              | AST.S_Stabilize => S.S_Stabilize :: stms              | AST.S_Stabilize => S.S_Stabilize :: stms
234                | AST.S_Print args => let
235                    val (stms, xs) = simplifyExpsToVars (args, stms)
236                    in
237                      S.S_Print xs :: stms
238                    end
239            (* end case *))            (* end case *))
240
241      and simplifyExp (exp, stms) = (      and simplifyExp (exp, stms) = (
# Line 143  Line 262
262                  in                  in
263                    (stms, S.E_Cons xs)                    (stms, S.E_Cons xs)
264                  end                  end
265                | AST.E_Seq es => let
266                    val (stms, xs) = simplifyExpsToVars (es, stms)
267                    in
268                      (stms, S.E_Seq xs)
269                    end
270              | AST.E_Slice(e, indices, ty) => let (* tensor slicing *)              | AST.E_Slice(e, indices, ty) => let (* tensor slicing *)
271                  val (stms, x) = simplifyExpToVar (e, stms)                  val (stms, x) = simplifyExpToVar (e, stms)
272                  fun f ([], ys, stms) = (stms, List.rev ys)                  fun f ([], ys, stms) = (stms, List.rev ys)
# Line 159  Line 283
283              | AST.E_Cond(e1, e2, e3, ty) => let              | AST.E_Cond(e1, e2, e3, ty) => let
284                (* a conditional expression gets turned into an if-then-else statememt *)                (* a conditional expression gets turned into an if-then-else statememt *)
285                  val result = newTemp ty                  val result = newTemp ty
286                  val (stms, x) = simplifyExpToVar (e1, stms)                  val (stms, x) = simplifyExpToVar (e1, S.S_Var result :: stms)
287                  fun simplifyBranch e = let                  fun simplifyBranch e = let
288                        val (stms, e) = simplifyExp (e, [])                        val (stms, e) = simplifyExp (e, [])
289                        in                        in
# Line 170  Line 294
294                  in                  in
295                    (S.S_IfThenElse(x, s1, s2) :: stms, S.E_Var result)                    (S.S_IfThenElse(x, s1, s2) :: stms, S.E_Var result)
296                  end                  end
297                | AST.E_LoadNrrd _ => raise Fail "unexpected E_LoadNrrd" (* should be handled by simplifyDecl *)
298                | AST.E_Coerce{srcTy, dstTy, e} => let
299                    val (stms, x) = simplifyExpToVar (e, stms)
300                    val result = newTemp dstTy
301                    in
302                      (S.S_Assign(result, S.E_Coerce{srcTy=srcTy, dstTy=dstTy, x=x})::stms, S.E_Var result)
303                    end
304            (* end case *))            (* end case *))
305
306      and simplifyExpToVar (exp, stms) = let      and simplifyExpToVar (exp, stms) = let
# Line 196  Line 327
327              f (exps, [], stms)              f (exps, [], stms)
328            end            end
329
330      fun transform ast = let      fun transform (errStrm, ast) = let
331            val simple = simplifyProgram ast            val simple = simplifyProgram ast
332            val _ = SimplePP.output (Log.logFile(), simple)       (* DEBUG *)            val _ = SimplePP.output (Log.logFile(), simple)       (* DEBUG *)
333    (*
334            val simple = Lift.transform simple            val simple = Lift.transform simple
335                    handle Eval.Error msg => (Error.error(errStrm, msg); simple)
336    *)
337            in            in
338              simple              simple
339            end            end

Legend:
 Removed from v.511 changed lines Added in v.2014

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