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 2605 - (view) (download)

1 : jhr 280 (* high-to-mid.sml
2 :     *
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 :     structure shift = ShiftEin
26 :     structure split = SplitEin
27 : cchiw 2553 structure E=Ein
28 : jhr 280
29 : cchiw 2510 datatype peanut= O of SrcOp.rator | E of Ein.ein |Nope
30 :    
31 : cchiw 2605 val testing =0
32 : jhr 1116 fun getRHS x = (case SrcIL.Var.binding x
33 : cchiw 2510 of SrcIL.VB_RHS(SrcIL.OP(rator, args)) => (O rator, args)
34 :     | SrcIL.VB_RHS(SrcIL.VAR x') => getRHS x'
35 :     | SrcIL.VB_RHS(SrcIL.EINAPP(rator, args)) => (E rator,args)
36 : cchiw 2515 | vb => (print "eee";raise Fail(concat[
37 :     "expected rhs operator for ", SrcIL.Var.toString x,
38 :     "but found ", SrcIL.vbToString vb
39 :     ]))
40 : cchiw 2510 (* end case *))
41 : jhr 1116
42 : cchiw 2605 (*created so a fail isn't returned. see rename function *)
43 :     fun getRHS2 x = (case SrcIL.Var.binding x
44 :     of SrcIL.VB_RHS(SrcIL.OP(rator, args)) => (O rator, args)
45 :     | SrcIL.VB_RHS(SrcIL.VAR x') => getRHS2 x'
46 :     | SrcIL.VB_RHS(SrcIL.EINAPP(rator, args)) => (E rator,args)
47 :     | _=>(Nope, [])
48 :     (* end case *))
49 : cchiw 2522
50 : jhr 394 fun cvtTy SrcTy.BoolTy = DstTy.BoolTy
51 :     | cvtTy SrcTy.StringTy = DstTy.StringTy
52 :     | cvtTy SrcTy.IntTy = DstTy.intTy
53 : jhr 1116 | cvtTy (SrcTy.TensorTy dd) = DstTy.tensorTy dd
54 : jhr 1640 | cvtTy (SrcTy.TupleTy tys) = DstTy.TupleTy(List.map cvtTy tys)
55 :     | cvtTy (SrcTy.SeqTy(ty, n)) = DstTy.SeqTy(cvtTy ty, n)
56 : jhr 1116 (* we replace Kernel and Field operations by 0, so the types are mapped to int *)
57 : cchiw 2522 | cvtTy SrcTy.KernelTy = DstTy.KernelTy
58 : cchiw 2515 | cvtTy SrcTy.FieldTy = DstTy.intTy
59 : jhr 397 | cvtTy ty = raise Fail("unexpected type " ^ SrcTy.toString ty)
60 : jhr 394
61 : jhr 1640 (* instantiate the translation environment *)
62 :     local
63 :     type var_env = DstIL.var VTbl.hash_table
64 :     type state_var_env = DstIL.state_var SrcSV.Tbl.hash_table
65 :    
66 : cchiw 2510 (*********************FIX*********************)
67 :    
68 : cchiw 2605 fun rename (env : var_env, x) = case VTbl.find env x
69 :     of SOME x' =>( x')
70 :     | NONE => let
71 :     val dstTy = (case SrcIL.Var.ty x
72 :     of SrcTy.ImageTy _ => (
73 :     (* for variables with image type, we need more detailed information
74 : jhr 1640 * about the image for the MidIL type.
75 :     *)
76 :     case getRHS x
77 : cchiw 2510 of (O (SrcOp.LoadImage v), _) => DstTy.ImageTy v
78 : jhr 1640 | _ => raise Fail "bogus image variable"
79 :     (* end case *))
80 :     | _ => cvtTy(SrcIL.Var.ty x)
81 :     (* end case *))
82 : cchiw 2510 val x' = DstIL.Var.new (SrcIL.Var.name x, dstTy)
83 :     in
84 :     VTbl.insert env (x, x');
85 :     x'
86 :     end
87 : cchiw 2515
88 : cchiw 2510 handle Fail msg => raise Fail(concat["rename(_, ", SrcIL.Var.toString x, "): ", msg])
89 : jhr 1116
90 : jhr 2356 fun renameSV (env : state_var_env, x) = (case SrcSV.Tbl.find env x
91 :     of SOME x' => x'
92 :     | NONE => let
93 :     val dstTy = cvtTy (SrcSV.ty x)
94 :     val x' = DstIL.StateVar.new (SrcSV.isOutput x, SrcSV.name x, dstTy)
95 :     in
96 :     SrcSV.Tbl.insert env (x, x');
97 :     x'
98 :     end
99 :     (* end case *))
100 : jhr 1640 in
101 :     structure Env = TranslateEnvFn (
102 :     struct
103 :     structure SrcIL = SrcIL
104 :     structure DstIL = DstIL
105 :     type var_env = var_env
106 :     type state_var_env = state_var_env
107 :     val rename = rename
108 :     val renameSV = renameSV
109 :     end)
110 :     end
111 : jhr 334
112 : jhr 1116 (* expand raising a real to an integer power. When we know the exponent, we can inline
113 :     * multiplications.
114 :     *)
115 :     fun expandPower (env, y, [x, n]) = let
116 : jhr 2356 fun getConst x = (case SrcIL.Var.binding x
117 :     of SrcIL.VB_RHS(SrcIL.VAR x') => getConst x'
118 :     | SrcIL.VB_RHS(SrcIL.LIT(Literal.Int n)) => SOME n
119 :     | vb => NONE
120 :     (* end case *))
121 :     val x = Env.rename(env, x)
122 :     fun pow () = let
123 :     val t = DstIL.Var.new("n", DstTy.realTy)
124 :     in [
125 :     (t, DstIL.OP(DstOp.IntToReal, [Env.rename(env, n)])),
126 :     (y, DstIL.APPLY(MathFuns.pow, [x, t]))
127 :     ] end
128 :     in
129 :     case getConst n
130 :     of SOME 0 => [(y, DstIL.LIT(Literal.Float(FloatLit.one)))]
131 :     | SOME 1 => [(y, DstIL.VAR x)]
132 :     | SOME ~1 => let
133 :     val t = DstIL.Var.new("one", DstTy.realTy)
134 :     in [
135 :     (t, DstIL.LIT(Literal.Float(FloatLit.one))),
136 : cchiw 2496 (y, DstIL.OP(DstOp.IDiv , [t, x]))
137 : jhr 2356 ] end
138 : cchiw 2496 | SOME 2 => [(y, DstIL.OP(DstOp.IMul , [x, x]))]
139 : jhr 1640 (* FIXME: expand into multiplications; ~2 ==> sqrt
140 : jhr 2356 | SOME n =>
141 : jhr 1116 *) | SOME _ => pow()
142 : jhr 2356 | NONE => pow()
143 :     end
144 : jhr 280
145 : jhr 1116 (* expand the field Inside operator into a image-space test *)
146 : cchiw 2496
147 :     (*
148 : jhr 1116 fun expandInside (env, result, pos, fld) = (case getRHS fld
149 : cchiw 2510 of (O(SrcOp.Field d), [img, h]) => (case (getRHS img, getRHS h)
150 :     of (O(SrcOp.LoadImage v), _), (O (SrcOp.Kernel(h, _)), [])) => let
151 : jhr 2356 val pos = Env.rename (env, pos)
152 :     val img = Env.rename (env, img)
153 : cchiw 2496
154 :     (**********FIXME**)
155 : jhr 2356 val imgPos = DstIL.Var.new ("x", DstTy.vecTy d)
156 :     val s = Kernel.support h
157 : cchiw 2397 (*PostoImageSpace*)
158 : jhr 2356 in [
159 :     (imgPos, DstIL.OP(DstOp.PosToImgSpace v, [img, pos])),
160 :     (result, DstIL.OP(DstOp.Inside(v, s), [imgPos, img]))
161 :     ] end
162 :     | _ => raise Fail "bogus kernel binding"
163 :     (* end case *))
164 :     | _ => raise Fail "bogus field binding"
165 : cchiw 2397 (* end case *))
166 : cchiw 2496 *)
167 :    
168 : cchiw 2396
169 : jhr 392 fun arity (SrcTy.TensorTy[]) = 1
170 :     | arity (SrcTy.TensorTy[d]) = d
171 : jhr 365 | arity _ = raise Fail "arity"
172 :    
173 : jhr 364 fun expandOp (env, y, rator, args) = let
174 : jhr 2356 fun assign rator' =
175 :     [(y, DstIL.OP(rator', Env.renameList(env, args)))]
176 :     fun cvtToInt rator' = let
177 :     val t = DstIL.Var.new ("t", DstTy.realTy)
178 :     in [
179 :     (t, DstIL.OP(rator', Env.renameList(env, args))),
180 :     (y, DstIL.OP(DstOp.RealToInt 1, [t]))
181 :     ] end
182 :     fun dummy () = [(y, DstIL.LIT(Literal.Int 0))]
183 :     in
184 :     case rator
185 : cchiw 2396 of SrcOp.IAdd => assign (DstOp.IAdd)
186 :     | SrcOp.ISub => assign (DstOp.ISub)
187 :     | SrcOp.IMul => assign (DstOp.IMul)
188 :     | SrcOp.IDiv => assign (DstOp.IDiv)
189 :     | SrcOp.INeg => assign (DstOp.INeg)
190 : jhr 2356 | SrcOp.Abs ty => assign (DstOp.Abs(cvtTy ty))
191 :     | SrcOp.LT ty => assign (DstOp.LT(cvtTy ty))
192 :     | SrcOp.LTE ty => assign (DstOp.LTE(cvtTy ty))
193 :     | SrcOp.EQ ty => assign (DstOp.EQ(cvtTy ty))
194 :     | SrcOp.NEQ ty => assign (DstOp.NEQ(cvtTy ty))
195 :     | SrcOp.GT ty => assign (DstOp.GT(cvtTy ty))
196 :     | SrcOp.GTE ty => assign (DstOp.GTE(cvtTy ty))
197 :     | SrcOp.Power => expandPower(env, y, args)
198 :     | SrcOp.Not => assign DstOp.Not
199 :     | SrcOp.Max => assign DstOp.Max
200 :     | SrcOp.Min => assign DstOp.Min
201 :     | SrcOp.Clamp ty => assign (DstOp.Clamp(cvtTy ty))
202 :     | SrcOp.Lerp ty => assign (DstOp.Lerp(cvtTy ty))
203 :     | SrcOp.Norm ty => assign (DstOp.Norm(cvtTy ty))
204 :     | SrcOp.Normalize ty => assign (DstOp.Normalize(arity ty))
205 : cchiw 2496
206 : jhr 2356 | SrcOp.PrincipleEvec ty => assign (DstOp.PrincipleEvec(cvtTy ty))
207 : cchiw 2496
208 :     (*| SrcOp.Zero ty => assign (DstOp.Zero(cvtTy ty))*)
209 : jhr 2356 | SrcOp.Slice(ty, mask) => raise Fail "FIXME: Slice"
210 : jhr 1640 | SrcOp.TensorSub(ty as SrcTy.TensorTy _) => assign (DstOp.Subscript(cvtTy ty))
211 :     | SrcOp.Select(ty as SrcTy.TupleTy _, i) => assign (DstOp.Select(cvtTy ty, i))
212 :     | SrcOp.Select(ty as SrcTy.SeqTy _, i) => assign (DstOp.Index(cvtTy ty, i))
213 : jhr 2356 | SrcOp.SeqSub(ty as SrcTy.SeqTy _) => assign (DstOp.Subscript(cvtTy ty))
214 :     | SrcOp.IntToReal => assign DstOp.IntToReal
215 :     | SrcOp.TruncToInt => cvtToInt (DstOp.Trunc 1)
216 :     | SrcOp.RoundToInt => cvtToInt (DstOp.Round 1)
217 :     | SrcOp.CeilToInt => cvtToInt (DstOp.Ceiling 1)
218 :     | SrcOp.FloorToInt => cvtToInt (DstOp.Floor 1)
219 : cchiw 2522 | SrcOp.Kernel h => assign (DstOp.Kernel h)
220 : cchiw 2553 | SrcOp.LoadImage info => [(y, DstIL.OP(DstOp.LoadImage info, []))]
221 :     (*Hard coded change here, cleared arguements*)
222 :     (*assign (DstOp.LoadImage info)*)
223 : cchiw 2496 (*| SrcOp.Inside _ =>
224 :     (case args
225 : jhr 2356 of [pos, fld] => expandInside(env, y, pos, fld)
226 : cchiw 2496 (* end case *))*)
227 : jhr 2356 (* fields are used in the Inside and Probe operations, but are otherwise ignored *)
228 :     | SrcOp.Input(ty, s, desc) => assign (DstOp.Input(cvtTy ty, s, desc))
229 :     | SrcOp.InputWithDefault(ty, s, desc) =>
230 :     assign (DstOp.InputWithDefault(cvtTy ty, s, desc))
231 :     | rator => raise Fail("bogus operator " ^ SrcOp.toString rator)
232 :     (* end case *)
233 :     end
234 :     handle ex => (print(concat["error converting ", SrcOp.toString rator, "\n"]); raise ex)
235 : cchiw 2522
236 :    
237 :     (*Expand then split *)
238 :     fun setEinAp e=let
239 :     val (y,rator,args)=e
240 : cchiw 2605 val _ = (case testing
241 :     of 1 => (print(String.concat["\n \t \t ",split.printA e]);1)
242 :     | _ => 1
243 :     (* end case *))
244 : cchiw 2522 in
245 :     (y, DstIL.EINAPP(rator, args))
246 :     end
247 :    
248 : cchiw 2605
249 : cchiw 2522 fun expandEinOp (env, y, rator, args) = let
250 : cchiw 2605 val einargs=Env.renameList(env, args)
251 : cchiw 2522
252 : cchiw 2605 val _ = (case testing
253 :     of 1=>(print(String.concat[ "\n ----------------------------------------------- \n New One \n", split.printAA(y,rator,args),"\n Args \n ",split.printA (y,rator,einargs)," \n"]);1)
254 :     | _ => 1)
255 : cchiw 2553
256 : cchiw 2605 val ((rator',args'),expcode)= Probe.expandEinOp(rator,args,einargs)
257 :     val (change,newbie)=split.splitein(y,rator',args')
258 :     in (case (change,newbie)
259 :     of (0,[(_,e,a)]) => let
260 :     val _ =(case testing of 0=> 1
261 :     | _ => (print(String.concat["\n No Splits \n ",split.printA(y,e,a)]);1))
262 :     in expcode@[(y, DstIL.EINAPP(e, a))] end
263 :     | _=> expcode@(List.map setEinAp newbie)
264 :     (*end case*))
265 : cchiw 2525
266 : cchiw 2605 end
267 : cchiw 2397
268 : jhr 387 (* expand a SrcIL assignment to a list of DstIL assignments *)
269 : cchiw 2508 fun expand (env, (y, rhs)) = let
270 : cchiw 2605 (*val _ =( case SrcIL.Var.binding y
271 : cchiw 2515 of SrcIL.VB_RHS(SrcIL.EINAPP(rator, args)) => print(String.concat[P.printerE rator ,"\n\n"])
272 : cchiw 2605 |_=>print "")*)
273 : cchiw 2522 fun assign rhs = [DstIL.ASSGN(Env.rename (env, y), rhs)]
274 : cchiw 2508
275 : cchiw 2522 in
276 : jhr 2356 case rhs
277 : cchiw 2508 of SrcIL.STATE x => (assign (DstIL.STATE(Env.renameSV(env, x))))
278 :     | SrcIL.VAR x => (assign (DstIL.VAR(Env.rename(env, x))))
279 :     | SrcIL.LIT lit => (assign (DstIL.LIT lit))
280 :     | SrcIL.OP(rator, args) =>(
281 :     List.map DstIL.ASSGN (expandOp (env, Env.rename (env, y), rator, args)))
282 :     | SrcIL.APPLY(f, args) => (assign(DstIL.APPLY(f, Env.renameList(env, args))))
283 :     | SrcIL.CONS(ty, args) => (assign (DstIL.CONS(cvtTy ty, Env.renameList(env, args))))
284 : cchiw 2605 | SrcIL.EINAPP(rator, args) => List.map (fn (y,rator)=> DstIL.ASSGN(y,rator))
285 : cchiw 2522 (expandEinOp (env, Env.rename (env, y), rator, args))
286 :    
287 : jhr 2356 (* end case *)
288 :     end
289 : jhr 364
290 : jhr 1640 (* expand a SrcIL multi-assignment to a DstIL CFG *)
291 :     fun mexpand (env, (ys, rator, xs)) = let
292 :     val ys' = Env.renameList(env, ys)
293 :     val rator' = (case rator
294 :     of SrcOp.Eigen2x2 => DstOp.EigenVecs2x2
295 :     | SrcOp.Eigen3x3 => DstOp.EigenVecs3x3
296 :     | SrcOp.Print tys => DstOp.Print(List.map cvtTy tys)
297 :     | _ => raise Fail("bogus operator " ^ SrcOp.toString rator)
298 :     (* end case *))
299 :     val xs' = Env.renameList(env, xs)
300 :     val nd = DstIL.Node.mkMASSIGN(ys', rator', xs')
301 :     in
302 :     DstIL.CFG{entry=nd, exit=nd}
303 :     end
304 :    
305 : jhr 364 structure Trans = TranslateFn (
306 :     struct
307 : jhr 2356 open Env
308 :     val expand = DstIL.CFG.mkBlock o expand
309 : jhr 1640 val mexpand = mexpand
310 : jhr 364 end)
311 :    
312 : jhr 1116 fun translate prog = let
313 : jhr 2356 val prog = Trans.translate prog
314 :     in
315 :     MidILCensus.init prog;
316 :     prog
317 :     end
318 : jhr 364
319 : jhr 280 end

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