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

SCM Repository

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

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

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

revision 245, Fri Aug 6 15:31:55 2010 UTC revision 1116, Thu May 5 04:49:02 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.
# Line 12  Line 12 
12        = BV of bool        = BV of bool
13        | SV of string        | SV of string
14        | IV of IntInf.int        | IV of IntInf.int
15        | TV of (int list * real list)    (* tensors *)        | RV of real
16        | FV of FieldDef.field_def        | TV of value list        (* tensors: values will either be RV or TV *)
17        | Img of ImageInfo.info        | ImgV of ImageInfo.info * Var.var
       | KV of Kernel.kernel  
18    
19      val evalStatics : Simple.block -> value Var.Map.map      val evalStatics : Var.Set.set * Simple.block -> value Var.Map.map
20    
21    end = struct    end = struct
22    
# Line 25  Line 24 
24      structure BV = BasisVars      structure BV = BasisVars
25      structure S = Simple      structure S = Simple
26      structure VMap = Var.Map      structure VMap = Var.Map
27        structure VSet = Var.Set
28      structure VTbl = Var.Tbl      structure VTbl = Var.Tbl
29    
30      datatype value      datatype value
31        = BV of bool        = BV of bool
32        | SV of string        | SV of string
33        | IV of IntInf.int        | IV of IntInf.int
34        | TV of (int list * real list)    (* tensors *)  (* FIXME: we probably should use FloatLit.float values instead of reals! *)
35        | FV of FieldDef.field_def        | RV of real
36        | Img of ImageInfo.info        | TV of value list        (* tensors: values will either be RV or TV *)
37        | KV of Kernel.kernel        | ImgV of ImageInfo.info * Var.var
   
     fun RV r = TV([], [r])  
38    
39      fun toString (BV b) = Bool.toString b      fun toString (BV b) = Bool.toString b
40        | toString (IV i) = IntInf.toString i        | toString (IV i) = IntInf.toString i
41        | toString (SV s) = concat["\"", String.toString s, "\""]        | toString (SV s) = concat["\"", String.toString s, "\""]
42        | toString (TV(s, v)) = "tensor"        | toString (RV r) = Real.toString r
43        | toString (FV fld) = FieldDef.toString fld        | toString (TV _) = "tensor"
44        | toString (Img info) = ImageInfo.toString info  (* FIXME: should include x in output *)
45        | toString (KV h) = Kernel.toString h        | toString (ImgV(info, x)) = ImageInfo.toString info
46    
47      val tbl : (value list -> value) VTbl.hash_table = let      val tbl : (value list -> value) VTbl.hash_table = let
48            val tbl = VTbl.mkTable (128, Fail "Eval table")            val tbl = VTbl.mkTable (128, Fail "Eval table")
49            fun intBinOp rator [IV a, IV b] = IV(rator(a, b))            fun intBinOp rator [IV a, IV b] = IV(rator(a, b))
50            fun tensorBinOp rator [TV(s1, v1), TV(s2, v2)] =            fun tensorBinOp rator [v1, v2] = let
51                  TV(s1, ListPair.mapEq rator (v1, v2))                  fun f (TV v1, TV v2) = TV(ListPair.mapEq f (v1, v2))
52            fun realBinOp rator [TV([], [a]), TV([], [b])] = RV(rator(a, b))                    | f (RV r1, RV r2) = RV(rator(r1, r2))
53            fun realUnOp rator [TV([], [a])] = RV(rator a)                  in
54                      f (v1, v2)
55                    end
56              fun realBinOp rator [RV a, RV b] = RV(rator(a, b))
57              fun realUnOp rator [RV a] = RV(rator a)
58            fun intCmp rator [IV a, IV b] = BV(rator(a, b))            fun intCmp rator [IV a, IV b] = BV(rator(a, b))
59            fun realCmp rator [TV([], [a]), TV([], [b])] = BV(rator(a, b))            fun realCmp rator [RV a, RV b] = BV(rator(a, b))
60            fun boolCmp rator [BV a, BV b] = BV(rator(a, b))            fun boolCmp rator [BV a, BV b] = BV(rator(a, b))
61            fun stringCmp rator [SV a, SV b] = BV(rator(a, b))            fun stringCmp rator [SV a, SV b] = BV(rator(a, b))
           fun kernel h [] = KV h  
62            in            in
63              List.app (VTbl.insert tbl) [              List.app (VTbl.insert tbl) [
64                  (BV.add_ii,             intBinOp (op +)),                  (BV.add_ii,             intBinOp (op +)),
# Line 94  Line 95 
95                  (BV.neg_i,              fn [IV i] => IV(~i)),                  (BV.neg_i,              fn [IV i] => IV(~i)),
96  (*  (*
97                  (BV.neg_t,              tensorOp Op.Neg),                  (BV.neg_t,              tensorOp Op.Neg),
 *)  
98                  (BV.neg_f,              fn [FV fld] => FV(FieldDef.neg fld)),                  (BV.neg_f,              fn [FV fld] => FV(FieldDef.neg fld)),
 (*  
99                  (BV.op_at,              fn (y, _, xs) => assign(y, Op.Probe, xs)),                  (BV.op_at,              fn (y, _, xs) => assign(y, Op.Probe, xs)),
 *)  
100                  (BV.op_D,               fn [FV fld] => FV(FieldDef.diff fld)),                  (BV.op_D,               fn [FV fld] => FV(FieldDef.diff fld)),
 (*  
101                  (BV.op_norm,            tensorOp Op.Norm),                  (BV.op_norm,            tensorOp Op.Norm),
102  *)  *)
103                  (BV.op_not,             fn [BV b] => BV(not b)),                  (BV.op_not,             fn [BV b] => BV(not b)),
104  (*  (*
                 (BV.op_subscript,       fn (y, [SK, NK], xs) => ??),  
105                  (BV.fn_CL,              fn (y, _, xs) => assign(y, Op.CL, xs)),                  (BV.fn_CL,              fn (y, _, xs) => assign(y, Op.CL, xs)),
106                    (BV.op_convolve,        fn [Img info, KV h] => FV(FieldDef.CONV(0, info, h))),
107                    (BV.fn_convolve,        fn [KV h, Img info] => FV(FieldDef.CONV(0, info, h))),
108  *)  *)
                 (BV.fn_convolve,        fn [KV h, Img info] => FV(FieldDef.CONV(info, h))),  
109                  (BV.fn_cos,             realUnOp Math.cos),                  (BV.fn_cos,             realUnOp Math.cos),
110  (*  (*
111                  (BV.fn_dot,             vectorOp Op.Dot),                  (BV.fn_dot,             vectorOp Op.Dot),
# Line 122  Line 119 
119                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
120  *)  *)
121                  (BV.fn_sin,             realUnOp Math.sin),                  (BV.fn_sin,             realUnOp Math.sin),
122    (*
123                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
124                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
125                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
126                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
127                    (BV.kn_c1tent,          kernel Kernel.c1tent),
128                    (BV.kn_c2ctmr,          kernel Kernel.c2ctmr),
129    *)
130                  (BV.i2r,                fn [IV i] => RV(real(IntInf.toInt i)))                  (BV.i2r,                fn [IV i] => RV(real(IntInf.toInt i)))
131                ];                ];
132              tbl              tbl
133            end            end
134    
135      fun loadImage ([Ty.DIM dim, Ty.SHAPE shp], [SV filename]) = let      fun loadImage ([Ty.DIM dim, Ty.SHAPE shp], SV filename) = let
136            val Ty.DimConst d = TypeUtil.resolveDim dim            val Ty.DimConst d = TypeUtil.resolveDim dim
137            val Ty.Shape dd = TypeUtil.resolveShape shp            val Ty.Shape dd = TypeUtil.resolveShape shp
138            val info as ImageInfo.ImgInfo{dim, ...} = ImageInfo.getInfo filename            val info as ImageInfo.ImgInfo{dim, ...} = ImageInfo.getInfo filename
# Line 142  Line 143 
143                else ();                else ();
144            (* check that the expected shape and actual shape match *)            (* check that the expected shape and actual shape match *)
145  (* FIXME *)  (* FIXME *)
146              Img info              info
147            end            end
148    
149      fun evalVar env x = (case VMap.find (env, x)      fun evalVar env x = (case VMap.find (env, x)
# Line 150  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 let
159                        val [imgName] = xs
160                        in
161                          SOME(ImgV(loadImage(mvs, evalVar env imgName), imgName))
162                        end
163                    else (case VTbl.find tbl f                    else (case VTbl.find tbl f
164                       of SOME evalFn => evalFn (List.map (evalVar env) xs)                       of SOME evalFn => SOME(evalFn (List.map (evalVar env) xs))
165                        | NONE => raise Fail("Eval.exvalExp: unknown function " ^ Var.nameOf f)                        | NONE => NONE
166                      (* end case *))                      (* end case *))
167                  ) handle ex => (                  ) handle ex => (
168                    TextIO.output (TextIO.stdErr, concat [                    TextIO.output (TextIO.stdErr, concat [
# Line 171  Line 170 
170                        String.concatWith "," (List.map Var.uniqueNameOf xs),                        String.concatWith "," (List.map Var.uniqueNameOf xs),
171                        ") fails with exception ", exnName ex, "\n"                        ") fails with exception ", exnName ex, "\n"
172                      ]);                      ]);
173                    raise ex))                raise ex)
174              | S.E_Cons xs => raise Fail "TODO: E_Cons"              else NONE
175              | S.E_Input(ty, name, optDefault) => let  
176                  val optDefault = Option.map (evalVar env) optDefault      fun evalExp (env, e) = (case e
177                  val SOME value = (case ty             of S.E_Var x => VMap.find (env, x)
178                | S.E_Lit(Literal.Int i) => SOME(IV i)
179                | S.E_Lit(Literal.Float f) => SOME(RV(FloatLit.toReal f))
180                | S.E_Lit(Literal.String s) => SOME(SV s)
181                | S.E_Lit(Literal.Bool b) => SOME(BV b)
182                | S.E_Tuple _ => raise Fail "E_Tuple"
183                | S.E_Apply(f, mvs, xs, _) => apply(env, f, mvs, xs)
184                | S.E_Cons xs => (case evalArgs(env, xs)
185                     of NONE => NONE
186                      | SOME vs => SOME(TV vs)
187                    (* end case *))
188                | S.E_Slice(x, indices, _) => (case VMap.find (env, x)
189                     of SOME v => let
190                          fun slice (TV vs, SOME ix :: ixs) = (case VMap.find (env, ix)
191                                 of SOME(IV i) => slice (List.nth(vs, IntInf.toInt i), ixs)
192                                  | NONE => raise Subscript
193                                (* end case *))
194                            | slice (TV vs, NONE :: ixs) =
195                                TV(List.map (fn v => slice(v, ixs)) vs)
196                            | slice (v, []) = v
197                          in
198                            SOME(slice(v, indices)) handle Subscript => NONE
199                          end
200                      | _ => NONE
201                    (* end case *))
202                | S.E_Input(ty, name, optDefault) => raise Fail "impossible"
203                | S.E_LoadImage info => SOME(ImgV info)
204              (* end case *))
205    
206        and evalArgs (env, args) = let
207              fun eval ([], vs) = SOME(List.rev vs)
208                | eval (x::xs, vs) = (case VMap.find(env, x)
209                     of SOME v => eval(xs, v::vs)
210                      | NONE => NONE
211                    (* end case *))
212              in
213                eval (args, [])
214              end
215    
216        fun getInput (ty, name, optDefault) = (case ty
217                         of Ty.T_Bool =>                         of Ty.T_Bool =>
218                              Inputs.getInput(name, (Option.map BV) o Bool.fromString, optDefault)                              Inputs.getInput(name, (Option.map BV) o Bool.fromString, optDefault)
219                          | Ty.T_Int =>                          | Ty.T_Int =>
# Line 183  Line 221 
221                          | Ty.T_String => Inputs.getInput(name, fn s => SOME(SV s), optDefault)                          | Ty.T_String => Inputs.getInput(name, fn s => SOME(SV s), optDefault)
222                          | Ty.T_Tensor(Ty.Shape[]) =>                          | Ty.T_Tensor(Ty.Shape[]) =>
223                              Inputs.getInput(name, (Option.map RV) o Real.fromString, optDefault)                              Inputs.getInput(name, (Option.map RV) o Real.fromString, optDefault)
224                | Ty.T_Tensor(Ty.Shape[Ty.DimConst d]) => let
225                    fun fromString s = let
226                        (* first split into fields by "," *)
227                          val flds = String.fields (fn #"," => true | _ => false) s
228                        (* then tokenize by white space and flatten *)
229                          val toks = List.concat(List.map (String.tokens Char.isSpace) flds)
230                        (* then convert to reals *)
231                          val vals = List.map (RV o valOf o Real.fromString) toks
232                          in
233                            if (List.length vals = d)
234                              then SOME(TV(vals))
235                              else NONE
236                          end
237                          handle _ => NONE
238                    in
239                      Inputs.getInput(name, fromString, optDefault)
240                    end
241                          | Ty.T_Tensor shp => raise Fail "TODO: general tensor inputs"                          | Ty.T_Tensor shp => raise Fail "TODO: general tensor inputs"
242                          | _ => raise Fail(concat[                          | _ => raise Fail(concat[
243                                "input ", name, " has invalid type ", TypeUtil.toString ty                                "input ", name, " has invalid type ", TypeUtil.toString ty
244                              ])                              ])
245                        (* end case *))                        (* end case *))
                 in  
                   value  
                 end  
             | S.E_Field fld => FV fld  
             | S.E_LoadImage info => Img info  
           (* end case *))  
246    
247        fun evalStatics (statics, blk) = let
248      fun evalBlock (env, S.Block stms) = let      fun evalBlock (env, S.Block stms) = let
249                    exception Done of value VMap.map
250            fun evalStm (stm, env) = (case stm            fun evalStm (stm, env) = (case stm
251                   of S.S_Assign(x, e) => VMap.insert(env, x, evalExp(env, e))                         of S.S_Var _ => raise Fail "unexpected variable decl"
252                    | S.S_IfThenElse(x, b1, b2) => (case evalVar env x                          | S.S_Assign(x, S.E_Input(ty, name, optDefault)) =>
253                         of BV true => evalBlock(env, b1)                              if VSet.member(statics, x)
254                          | BV false => evalBlock(env, b2)                                then let
255                          | _ => raise Fail "type error"                                  val optDefault = Option.map (evalVar env) optDefault
256                                    val input = getInput (ty, name, optDefault)
257                                    in
258                                      case input
259                                       of SOME v => VMap.insert(env, x, v)
260                                        | NONE => raise Fail("error getting required input " ^ name)
261                                      (* end case *)
262                                    end
263                                  else env
264                            | S.S_Assign(x, e) => (case evalExp(env, e)
265                                 of SOME v =>
266    (Log.msg(concat["eval assignment: ", Var.uniqueNameOf x, " = ", toString v, "\n"]);
267                                    VMap.insert(env, x, v)
268    )
269                                  | NONE => env
270                                (* end case *))
271                            | S.S_IfThenElse(x, b1, b2) => (case VMap.find(env, x)
272                                 of SOME(BV true) => evalBlock(env, b1)
273                                  | SOME(BV false) => evalBlock(env, b2)
274                                  | SOME _ => raise Fail "type error"
275                                  | NONE => raise (Done env)
276                        (* end case *))                        (* end case *))
277                    | S.S_New _ => raise Fail "unexpected new actor"                          | S.S_New _ => raise Fail "unexpected new strand"
278                    | S.S_Die => raise Fail "unexpected die"                    | S.S_Die => raise Fail "unexpected die"
279                    | S.S_Stabilize => raise Fail "unexpected stabilize"                    | S.S_Stabilize => raise Fail "unexpected stabilize"
280                  (* end case *))                  (* end case *))
281            in            in
282              List.foldl evalStm env stms                    (List.foldl evalStm env stms) handle Done env => env
283                    end
284              in
285                evalBlock (VMap.empty, blk)
286            end            end
   
     fun evalStatics staticInit = evalBlock (VMap.empty, staticInit)  
287    
288    end    end

Legend:
Removed from v.245  
changed lines
  Added in v.1116

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