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 236, Thu Aug 5 21:57:57 2010 UTC revision 399, Thu Oct 14 20:08:35 2010 UTC
# Line 17  Line 17 
17        | Img of ImageInfo.info        | Img of ImageInfo.info
18        | KV of Kernel.kernel        | KV of Kernel.kernel
19    
20      val evalStatics : Simple.program -> value Var.Map.map      val evalStatics : Var.Set.set * Simple.block -> value Var.Map.map
21    
22    end = struct    end = struct
23    
# Line 25  Line 25 
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 52  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 90  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.op_subscript,       fn (y, [SK, NK], xs) => ??),
110                  (BV.fn_CL,              fn (y, _, xs) => assign(y, Op.CL, xs)),                  (BV.fn_CL,              fn (y, _, xs) => assign(y, Op.CL, xs)),
111                  (BV.fn_convolve,        fn (y, _, xs) => assign(y, Op.Convolve, xs)),  *)
112                  (BV.fn_cos,             simpleOp Op.Cos),                  (BV.op_convolve,        fn [Img info, KV h] => FV(FieldDef.CONV(0, info, h))),
113                    (BV.fn_convolve,        fn [KV h, Img info] => FV(FieldDef.CONV(0, info, h))),
114                    (BV.fn_cos,             realUnOp Math.cos),
115    (*
116                  (BV.fn_dot,             vectorOp Op.Dot),                  (BV.fn_dot,             vectorOp Op.Dot),
117                  (BV.fn_inside,          fn (y, _, xs) => assign(y, Op.Inside, xs)),                  (BV.fn_inside,          fn (y, _, xs) => assign(y, Op.Inside, xs)),
118  *)  *)
# Line 113  Line 122 
122                  (BV.fn_pow,             realBinOp Real.Math.pow),                  (BV.fn_pow,             realBinOp Real.Math.pow),
123  (*  (*
124                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
                 (BV.fn_sin,             simpleOp Op.Sin),  
125  *)  *)
126                    (BV.fn_sin,             realUnOp Math.sin),
127                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
128                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
129                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
130                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
131                  (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*)  
 *)  
132                ];                ];
133              tbl              tbl
134            end            end
135    
136      fun loadImage (mvs, [SV filename]) = let      fun loadImage ([Ty.DIM dim, Ty.SHAPE shp], [SV filename]) = let
137            val info = ImageInfo.getInfo filename            val Ty.DimConst d = TypeUtil.resolveDim dim
138              val Ty.Shape dd = TypeUtil.resolveShape shp
139              val info as ImageInfo.ImgInfo{dim, ...} = ImageInfo.getInfo filename
140            in            in
141  (* FIXME: check image info details against mvs *)            (* check that the expected dimension and actual dimension match *)
142                if (d <> dim)
143                  then raise Fail(concat["image file \"", filename, "\" has wrong dimension"])
144                  else ();
145              (* check that the expected shape and actual shape match *)
146    (* FIXME *)
147              Img info              Img info
148            end            end
149    
# Line 139  Line 152 
152              | NONE => raise Fail("undefined variable " ^ Var.uniqueNameOf x)              | NONE => raise Fail("undefined variable " ^ Var.uniqueNameOf x)
153            (* end case *))            (* end case *))
154    
155      fun evalExp (env, e) = (case e      fun apply (env, f, mvs, xs) =
156             of S.E_Var x => evalVar env x            if List.all (fn x => VMap.inDomain(env, x)) xs
157              | 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 *)(  
158                  if Var.same(f, BV.fn_load)                  if Var.same(f, BV.fn_load)
159                    then loadImage(mvs, List.map (evalVar env) xs)                    then SOME(loadImage(mvs, List.map (evalVar env) xs))
160                    else (case VTbl.find tbl f                    else (case VTbl.find tbl f
161                       of SOME evalFn => evalFn (List.map (evalVar env) xs)                       of SOME evalFn => SOME(evalFn (List.map (evalVar env) xs))
162                        | NONE => raise Fail("Eval.exvalExp: unknown function " ^ Var.nameOf f)                        | NONE => NONE
163                      (* end case *))                      (* end case *))
164                  ) handle ex => raise Fail (concat [                  ) handle ex => (
165                      TextIO.output (TextIO.stdErr, concat [
166                      Var.uniqueNameOf f, "(",                      Var.uniqueNameOf f, "(",
167                      String.concatWith "," (List.map Var.uniqueNameOf xs),                      String.concatWith "," (List.map Var.uniqueNameOf xs),
168                      ") fails with exception ", exnName ex                        ") fails with exception ", exnName ex, "\n"
169                    ]))                      ]);
170                  raise ex)
171                else NONE
172    
173        fun evalExp (env, e) = (case e
174               of S.E_Var x => VMap.find (env, x)
175                | S.E_Lit(Literal.Int i) => SOME(IV i)
176                | S.E_Lit(Literal.Float f) => SOME(RV(FloatLit.toReal f))
177                | S.E_Lit(Literal.String s) => SOME(SV s)
178                | S.E_Lit(Literal.Bool b) => SOME(BV b)
179                | S.E_Tuple _ => raise Fail "E_Tuple"
180                | S.E_Apply(f, mvs, xs, _) => apply(env, f, mvs, xs)
181              | S.E_Cons xs => raise Fail "TODO: E_Cons"              | S.E_Cons xs => raise Fail "TODO: E_Cons"
182              | S.E_Input(ty, name, optDefault) => let              | S.E_Slice(e, indices, _) => raise Fail "TODO: E_Slice"
183                | S.E_Input(ty, name, optDefault) => raise Fail "impossible"
184                | S.E_Field fld => SOME(FV fld)
185                | S.E_LoadImage info => SOME(Img info)
186              (* end case *))
187    
188        fun evalStatics (statics, blk) = let
189              fun evalBlock (env, S.Block stms) = let
190                    exception Done of value VMap.map
191                    fun evalStm (stm, env) = (case stm
192                           of S.S_Assign(x, S.E_Input(ty, name, optDefault)) =>
193                                if VSet.member(statics, x)
194                                  then let
195                  val optDefault = Option.map (evalVar env) optDefault                  val optDefault = Option.map (evalVar env) optDefault
196                  val SOME value = (case ty                                  val input = (case ty
197                         of Ty.T_Bool =>                         of Ty.T_Bool =>
198                              Inputs.getInput(name, (Option.map BV) o Bool.fromString, optDefault)                              Inputs.getInput(name, (Option.map BV) o Bool.fromString, optDefault)
199                          | Ty.T_Int =>                          | Ty.T_Int =>
# Line 176  Line 207 
207                              ])                              ])
208                        (* end case *))                        (* end case *))
209                  in                  in
210                    value                                    case input
211                                       of SOME v => VMap.insert(env, x, v)
212                                        | NONE => raise Fail("error getting required input " ^ name)
213                                      (* end case *)
214                  end                  end
215              | S.E_Field fld => FV fld                                else env
216              | S.E_LoadImage info => Img info                          | S.S_Assign(x, e) => (case evalExp(env, e)
217            (* end case *))                               of SOME v =>
218    (Log.msg(concat["eval assignment: ", Var.uniqueNameOf x, " = ", toString v, "\n"]);
219      fun evalBlock (env, S.Block stms) = let                                  VMap.insert(env, x, v)
220            fun evalStm (stm, env) = (case stm  )
221                   of S.S_Assign(x, e) => VMap.insert(env, x, evalExp(env, e))                                | NONE => env
222                    | S.S_IfThenElse(x, b1, b2) => (case evalVar env x                              (* end case *))
223                         of BV true => evalBlock(env, b1)                          | S.S_IfThenElse(x, b1, b2) => (case VMap.find(env, x)
224                          | BV false => evalBlock(env, b2)                               of SOME(BV true) => evalBlock(env, b1)
225                          | _ => raise Fail "type error"                                | SOME(BV false) => evalBlock(env, b2)
226                                  | SOME _ => raise Fail "type error"
227                                  | NONE => raise (Done env)
228                        (* end case *))                        (* end case *))
229                    | S.S_New _ => raise Fail "unexpected new actor"                    | S.S_New _ => raise Fail "unexpected new actor"
230                    | S.S_Die => raise Fail "unexpected die"                    | S.S_Die => raise Fail "unexpected die"
231                    | S.S_Stabilize => raise Fail "unexpected stabilize"                    | S.S_Stabilize => raise Fail "unexpected stabilize"
232                  (* end case *))                  (* end case *))
233            in            in
234              List.foldl evalStm env stms                    (List.foldl evalStm env stms) handle Done env => env
235                    end
236              in
237                evalBlock (VMap.empty, blk)
238            end            end
   
     fun evalStatics (S.Program{staticInit, ...}) =  
           evalBlock (VMap.empty, staticInit)  
239    
240    end    end

Legend:
Removed from v.236  
changed lines
  Added in v.399

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