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

SCM Repository

[diderot] Annotation of /branches/charisee/src/compiler/high-to-mid/high-to-mid.sml
ViewVC logotype

Annotation of /branches/charisee/src/compiler/high-to-mid/high-to-mid.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3048 - (view) (download)

1 : cchiw 3048 (* high-to-mid.sml
2 : jhr 280 *
3 : jhr 435 * COPYRIGHT (c) 2010 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 : jhr 280 * All rights reserved.
5 :     *
6 :     * Translation from HighIL to MidIL representations.
7 :     *)
8 :    
9 :     structure HighToMid : sig
10 :    
11 :     val translate : HighIL.program -> MidIL.program
12 :    
13 :     end = struct
14 :    
15 :     structure SrcIL = HighIL
16 : jhr 392 structure SrcTy = HighILTypes
17 : jhr 334 structure SrcOp = HighOps
18 : jhr 1640 structure SrcSV = SrcIL.StateVar
19 : jhr 364 structure VTbl = SrcIL.Var.Tbl
20 : jhr 280 structure DstIL = MidIL
21 : jhr 391 structure DstTy = MidILTypes
22 : jhr 334 structure DstOp = MidOps
23 : cchiw 2605 structure Probe = ProbeEin
24 :     structure P = Printer
25 : cchiw 2553 structure E=Ein
26 : cchiw 2844 structure Var = MidIL.Var
27 :     structure split =Split
28 :     structure TE=TransformEin
29 : cchiw 2845 structure mk= mkOperators
30 :     structure MidToString =MidToString
31 : cchiw 2510
32 : cchiw 3033 val testing =0
33 : cchiw 2830 fun testp n=(case testing
34 :     of 0=> 1
35 :     | _ =>(print(String.concat n);1)
36 :     (*end case*))
37 : cchiw 3017 fun testp0 n= testp n
38 :    
39 : cchiw 2845 fun incUseD (DstIL.V{useCnt, ...}) = (useCnt := !useCnt + 1)
40 :     fun useD x = (incUseD x; x)
41 :     fun iTos e=Int.toString e
42 :     val cnt = ref 0
43 :     fun genName prefix = let
44 :     val n = !cnt
45 :     in
46 :     cnt := n+1;
47 :     String.concat[prefix, "_", Int.toString n]
48 :     end
49 : jhr 1116 fun getRHS x = (case SrcIL.Var.binding x
50 : cchiw 2845 of SrcIL.VB_RHS(SrcIL.VAR x') => getRHS x'
51 :     | SrcIL.VB_RHS e => e
52 : cchiw 2830 | vb => raise Fail(concat[
53 : cchiw 2515 "expected rhs operator for ", SrcIL.Var.toString x,
54 :     "but found ", SrcIL.vbToString vb
55 : cchiw 2845 ])
56 : cchiw 2510 (* end case *))
57 : jhr 1116
58 : jhr 394 fun cvtTy SrcTy.BoolTy = DstTy.BoolTy
59 :     | cvtTy SrcTy.StringTy = DstTy.StringTy
60 :     | cvtTy SrcTy.IntTy = DstTy.intTy
61 : jhr 1116 | cvtTy (SrcTy.TensorTy dd) = DstTy.tensorTy dd
62 : jhr 1640 | cvtTy (SrcTy.TupleTy tys) = DstTy.TupleTy(List.map cvtTy tys)
63 :     | cvtTy (SrcTy.SeqTy(ty, n)) = DstTy.SeqTy(cvtTy ty, n)
64 : jhr 1116 (* we replace Kernel and Field operations by 0, so the types are mapped to int *)
65 : cchiw 2522 | cvtTy SrcTy.KernelTy = DstTy.KernelTy
66 : cchiw 2515 | cvtTy SrcTy.FieldTy = DstTy.intTy
67 : jhr 397 | cvtTy ty = raise Fail("unexpected type " ^ SrcTy.toString ty)
68 : jhr 394
69 : jhr 1640 (* instantiate the translation environment *)
70 :     local
71 :     type var_env = DstIL.var VTbl.hash_table
72 :     type state_var_env = DstIL.state_var SrcSV.Tbl.hash_table
73 :    
74 : cchiw 2510 (*********************FIX*********************)
75 :    
76 : cchiw 2605 fun rename (env : var_env, x) = case VTbl.find env x
77 :     of SOME x' =>( x')
78 :     | NONE => let
79 :     val dstTy = (case SrcIL.Var.ty x
80 :     of SrcTy.ImageTy _ => (
81 :     (* for variables with image type, we need more detailed information
82 : jhr 1640 * about the image for the MidIL type.
83 :     *)
84 :     case getRHS x
85 : cchiw 2845 of SrcIL.OP(SrcOp.LoadImage v, _) => DstTy.ImageTy v
86 : jhr 1640 | _ => raise Fail "bogus image variable"
87 :     (* end case *))
88 :     | _ => cvtTy(SrcIL.Var.ty x)
89 :     (* end case *))
90 : cchiw 2510 val x' = DstIL.Var.new (SrcIL.Var.name x, dstTy)
91 :     in
92 :     VTbl.insert env (x, x');
93 :     x'
94 :     end
95 : cchiw 2515
96 : cchiw 2510 handle Fail msg => raise Fail(concat["rename(_, ", SrcIL.Var.toString x, "): ", msg])
97 : jhr 1116
98 : jhr 2356 fun renameSV (env : state_var_env, x) = (case SrcSV.Tbl.find env x
99 :     of SOME x' => x'
100 :     | NONE => let
101 :     val dstTy = cvtTy (SrcSV.ty x)
102 :     val x' = DstIL.StateVar.new (SrcSV.isOutput x, SrcSV.name x, dstTy)
103 :     in
104 :     SrcSV.Tbl.insert env (x, x');
105 :     x'
106 :     end
107 :     (* end case *))
108 : jhr 1640 in
109 :     structure Env = TranslateEnvFn (
110 :     struct
111 :     structure SrcIL = SrcIL
112 :     structure DstIL = DstIL
113 :     type var_env = var_env
114 :     type state_var_env = state_var_env
115 :     val rename = rename
116 :     val renameSV = renameSV
117 :     end)
118 :     end
119 : jhr 334
120 : jhr 1116 (* expand raising a real to an integer power. When we know the exponent, we can inline
121 :     * multiplications.
122 :     *)
123 :     fun expandPower (env, y, [x, n]) = let
124 : jhr 2356 fun getConst x = (case SrcIL.Var.binding x
125 :     of SrcIL.VB_RHS(SrcIL.VAR x') => getConst x'
126 :     | SrcIL.VB_RHS(SrcIL.LIT(Literal.Int n)) => SOME n
127 :     | vb => NONE
128 :     (* end case *))
129 :     val x = Env.rename(env, x)
130 :     fun pow () = let
131 :     val t = DstIL.Var.new("n", DstTy.realTy)
132 :     in [
133 :     (t, DstIL.OP(DstOp.IntToReal, [Env.rename(env, n)])),
134 :     (y, DstIL.APPLY(MathFuns.pow, [x, t]))
135 :     ] end
136 :     in
137 :     case getConst n
138 :     of SOME 0 => [(y, DstIL.LIT(Literal.Float(FloatLit.one)))]
139 :     | SOME 1 => [(y, DstIL.VAR x)]
140 :     | SOME ~1 => let
141 :     val t = DstIL.Var.new("one", DstTy.realTy)
142 :     in [
143 :     (t, DstIL.LIT(Literal.Float(FloatLit.one))),
144 : cchiw 2496 (y, DstIL.OP(DstOp.IDiv , [t, x]))
145 : jhr 2356 ] end
146 : cchiw 2496 | SOME 2 => [(y, DstIL.OP(DstOp.IMul , [x, x]))]
147 : jhr 1640 (* FIXME: expand into multiplications; ~2 ==> sqrt
148 : jhr 2356 | SOME n =>
149 : jhr 1116 *) | SOME _ => pow()
150 : jhr 2356 | NONE => pow()
151 :     end
152 : jhr 280
153 : jhr 1116 (* expand the field Inside operator into a image-space test *)
154 :     fun expandInside (env, result, pos, fld) = (case getRHS fld
155 : cchiw 2845 of SrcIL.EINAPP( _, [img, h]) =>(case (getRHS img, getRHS h)
156 :     of (SrcIL.OP(SrcOp.LoadImage v, _), SrcIL.OP(SrcOp.Kernel(h, _),_)) => let
157 : jhr 2356 val pos = Env.rename (env, pos)
158 : cchiw 2845 val img = Env.rename (env, img)
159 : jhr 2356 val s = Kernel.support h
160 : cchiw 2830 val dim=ImageInfo.dim v
161 : cchiw 2843 val(_,x,code)=TE.WorldToImagespace(dim,v,pos,img)
162 : cchiw 2857
163 : cchiw 2845 in code@[
164 :     (result, DstIL.OP(DstOp.Inside(v, s), [x, img]))
165 :     ]
166 :     end
167 : jhr 2356 | _ => raise Fail "bogus kernel binding"
168 :     (* end case *))
169 :     | _ => raise Fail "bogus field binding"
170 : cchiw 2830 (* end case *))
171 : cchiw 2496
172 : cchiw 2668
173 : jhr 392 fun arity (SrcTy.TensorTy[]) = 1
174 :     | arity (SrcTy.TensorTy[d]) = d
175 : jhr 365 | arity _ = raise Fail "arity"
176 :    
177 : jhr 364 fun expandOp (env, y, rator, args) = let
178 : jhr 2356 fun assign rator' =
179 :     [(y, DstIL.OP(rator', Env.renameList(env, args)))]
180 :     fun cvtToInt rator' = let
181 :     val t = DstIL.Var.new ("t", DstTy.realTy)
182 :     in [
183 :     (t, DstIL.OP(rator', Env.renameList(env, args))),
184 :     (y, DstIL.OP(DstOp.RealToInt 1, [t]))
185 :     ] end
186 :     fun dummy () = [(y, DstIL.LIT(Literal.Int 0))]
187 :     in
188 :     case rator
189 : cchiw 2396 of SrcOp.IAdd => assign (DstOp.IAdd)
190 :     | SrcOp.ISub => assign (DstOp.ISub)
191 :     | SrcOp.IMul => assign (DstOp.IMul)
192 :     | SrcOp.IDiv => assign (DstOp.IDiv)
193 :     | SrcOp.INeg => assign (DstOp.INeg)
194 : jhr 2356 | SrcOp.Abs ty => assign (DstOp.Abs(cvtTy ty))
195 :     | SrcOp.LT ty => assign (DstOp.LT(cvtTy ty))
196 :     | SrcOp.LTE ty => assign (DstOp.LTE(cvtTy ty))
197 :     | SrcOp.EQ ty => assign (DstOp.EQ(cvtTy ty))
198 :     | SrcOp.NEQ ty => assign (DstOp.NEQ(cvtTy ty))
199 :     | SrcOp.GT ty => assign (DstOp.GT(cvtTy ty))
200 :     | SrcOp.GTE ty => assign (DstOp.GTE(cvtTy ty))
201 :     | SrcOp.Power => expandPower(env, y, args)
202 :     | SrcOp.Not => assign DstOp.Not
203 :     | SrcOp.Max => assign DstOp.Max
204 :     | SrcOp.Min => assign DstOp.Min
205 :     | SrcOp.Clamp ty => assign (DstOp.Clamp(cvtTy ty))
206 :     | SrcOp.Lerp ty => assign (DstOp.Lerp(cvtTy ty))
207 : cchiw 2845 | SrcOp.Sqrt =>assign DstOp.Sqrt
208 : cchiw 3048 | SrcOp.Norm(SrcTy.TensorTy [])=> assign(DstOp.Abs DstTy.realTy)
209 : cchiw 2845 | SrcOp.Norm(SrcTy.TensorTy alpha)=> let
210 : cchiw 3048 (*Note Norm is implemented with EINAPP as a summation over modulate then sqrt*)
211 : cchiw 2845 val t = DstIL.Var.new (genName "t", DstTy.realTy)
212 :     val t= useD t
213 :     val a=Env.renameList(env, args)
214 : cchiw 2906 in [(t,DstIL.EINAPP(mk.magnitudeTT alpha,a@a)),
215 : cchiw 2845 (y, DstIL.OP( DstOp.Sqrt,[t]))
216 :     ]
217 :     end
218 :     (*| SrcOp.Norm ty => assign (DstOp.Norm(cvtTy ty))*)
219 : cchiw 2838 | SrcOp.Normalize ty=> assign (DstOp.Normalize(arity ty))
220 : jhr 2356 | SrcOp.PrincipleEvec ty => assign (DstOp.PrincipleEvec(cvtTy ty))
221 : cchiw 2628 | SrcOp.Zero ty => assign (DstOp.Zero(cvtTy ty))
222 : cchiw 2847 | SrcOp.Slice(SrcTy.TensorTy argTy, mask) => let
223 :     fun iterArgs []=[]
224 :     | iterArgs(e1::es)=let
225 :     val SrcIL.LIT(Literal.Int i)=getRHS e1
226 :     in [IntInf.toInt i]@iterArgs es end
227 :     val const= iterArgs (List.drop(args,1))
228 :     val DstTy.TensorTy rstTy= DstIL.Var.ty y
229 :     val rator=mk.slice (argTy,mask,const,rstTy)
230 :     (* ("aFIXME: Slice{\n\t"^String.concatWith"\n\t,"(List.map SrcIL.Var.toString args))*)
231 :     val a=Env.renameList(env, args)
232 :     in
233 :     [(y,DstIL.EINAPP(rator,a))]
234 :     end
235 : jhr 2356 | SrcOp.Slice(ty, mask) => raise Fail "FIXME: Slice"
236 : jhr 1640 | SrcOp.TensorSub(ty as SrcTy.TensorTy _) => assign (DstOp.Subscript(cvtTy ty))
237 :     | SrcOp.Select(ty as SrcTy.TupleTy _, i) => assign (DstOp.Select(cvtTy ty, i))
238 :     | SrcOp.Select(ty as SrcTy.SeqTy _, i) => assign (DstOp.Index(cvtTy ty, i))
239 : jhr 2356 | SrcOp.SeqSub(ty as SrcTy.SeqTy _) => assign (DstOp.Subscript(cvtTy ty))
240 :     | SrcOp.IntToReal => assign DstOp.IntToReal
241 :     | SrcOp.TruncToInt => cvtToInt (DstOp.Trunc 1)
242 :     | SrcOp.RoundToInt => cvtToInt (DstOp.Round 1)
243 :     | SrcOp.CeilToInt => cvtToInt (DstOp.Ceiling 1)
244 :     | SrcOp.FloorToInt => cvtToInt (DstOp.Floor 1)
245 : cchiw 2522 | SrcOp.Kernel h => assign (DstOp.Kernel h)
246 : cchiw 2838 | SrcOp.LoadImage info => assign (DstOp.LoadImage info)
247 :     | SrcOp.Inside _ =>(case args
248 : jhr 2356 of [pos, fld] => expandInside(env, y, pos, fld)
249 : cchiw 2830 (* end case *))
250 : jhr 2356 (* fields are used in the Inside and Probe operations, but are otherwise ignored *)
251 :     | SrcOp.Input(ty, s, desc) => assign (DstOp.Input(cvtTy ty, s, desc))
252 :     | SrcOp.InputWithDefault(ty, s, desc) =>
253 :     assign (DstOp.InputWithDefault(cvtTy ty, s, desc))
254 :     | rator => raise Fail("bogus operator " ^ SrcOp.toString rator)
255 :     (* end case *)
256 :     end
257 :     handle ex => (print(concat["error converting ", SrcOp.toString rator, "\n"]); raise ex)
258 : cchiw 2522
259 : cchiw 2847 (*checkEINApp: env* midil.var*EIN*mid-ilvar->DstIL.ASSGN list
260 :     * Field operators are changed to zero
261 :     *)
262 :     fun checkEINApp(env, srcy,y, rator, args) = (case (SrcIL.Var.ty srcy)
263 :     of SrcTy.FieldTy =>[DstIL.ASSGN(y,DstIL.LIT(Literal.Int 0))]
264 : cchiw 3033 | _ =>handleEin.expandEinOp(y,DstIL.EINAPP(rator,Env.renameList(env, args)))
265 : cchiw 2847 (*end case*))
266 :    
267 : jhr 387 (* expand a SrcIL assignment to a list of DstIL assignments *)
268 : cchiw 2830 fun expand (env, (y, rhs)) = let
269 : cchiw 2522 fun assign rhs = [DstIL.ASSGN(Env.rename (env, y), rhs)]
270 : cchiw 2847 in
271 : jhr 2356 case rhs
272 : cchiw 2508 of SrcIL.STATE x => (assign (DstIL.STATE(Env.renameSV(env, x))))
273 :     | SrcIL.VAR x => (assign (DstIL.VAR(Env.rename(env, x))))
274 :     | SrcIL.LIT lit => (assign (DstIL.LIT lit))
275 :     | SrcIL.OP(rator, args) =>(
276 :     List.map DstIL.ASSGN (expandOp (env, Env.rename (env, y), rator, args)))
277 :     | SrcIL.APPLY(f, args) => (assign(DstIL.APPLY(f, Env.renameList(env, args))))
278 :     | SrcIL.CONS(ty, args) => (assign (DstIL.CONS(cvtTy ty, Env.renameList(env, args))))
279 : cchiw 2845 | SrcIL.EINAPP(rator, args) =>
280 : cchiw 2847 (checkEINApp (env, y,Env.rename (env, y), rator, args))
281 : jhr 2356 (* end case *)
282 :     end
283 : jhr 364
284 : jhr 1640 (* expand a SrcIL multi-assignment to a DstIL CFG *)
285 :     fun mexpand (env, (ys, rator, xs)) = let
286 :     val ys' = Env.renameList(env, ys)
287 :     val rator' = (case rator
288 :     of SrcOp.Eigen2x2 => DstOp.EigenVecs2x2
289 :     | SrcOp.Eigen3x3 => DstOp.EigenVecs3x3
290 :     | SrcOp.Print tys => DstOp.Print(List.map cvtTy tys)
291 :     | _ => raise Fail("bogus operator " ^ SrcOp.toString rator)
292 :     (* end case *))
293 :     val xs' = Env.renameList(env, xs)
294 :     val nd = DstIL.Node.mkMASSIGN(ys', rator', xs')
295 :     in
296 :     DstIL.CFG{entry=nd, exit=nd}
297 :     end
298 :    
299 : jhr 364 structure Trans = TranslateFn (
300 :     struct
301 : jhr 2356 open Env
302 :     val expand = DstIL.CFG.mkBlock o expand
303 : jhr 1640 val mexpand = mexpand
304 : jhr 364 end)
305 :    
306 : jhr 1116 fun translate prog = let
307 : jhr 2356 val prog = Trans.translate prog
308 :     in
309 :     MidILCensus.init prog;
310 :     prog
311 :     end
312 : jhr 364
313 : jhr 280 end

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