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

SCM Repository

[diderot] Diff of /trunk/src/compiler/simplify/eval.sml
ViewVC logotype

Diff of /trunk/src/compiler/simplify/eval.sml

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

revision 234, Thu Aug 5 21:34:29 2010 UTC revision 511, Tue Feb 8 17:01:43 2011 UTC
# Line 1  Line 1 
1  (* eval.sml  (* eval.sml
2   *   *
3   * COPYRIGHT (c) 2010 The Diderot Project (http://diderot.cs.uchicago.edu)   * COPYRIGHT (c) 2010 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4   * All rights reserved.   * All rights reserved.
5   *   *
6   * Evaluation of "static" expressions.   * Evaluation of "static" expressions.
7   *)   *)
8    
9  structure Eval =  structure Eval : sig
10    struct  
11        datatype value
12          = BV of bool
13          | SV of string
14          | IV of IntInf.int
15          | TV of (int list * real list)    (* tensors *)
16          | FV of FieldDef.field_def
17          | Img of ImageInfo.info
18          | KV of Kernel.kernel
19    
20        val evalStatics : Var.Set.set * Simple.block -> value Var.Map.map
21    
22      end = struct
23    
24      structure Ty = Types      structure Ty = Types
25      structure BV = BasisVars      structure BV = BasisVars
26      structure S = Simple      structure S = Simple
27      structure VMap = Var.Map      structure VMap = Var.Map
28        structure VSet = Var.Set
29      structure VTbl = Var.Tbl      structure VTbl = Var.Tbl
30    
31      datatype value      datatype value
# Line 40  Line 53 
53            fun tensorBinOp rator [TV(s1, v1), TV(s2, v2)] =            fun tensorBinOp rator [TV(s1, v1), TV(s2, v2)] =
54                  TV(s1, ListPair.mapEq rator (v1, v2))                  TV(s1, ListPair.mapEq rator (v1, v2))
55            fun realBinOp rator [TV([], [a]), TV([], [b])] = RV(rator(a, b))            fun realBinOp rator [TV([], [a]), TV([], [b])] = RV(rator(a, b))
56              fun realUnOp rator [TV([], [a])] = RV(rator a)
57            fun intCmp rator [IV a, IV b] = BV(rator(a, b))            fun intCmp rator [IV a, IV b] = BV(rator(a, b))
58            fun realCmp rator [TV([], [a]), TV([], [b])] = BV(rator(a, b))            fun realCmp rator [TV([], [a]), TV([], [b])] = BV(rator(a, b))
59            fun boolCmp rator [BV a, BV b] = BV(rator(a, b))            fun boolCmp rator [BV a, BV b] = BV(rator(a, b))
# Line 78  Line 92 
92                  (BV.neq_ii,             intCmp (op <>)),                  (BV.neq_ii,             intCmp (op <>)),
93                  (BV.neq_ss,             stringCmp (op <>)),                  (BV.neq_ss,             stringCmp (op <>)),
94                  (BV.neq_rr,             realCmp Real.!=),                  (BV.neq_rr,             realCmp Real.!=),
95                    (BV.neg_i,              fn [IV i] => IV(~i)),
96  (*  (*
                 (BV.neg_i,              simpleOp(Op.Neg Op.IntTy)),  
97                  (BV.neg_t,              tensorOp Op.Neg),                  (BV.neg_t,              tensorOp Op.Neg),
98                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),  *)
99                    (BV.neg_f,              fn [FV fld] => FV(FieldDef.neg fld)),
100    (*
101                  (BV.op_at,              fn (y, _, xs) => assign(y, Op.Probe, xs)),                  (BV.op_at,              fn (y, _, xs) => assign(y, Op.Probe, xs)),
102                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),  *)
103                  (BV.op_norm,            tensorOp Op.Norm),                  (BV.op_D,               fn [FV fld] => FV(FieldDef.diff fld)),
                 (BV.op_not,             simpleOp Op.Not),  
104  (*  (*
105                  (BV.op_subscript,       fn (y, [SK, NK], xs) => ??), (*FIXME*)                  (BV.op_norm,            tensorOp Op.Norm),
106  *)  *)
107                    (BV.op_not,             fn [BV b] => BV(not b)),
108    (*
109                  (BV.fn_CL,              fn (y, _, xs) => assign(y, Op.CL, xs)),                  (BV.fn_CL,              fn (y, _, xs) => assign(y, Op.CL, xs)),
110                  (BV.fn_convolve,        fn (y, _, xs) => assign(y, Op.Convolve, xs)),  *)
111                  (BV.fn_cos,             simpleOp Op.Cos),                  (BV.op_convolve,        fn [Img info, KV h] => FV(FieldDef.CONV(0, info, h))),
112                    (BV.fn_convolve,        fn [KV h, Img info] => FV(FieldDef.CONV(0, info, h))),
113                    (BV.fn_cos,             realUnOp Math.cos),
114    (*
115                  (BV.fn_dot,             vectorOp Op.Dot),                  (BV.fn_dot,             vectorOp Op.Dot),
116                  (BV.fn_inside,          fn (y, _, xs) => assign(y, Op.Inside, xs)),                  (BV.fn_inside,          fn (y, _, xs) => assign(y, Op.Inside, xs)),
117  *)  *)
# Line 101  Line 121 
121                  (BV.fn_pow,             realBinOp Real.Math.pow),                  (BV.fn_pow,             realBinOp Real.Math.pow),
122  (*  (*
123                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
                 (BV.fn_sin,             simpleOp Op.Sin),  
124  *)  *)
125                    (BV.fn_sin,             realUnOp Math.sin),
126                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
127                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
128                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
129                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
130                  (BV.i2r,                fn [IV i] => RV(real(IntInf.toInt i)))(*,                  (BV.i2r,                fn [IV i] => RV(real(IntInf.toInt i)))
                 (BV.input,              fn (y, [TK], xs) => ??), (*FIXME*)  
                 (BV.optInput,           fn (y, [TK], xs) => ??) (*FIXME*)  
 *)  
131                ];                ];
132              tbl              tbl
133            end            end
134    
135      fun loadImage (mvs, [SV filename]) = let      fun loadImage ([Ty.DIM dim, Ty.SHAPE shp], [SV filename]) = let
136            val info = ImageInfo.getInfo filename            val Ty.DimConst d = TypeUtil.resolveDim dim
137              val Ty.Shape dd = TypeUtil.resolveShape shp
138              val info as ImageInfo.ImgInfo{dim, ...} = ImageInfo.getInfo filename
139            in            in
140  (* FIXME: check image info details against mvs *)            (* check that the expected dimension and actual dimension match *)
141                if (d <> dim)
142                  then raise Fail(concat["image file \"", filename, "\" has wrong dimension"])
143                  else ();
144              (* check that the expected shape and actual shape match *)
145    (* FIXME *)
146              Img info              Img info
147            end            end
148    
# Line 127  Line 151 
151              | NONE => raise Fail("undefined variable " ^ Var.uniqueNameOf x)              | NONE => raise Fail("undefined variable " ^ Var.uniqueNameOf x)
152            (* end case *))            (* end case *))
153    
154      fun evalExp (env, e) = (case e      fun apply (env, f, mvs, xs) =
155             of S.E_Var x => evalVar env x            if List.all (fn x => VMap.inDomain(env, x)) xs
156              | S.E_Lit(Literal.Int i) => IV i              then (* try *)(
             | S.E_Lit(Literal.Float f) => RV(FloatLit.toReal f)  
             | S.E_Lit(Literal.String s) => SV s  
             | S.E_Lit(Literal.Bool b) => BV b  
             | S.E_Tuple _ => raise Fail "E_Tuple"  
             | S.E_Apply(f, mvs, xs, _) => (  
                 (* try *)(  
157                  if Var.same(f, BV.fn_load)                  if Var.same(f, BV.fn_load)
158                    then loadImage(mvs, List.map (evalVar env) xs)                    then SOME(loadImage(mvs, List.map (evalVar env) xs))
159                    else (case VTbl.find tbl f                    else (case VTbl.find tbl f
160                       of SOME evalFn => evalFn (List.map (evalVar env) xs)                       of SOME evalFn => SOME(evalFn (List.map (evalVar env) xs))
161                        | NONE => raise Fail("Eval.exvalExp: unknown function " ^ Var.nameOf f)                        | NONE => NONE
162                      (* end case *))                      (* end case *))
163                  ) handle ex => raise Fail (concat [                  ) handle ex => (
164                      TextIO.output (TextIO.stdErr, concat [
165                      Var.uniqueNameOf f, "(",                      Var.uniqueNameOf f, "(",
166                      String.concatWith "," (List.map Var.uniqueNameOf xs),                      String.concatWith "," (List.map Var.uniqueNameOf xs),
167                      ") fails with exception ", exnName ex                        ") fails with exception ", exnName ex, "\n"
168                    ]))                      ]);
169                  raise ex)
170                else NONE
171    
172        fun evalExp (env, e) = (case e
173               of S.E_Var x => VMap.find (env, x)
174                | S.E_Lit(Literal.Int i) => SOME(IV i)
175                | S.E_Lit(Literal.Float f) => SOME(RV(FloatLit.toReal f))
176                | S.E_Lit(Literal.String s) => SOME(SV s)
177                | S.E_Lit(Literal.Bool b) => SOME(BV b)
178                | S.E_Tuple _ => raise Fail "E_Tuple"
179                | S.E_Apply(f, mvs, xs, _) => apply(env, f, mvs, xs)
180              | S.E_Cons xs => raise Fail "TODO: E_Cons"              | S.E_Cons xs => raise Fail "TODO: E_Cons"
181              | S.E_Input(ty, name, optDefault) => let              | S.E_Slice(e, indices, _) => raise Fail "TODO: E_Slice"
182                | S.E_Input(ty, name, optDefault) => raise Fail "impossible"
183                | S.E_Field fld => SOME(FV fld)
184                | S.E_LoadImage info => SOME(Img info)
185              (* end case *))
186    
187        fun evalStatics (statics, blk) = let
188              fun evalBlock (env, S.Block stms) = let
189                    exception Done of value VMap.map
190                    fun evalStm (stm, env) = (case stm
191                           of S.S_Assign(x, S.E_Input(ty, name, optDefault)) =>
192                                if VSet.member(statics, x)
193                                  then let
194                  val optDefault = Option.map (evalVar env) optDefault                  val optDefault = Option.map (evalVar env) optDefault
195                  val SOME value = (case ty                                  val input = (case ty
196                         of Ty.T_Bool =>                         of Ty.T_Bool =>
197                              Inputs.getInput(name, (Option.map BV) o Bool.fromString, optDefault)                              Inputs.getInput(name, (Option.map BV) o Bool.fromString, optDefault)
198                          | Ty.T_Int =>                          | Ty.T_Int =>
# Line 164  Line 206 
206                              ])                              ])
207                        (* end case *))                        (* end case *))
208                  in                  in
209                    value                                    case input
210                                       of SOME v => VMap.insert(env, x, v)
211                                        | NONE => raise Fail("error getting required input " ^ name)
212                                      (* end case *)
213                  end                  end
214              | S.E_Field fld => FV fld                                else env
215              | S.E_LoadImage info => Img info                          | S.S_Assign(x, e) => (case evalExp(env, e)
216                                 of SOME v =>
217    (Log.msg(concat["eval assignment: ", Var.uniqueNameOf x, " = ", toString v, "\n"]);
218                                    VMap.insert(env, x, v)
219    )
220                                  | NONE => env
221                                (* end case *))
222                            | S.S_IfThenElse(x, b1, b2) => (case VMap.find(env, x)
223                                 of SOME(BV true) => evalBlock(env, b1)
224                                  | SOME(BV false) => evalBlock(env, b2)
225                                  | SOME _ => raise Fail "type error"
226                                  | NONE => raise (Done env)
227                                (* end case *))
228                            | S.S_New _ => raise Fail "unexpected new strand"
229                            | S.S_Die => raise Fail "unexpected die"
230                            | S.S_Stabilize => raise Fail "unexpected stabilize"
231            (* end case *))            (* end case *))
232                    in
233                      (List.foldl evalStm env stms) handle Done env => env
234                    end
235              in
236                evalBlock (VMap.empty, blk)
237              end
238    
239    end    end

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

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