Home My Page Projects Code Snippets Project Openings diderot

# SCM Repository

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

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

revision 1115, Thu May 5 04:42:18 2011 UTC revision 1116, Thu May 5 04:49:02 2011 UTC
# 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 : Var.Set.set * Simple.block -> value Var.Map.map      val evalStatics : Var.Set.set * Simple.block -> value Var.Map.map
20
# Line 32  Line 31
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) [
# Line 95  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  (*  (*
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))),                  (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))),                  (BV.fn_convolve,        fn [KV h, Img info] => FV(FieldDef.CONV(0, info, h))),
108    *)
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 123  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 143  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 155  Line 155
155            if List.all (fn x => VMap.inDomain(env, x)) xs            if List.all (fn x => VMap.inDomain(env, x)) xs
156              then (* try *)(              then (* try *)(
158                    then SOME(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 => SOME(evalFn (List.map (evalVar env) xs))                       of SOME evalFn => SOME(evalFn (List.map (evalVar env) xs))
165                        | NONE => NONE                        | NONE => NONE
# Line 177  Line 181
181              | S.E_Lit(Literal.Bool b) => SOME(BV b)              | S.E_Lit(Literal.Bool b) => SOME(BV b)
182              | S.E_Tuple _ => raise Fail "E_Tuple"              | S.E_Tuple _ => raise Fail "E_Tuple"
183              | S.E_Apply(f, mvs, xs, _) => apply(env, f, mvs, xs)              | S.E_Apply(f, mvs, xs, _) => apply(env, f, mvs, xs)
184              | S.E_Cons xs => raise Fail "TODO: E_Cons"              | S.E_Cons xs => (case evalArgs(env, xs)
185              | S.E_Slice(e, indices, _) => raise Fail "TODO: E_Slice"                   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"              | S.E_Input(ty, name, optDefault) => raise Fail "impossible"
203              | S.E_Field fld => SOME(FV fld)              | S.E_LoadImage info => SOME(ImgV info)
| S.E_LoadImage info => SOME(Img info)
204            (* end case *))            (* end case *))
205
206      fun evalStatics (statics, blk) = let      and evalArgs (env, args) = let
207            fun evalBlock (env, S.Block stms) = let            fun eval ([], vs) = SOME(List.rev vs)
208                  exception Done of value VMap.map              | eval (x::xs, vs) = (case VMap.find(env, x)
209                  fun evalStm (stm, env) = (case stm                   of SOME v => eval(xs, v::vs)
210                         of S.S_Assign(x, S.E_Input(ty, name, optDefault)) =>                    | NONE => NONE
211                              if VSet.member(statics, x)                  (* end case *))
212                                then let            in
213                                  val optDefault = Option.map (evalVar env) optDefault              eval (args, [])
214                                  val input = (case ty            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 200  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 *))
246
247        fun evalStatics (statics, blk) = let
248              fun evalBlock (env, S.Block stms) = let
249                    exception Done of value VMap.map
250                    fun evalStm (stm, env) = (case stm
251                           of S.S_Var _ => raise Fail "unexpected variable decl"
252                            | S.S_Assign(x, S.E_Input(ty, name, optDefault)) =>
253                                if VSet.member(statics, x)
254                                  then let
255                                    val optDefault = Option.map (evalVar env) optDefault
256                                    val input = getInput (ty, name, optDefault)
257                                  in                                  in
258                                    case input                                    case input
259                                     of SOME v => VMap.insert(env, x, v)                                     of SOME v => VMap.insert(env, x, v)

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