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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3529 - (view) (download)

1 : jhr 3529 (* high-to-mid.sml
2 :     *
3 :     * Translation from HighIR to MidIR representations.
4 :     *
5 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
6 :     *
7 :     * COPYRIGHT (c) 2015 The University of Chicago
8 :     * All rights reserved.
9 :     *)
10 :    
11 :     structure HighToMid : sig
12 :    
13 :     val translate : HighIR.program -> MidIR.program
14 :    
15 :     end = struct
16 :    
17 :     structure SrcIR = HighIR
18 :     structure SrcTy = HighIRTypes
19 :     structure SrcOp = HighOps
20 :     structure SrcSV = SrcIR.StateVar
21 :     structure VTbl = SrcIR.Var.Tbl
22 :     structure DstIR = MidIR
23 :     structure DstTy = MidIRTypes
24 :     structure DstOp = MidOps
25 :     structure InP = Inputs
26 :     structure BCtl = BorderCtl
27 :    
28 :     fun getIncUse (DstIR.V{useCnt, ...})= !useCnt
29 :     fun incUseD (DstIR.V{useCnt, ...}) = (useCnt := !useCnt + 1)
30 :     fun useCount (SrcIR.V{useCnt, ...}) = !useCnt
31 :     fun useD x = (incUseD x; x)
32 :     fun iTos e=Int.toString e
33 :     val cnt = ref 0
34 :     fun nameCnt e= String.concat[SrcIR.Var.toString e, "(",Int.toString(useCount e),")"]
35 :     fun genName prefix = let
36 :     val n = !cnt
37 :     in
38 :     cnt := n+1;
39 :     String.concat[prefix, "_", Int.toString n]
40 :     end
41 :    
42 :     fun getRHS x = (case SrcIR.Var.binding x
43 :     of SrcIR.VB_RHS(SrcIR.OP(rator, args)) => (rator, args)
44 :     | SrcIR.VB_RHS(SrcIR.VAR x') => getRHS x'
45 :     | SrcIR.VB_RHS(SrcIR.GLOBAL x') => getRHS(SrcIR.GlobalVar.binding x')
46 :     | vb => raise Fail(concat[
47 :     "expected rhs operator for ", SrcIR.Var.toString x,
48 :     " but found ", SrcIR.vbToString vb
49 :     ])
50 :     (* end case *))
51 :    
52 :     (* get the image referenced on a RHS and its border control (if any) *)
53 :     fun getRHSImage x = let
54 :     fun get x = (case getRHS x
55 :     of (SrcOp.LoadImage(SrcTy.ImageTy v, _), _) => v
56 :     | (SrcOp.Input(InP.INP{init=SOME(InP.Proxy(_, v)), ...}), _) => v
57 :     | (SrcOp.Input(InP.INP{init=SOME(InP.Image v), ...}), _) => v
58 :     | _ => raise Fail "bogus image variable"
59 :     (* end case *))
60 :     in
61 :     case getRHS x
62 :     of (SrcOp.BorderCtlDefault _, [img, v]) => (get img, BCtl.Default v)
63 :     | (SrcOp.BorderCtlClamp _, [img]) => (get img, BCtl.clamp)
64 :     | (SrcOp.BorderCtlMirror _, [img]) => (get img, BCtl.mirror)
65 :     | (SrcOp.BorderCtlWrap _, [img]) => (get img, BCtl.wrap)
66 :     | (SrcOp.LoadImage(SrcTy.ImageTy v, _), _) => (v, BCtl.None)
67 :     | (SrcOp.Input(InP.INP{init=SOME(InP.Proxy(_, v)), ...}), _) => (v, BCtl.None)
68 :     | (SrcOp.Input(InP.INP{init=SOME(InP.Image v), ...}), _) => (v, BCtl.None)
69 :     | _ => raise Fail "bogus image variable"
70 :     (* end case *)
71 :     end
72 :    
73 :     fun cvtTy SrcTy.BoolTy = DstTy.BoolTy
74 :     | cvtTy SrcTy.StringTy = DstTy.StringTy
75 :     | cvtTy SrcTy.IntTy = DstTy.intTy
76 :     | cvtTy (SrcTy.TensorTy dd) = DstTy.tensorTy dd
77 :     | cvtTy (SrcTy.TupleTy tys) = DstTy.TupleTy(List.map cvtTy tys)
78 :     | cvtTy (SrcTy.SeqTy(ty, n)) = DstTy.SeqTy(cvtTy ty, n)
79 :     (* we replace Kernel and Field operations by 0, so the types are mapped to int *)
80 :     | cvtTy SrcTy.KernelTy = DstTy.KernelTy
81 :     | cvtTy SrcTy.FieldTy = DstTy.intTy
82 :     | cvtTy (SrcTy.ImageTy info) = DstTy.ImageTy info
83 :     | cvtTy ty = raise Fail("unexpected type " ^ SrcTy.toString ty)
84 :    
85 :     (* instantiate the translation environment *)
86 :     structure Env = TranslateEnvFn (
87 :     struct
88 :     structure SrcIR = SrcIR
89 :     structure DstIR = DstIR
90 :     val cvtTy = cvtTy
91 :     end)
92 :    
93 :     (* expand raising a real to an integer power. When we know the exponent, we can inline
94 :     * multiplications.
95 :     *)
96 :     fun expandPower (env, y, [x, n]) = let
97 :     fun getConst x = (case SrcIR.Var.binding x
98 :     of SrcIR.VB_RHS(SrcIR.VAR x') => getConst x'
99 :     | SrcIR.VB_RHS(SrcIR.LIT(Literal.Int n)) => SOME n
100 :     | vb => NONE
101 :     (* end case *))
102 :     val x = Env.rename(env, x)
103 :     fun pow () = let
104 :     val t = DstIR.Var.new("n", DstTy.realTy)
105 :     in [
106 :     (t, DstIR.OP(DstOp.IntToReal, [Env.rename(env, n)])),
107 :     (y, DstIR.APPLY(MathFuns.pow, [x, t]))
108 :     ] end
109 :     in
110 :     case getConst n
111 :     of SOME 0 => [(y, DstIR.LIT(Literal.Float(FloatLit.one)))]
112 :     | SOME 1 => [(y, DstIR.VAR x)]
113 :     | SOME ~1 => let
114 :     val t = DstIR.Var.new("one", DstTy.realTy)
115 :     in [
116 :     (t, DstIR.LIT(Literal.Float(FloatLit.one))),
117 :     (* FIXME: shouldn't be IDiv; should be real division! *)
118 :     (y, DstIR.OP(DstOp.IDiv , [t, x]))
119 :     ] end
120 :     (* FIXME: shouldn't be IMul; should be real multiplication! *)
121 :     | SOME 2 => [(y, DstIR.OP(DstOp.IMul , [x, x]))]
122 :     (* FIXME: expand into multiplications
123 :     | SOME n =>
124 :     *) | SOME _ => pow()
125 :     | NONE => pow()
126 :     (* end case *)
127 :     end
128 :    
129 :     (* expand the field Inside operator into a image-space test *)
130 :     fun expandInside (env, result, pos, fld) = (case getRHS fld
131 :     of SrcIR.EINAPP(_, [img, h]) => (case (getRHSImage img, getRHS h)
132 :     of (v, SrcIR.OP(SrcOp.Kernel(h, _), _)) => let
133 :     val pos = Env.rename (env, pos)
134 :     val img = Env.rename (env, img)
135 :     val s = Kernel.support h
136 :     val dim = ImageInfo.dim v
137 :     val (_, x, code) = TransformEin.WorldToImagespace(dim, v, pos, img)
138 :     in
139 :     code @ [(result, DstIR.OP(DstOp.Inside(v, s), [x, img]))]
140 :     end
141 :     | _ => raise Fail "bogus kernel binding"
142 :     (* end case *))
143 :     | _ => raise Fail "bogus field binding"
144 :     (* end case *))
145 :    
146 :     fun arity (SrcTy.TensorTy[]) = 1
147 :     | arity (SrcTy.TensorTy[d]) = d
148 :     | arity _ = raise Fail "arity"
149 :    
150 :     fun expandOp (env, y, rator, args) = let
151 :     fun assign rator' =
152 :     [(y, DstIR.OP(rator', Env.renameList(env, args)))]
153 :     fun cvtToInt rator' = let
154 :     val t = DstIR.Var.new ("t", DstTy.realTy)
155 :     in [
156 :     (t, DstIR.OP(rator', Env.renameList(env, args))),
157 :     (y, DstIR.OP(DstOp.RealToInt 1, [t]))
158 :     ] end
159 :     fun dummy () = [(y, DstIR.LIT(Literal.Int 0))]
160 :     in
161 :     case rator
162 :     of SrcOp.IAdd => assign (DstOp.IAdd)
163 :     | SrcOp.ISub => assign (DstOp.ISub)
164 :     | SrcOp.IMul => assign (DstOp.IMul)
165 :     | SrcOp.IDiv => assign (DstOp.IDiv)
166 :     | SrcOp.IMod => assign (DstOp.IMod)
167 :     | SrcOp.INeg => assign (DstOp.INeg)
168 :     | SrcOp.Abs ty => assign (DstOp.Abs(cvtTy ty))
169 :     | SrcOp.LT ty => assign (DstOp.LT(cvtTy ty))
170 :     | SrcOp.LTE ty => assign (DstOp.LTE(cvtTy ty))
171 :     | SrcOp.EQ ty => assign (DstOp.EQ(cvtTy ty))
172 :     | SrcOp.NEQ ty => assign (DstOp.NEQ(cvtTy ty))
173 :     | SrcOp.GT ty => assign (DstOp.GT(cvtTy ty))
174 :     | SrcOp.GTE ty => assign (DstOp.GTE(cvtTy ty))
175 :     | SrcOp.Power => expandPower(env, y, args)
176 :     | SrcOp.Not => assign DstOp.Not
177 :     | SrcOp.Max => assign DstOp.Max
178 :     | SrcOp.Min => assign DstOp.Min
179 :     | SrcOp.Clamp ty => assign (DstOp.Clamp(cvtTy ty))
180 :     | SrcOp.Lerp ty => assign (DstOp.Lerp(cvtTy ty))
181 :     | SrcOp.Sqrt => assign DstOp.Sqrt
182 :     | SrcOp.Norm(SrcTy.TensorTy []) => assign (DstOp.Abs DstTy.realTy)
183 :     | SrcOp.Norm(SrcTy.TensorTy alpha) => let
184 :     (* Note Norm is implemented with EINAPP as a summation over modulate then sqrt *)
185 :     val t = DstIR.Var.new (genName "t", DstTy.realTy)
186 :     val t = useD t
187 :     val a = Env.renameList(env, args)
188 :     in [
189 :     (t, DstIR.EINAPP(MkOperators.magnitudeTT alpha, a@a)),
190 :     (y, DstIR.OP(DstOp.Sqrt, [t]))
191 :     ] end
192 :     | SrcOp.Normalize ty => assign (DstOp.Normalize(arity ty))
193 :     | SrcOp.PrincipleEvec ty => assign (DstOp.PrincipleEvec(cvtTy ty))
194 :     | SrcOp.Zero ty => assign (DstOp.Zero(cvtTy ty))
195 :     | SrcOp.Slice(SrcTy.TensorTy argTy, mask) => let
196 :     val args' = let
197 :     fun f e = let
198 :     val SrcIR.LIT(Literal.Int i) = getRHS e
199 :     in
200 :     IntInf.toInt i
201 :     end
202 :     in
203 :     List.map f (List.drop(args, 1))
204 :     end
205 :     val DstTy.TensorTy rstTy = DstIR.Var.ty y
206 :     val rator = MkOperators.slice (argTy, mask, args', rstTy)
207 :     val a = Env.renameList(env, args)
208 :     in
209 :     [(y, DstIR.EINAPP(rator, a))]
210 :     end
211 :     | SrcOp.Slice(ty, mask) => raise Fail "FIXME: Slice"
212 :     | SrcOp.TensorSub(ty as SrcTy.TensorTy _) => assign (DstOp.Subscript(cvtTy ty))
213 :     | SrcOp.Select(ty as SrcTy.TupleTy _, i) => assign (DstOp.Select(cvtTy ty, i))
214 :     | SrcOp.Select(ty as SrcTy.SeqTy _, i) => assign (DstOp.Index(cvtTy ty, i))
215 :     | SrcOp.SeqSub(ty as SrcTy.SeqTy _) => assign (DstOp.Subscript(cvtTy ty))
216 :     | SrcOp.IntToReal => assign DstOp.IntToReal
217 :     | SrcOp.TruncToInt => cvtToInt (DstOp.Trunc 1)
218 :     | SrcOp.RoundToInt => cvtToInt (DstOp.Round 1)
219 :     | SrcOp.CeilToInt => cvtToInt (DstOp.Ceiling 1)
220 :     | SrcOp.FloorToInt => cvtToInt (DstOp.Floor 1)
221 :     | SrcOp.Kernel h => assign (DstOp.Kernel h)
222 :     | SrcOp.Inside _ => (case args
223 :     of [pos, fld] => expandInside(env, y, pos, fld)
224 :     (* end case *))
225 :     | SrcOp.LoadImage(ty, nrrd, info) =>
226 :     assign (DstOp.LoadImage(DstTy.ImageTy info, nrrd, info))
227 :     | SrcOp.Input inp => (case Inputs.imageInfo inp
228 :     of SOME info => let
229 :     val Inputs.INP{name, desc, init, ...} = inp
230 :     in
231 :     assign (DstOp.Input(Inputs.INP{
232 :     ty = DstTy.ImageTy info,
233 :     name = name, desc = desc,
234 :     init = init
235 :     }))
236 :     end
237 :     | _ => assign (DstOp.Input(Inputs.map cvtTy inp))
238 :     (* end case *))
239 :     | rator => raise Fail("bogus operator " ^ SrcOp.toString rator)
240 :     (* end case *)
241 :     end
242 :     handle ex => (print(concat["error converting ", SrcOp.toString rator, "\n"]); raise ex)
243 :    
244 :     (* expandEINAPP: env* midil.var*EIN*mid-ilvar->DstIR.ASSGN list
245 :     * Field operators are changed to zero
246 :     *)
247 :     fun expandEINAPP (env, srcy, y, rator, args) = (case SrcIR.Var.ty srcy
248 :     of SrcTy.FieldTy => [DstIR.ASSGN(y, DstIR.LIT(Literal.Int 0))]
249 :     | _ => if (useCount srcy > 0)
250 :     then HandleEin.expandEinOp (srcy, (y, DstIR.EINAPP(rator, Env.renameList(env, args))))
251 :     else []
252 :     (* end case *))
253 :     handle ex => (print(concat["error converting: ", MidIR.Var.toString y, " = ",
254 :     EinPP.toString rator, " ", "(", String.concatWithMap ", " HighIR.Var.toString args, ")\n"]);
255 :     raise ex)
256 :    
257 :     (* expand a SrcIR assignment to a list of DstIR assignments *)
258 :     fun expand (env, (y, rhs)) = let
259 :     fun assign rhs = [DstIR.ASSGN(Env.rename (env, y), rhs)]
260 :     in
261 :     case rhs
262 :     of SrcIR.GLOBAL x => assign (DstIR.GLOBAL(Env.renameGV(env, x)))
263 :     | SrcIR.STATE x => assign (DstIR.STATE(Env.renameSV(env, x)))
264 :     | SrcIR.VAR x => assign (DstIR.VAR(Env.rename(env, x)))
265 :     | SrcIR.LIT lit => assign (DstIR.LIT lit)
266 :     | SrcIR.OP(rator, args) =>
267 :     List.map DstIR.ASSGN (expandOp (env, Env.rename (env, y), rator, args))
268 :     | SrcIR.CONS(ty, args) => assign (DstIR.CONS(cvtTy ty, Env.renameList(env, args)))
269 :     | SrcIR.EINAPP(rator, args) =>
270 :     expandEINAPP (env, y, Env.rename (env, y), rator, args)
271 :     (* end case *)
272 :     end
273 :    
274 :     (* expand a SrcIR multi-assignment to a DstIR CFG *)
275 :     fun mexpand (env, (ys, rator, xs)) = let
276 :     val ys' = Env.renameList(env, ys)
277 :     val rator' = (case rator
278 :     of SrcOp.Eigen2x2 => DstOp.EigenVecs2x2
279 :     | SrcOp.Eigen3x3 => DstOp.EigenVecs3x3
280 :     | SrcOp.Print tys => DstOp.Print(List.map cvtTy tys)
281 :     | _ => raise Fail("bogus operator " ^ SrcOp.toString rator)
282 :     (* end case *))
283 :     val xs' = Env.renameList(env, xs)
284 :     val nd = DstIR.Node.mkMASSIGN(ys', rator', xs')
285 :     in
286 :     DstIR.CFG{entry=nd, exit=nd}
287 :     end
288 :    
289 :     structure Trans = TranslateFn (
290 :     struct
291 :     open Env
292 :     val expand = DstIR.CFG.mkBlock o expand
293 :     val mexpand = mexpand
294 :     end)
295 :    
296 :     fun translate prog = let
297 :     (* need a prepass to add Inside tests for border control *)
298 :     val prog = Trans.translate prog
299 :     in
300 :     MidIRCensus.init prog;
301 :     prog
302 :     end
303 :    
304 :     end

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