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 3582 - (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 : jhr 3534 structure SrcTy = HighTypes
19 : jhr 3529 structure SrcOp = HighOps
20 :     structure SrcSV = SrcIR.StateVar
21 :     structure VTbl = SrcIR.Var.Tbl
22 :     structure DstIR = MidIR
23 : jhr 3534 structure DstTy = MidTypes
24 : jhr 3529 structure DstOp = MidOps
25 :     structure InP = Inputs
26 :     structure BCtl = BorderCtl
27 :    
28 :     fun useCount (SrcIR.V{useCnt, ...}) = !useCnt
29 :    
30 : jhr 3534 fun getRHS x = (case SrcIR.Var.binding x
31 :     of SrcIR.VB_RHS(SrcIR.VAR x') => getRHS x'
32 : jhr 3550 | SrcIR.VB_RHS(SrcIR.GLOBAL x') => (case SrcIR.GlobalVar.bindingOf x'
33 :     of SOME x'' => getRHS x''
34 :     | NONE => raise Fail(concat[
35 :     "mutable global ", SrcIR.GlobalVar.toString x',
36 :     " encountered"
37 :     ])
38 :     (* end case *))
39 : jhr 3534 | SrcIR.VB_RHS rhs => rhs
40 : jhr 3529 | vb => raise Fail(concat[
41 : jhr 3534 "expected rhs binding for ", SrcIR.Var.toString x,
42 : jhr 3529 " but found ", SrcIR.vbToString vb
43 :     ])
44 :     (* end case *))
45 :    
46 : jhr 3534 fun getRHSOp x = (case getRHS x
47 :     of SrcIR.OP(rator, args) => (rator, args)
48 :     | rhs => raise Fail(concat[
49 :     "expected rhs operator for ", SrcIR.Var.toString x,
50 :     " but found ", SrcIR.RHS.toString rhs
51 :     ])
52 :     (* end case *))
53 :    
54 : jhr 3529 (* get the image referenced on a RHS and its border control (if any) *)
55 : jhr 3582 fun getRHSImage x = (case getRHSOp x
56 :     of (SrcOp.BorderCtlDefault info, [img, v]) => (info, BCtl.Default v)
57 :     | (SrcOp.BorderCtlClamp info, [img]) => (info, BCtl.clamp)
58 :     | (SrcOp.BorderCtlMirror info, [img]) => (info, BCtl.mirror)
59 :     | (SrcOp.BorderCtlWrap info, [img]) => (info, BCtl.wrap)
60 :     | (SrcOp.LoadImage(SrcTy.ImageTy info, _), _) => (info, BCtl.None)
61 :     | _ => raise Fail "bogus image variable"
62 :     (* end case *))
63 : jhr 3529
64 :     fun cvtTy SrcTy.BoolTy = DstTy.BoolTy
65 :     | cvtTy SrcTy.StringTy = DstTy.StringTy
66 :     | cvtTy SrcTy.IntTy = DstTy.intTy
67 :     | cvtTy (SrcTy.TensorTy dd) = DstTy.tensorTy dd
68 :     | cvtTy (SrcTy.SeqTy(ty, n)) = DstTy.SeqTy(cvtTy ty, n)
69 :     (* we replace Kernel and Field operations by 0, so the types are mapped to int *)
70 :     | cvtTy SrcTy.KernelTy = DstTy.KernelTy
71 :     | cvtTy SrcTy.FieldTy = DstTy.intTy
72 :     | cvtTy (SrcTy.ImageTy info) = DstTy.ImageTy info
73 :     | cvtTy ty = raise Fail("unexpected type " ^ SrcTy.toString ty)
74 :    
75 :     (* instantiate the translation environment *)
76 :     structure Env = TranslateEnvFn (
77 :     struct
78 :     structure SrcIR = SrcIR
79 :     structure DstIR = DstIR
80 :     val cvtTy = cvtTy
81 :     end)
82 :    
83 :     (* expand raising a real to an integer power. When we know the exponent, we can inline
84 :     * multiplications.
85 :     *)
86 :     fun expandPower (env, y, [x, n]) = let
87 :     fun getConst x = (case SrcIR.Var.binding x
88 :     of SrcIR.VB_RHS(SrcIR.VAR x') => getConst x'
89 :     | SrcIR.VB_RHS(SrcIR.LIT(Literal.Int n)) => SOME n
90 :     | vb => NONE
91 :     (* end case *))
92 :     val x = Env.rename(env, x)
93 :     fun pow () = let
94 :     val t = DstIR.Var.new("n", DstTy.realTy)
95 :     in [
96 :     (t, DstIR.OP(DstOp.IntToReal, [Env.rename(env, n)])),
97 : jhr 3582 (y, DstIR.OP(DstOp.MathFn MathFns.POW, [x, t]))
98 : jhr 3529 ] end
99 :     in
100 :     case getConst n
101 : jhr 3534 of SOME 0 => [(y, DstIR.LIT(Literal.Real(RealLit.one)))]
102 : jhr 3529 | SOME 1 => [(y, DstIR.VAR x)]
103 :     | SOME ~1 => let
104 :     val t = DstIR.Var.new("one", DstTy.realTy)
105 :     in [
106 : jhr 3534 (t, DstIR.LIT(Literal.Real(RealLit.one))),
107 : jhr 3529 (* FIXME: shouldn't be IDiv; should be real division! *)
108 : jhr 3548 (y, DstIR.OP(DstOp.IDiv, [t, x]))
109 : jhr 3529 ] end
110 :     (* FIXME: shouldn't be IMul; should be real multiplication! *)
111 : jhr 3548 | SOME 2 => [(y, DstIR.OP(DstOp.IMul, [x, x]))]
112 : jhr 3529 (* FIXME: expand into multiplications
113 :     | SOME n =>
114 :     *) | SOME _ => pow()
115 :     | NONE => pow()
116 :     (* end case *)
117 :     end
118 :    
119 :     (* expand the field Inside operator into a image-space test *)
120 :     fun expandInside (env, result, pos, fld) = (case getRHS fld
121 : jhr 3534 of SrcIR.EINAPP(_, [img, h]) => (case (getRHSImage img, getRHSOp h)
122 :     of ((v, _), (SrcOp.Kernel(h, _), _)) => let
123 : jhr 3529 val pos = Env.rename (env, pos)
124 :     val img = Env.rename (env, img)
125 :     val s = Kernel.support h
126 : jhr 3582 val (_, x, code) = CoordSpaceTransform.worldToImage{info = v, img = img, pos = pos}
127 : jhr 3529 in
128 :     code @ [(result, DstIR.OP(DstOp.Inside(v, s), [x, img]))]
129 :     end
130 :     | _ => raise Fail "bogus kernel binding"
131 :     (* end case *))
132 :     | _ => raise Fail "bogus field binding"
133 :     (* end case *))
134 :    
135 :     fun arity (SrcTy.TensorTy[]) = 1
136 :     | arity (SrcTy.TensorTy[d]) = d
137 :     | arity _ = raise Fail "arity"
138 :    
139 :     fun expandOp (env, y, rator, args) = let
140 :     fun assign rator' =
141 :     [(y, DstIR.OP(rator', Env.renameList(env, args)))]
142 :     fun cvtToInt rator' = let
143 :     val t = DstIR.Var.new ("t", DstTy.realTy)
144 :     in [
145 :     (t, DstIR.OP(rator', Env.renameList(env, args))),
146 :     (y, DstIR.OP(DstOp.RealToInt 1, [t]))
147 :     ] end
148 :     fun dummy () = [(y, DstIR.LIT(Literal.Int 0))]
149 : jhr 3582 fun copy () = let val [x] = args
150 :     in
151 :     [(y, DstIR.VAR(Env.rename(env, x)))]
152 :     end
153 : jhr 3529 in
154 :     case rator
155 : jhr 3582 of SrcOp.IAdd => assign DstOp.IAdd
156 :     | SrcOp.ISub => assign DstOp.ISub
157 :     | SrcOp.IMul => assign DstOp.IMul
158 :     | SrcOp.IDiv => assign DstOp.IDiv
159 :     | SrcOp.IMod => assign DstOp.IMod
160 :     | SrcOp.INeg => assign DstOp.INeg
161 : jhr 3529 | SrcOp.LT ty => assign (DstOp.LT(cvtTy ty))
162 :     | SrcOp.LTE ty => assign (DstOp.LTE(cvtTy ty))
163 :     | SrcOp.EQ ty => assign (DstOp.EQ(cvtTy ty))
164 :     | SrcOp.NEQ ty => assign (DstOp.NEQ(cvtTy ty))
165 :     | SrcOp.GT ty => assign (DstOp.GT(cvtTy ty))
166 :     | SrcOp.GTE ty => assign (DstOp.GTE(cvtTy ty))
167 :     | SrcOp.Power => expandPower(env, y, args)
168 :     | SrcOp.Not => assign DstOp.Not
169 : jhr 3534 | SrcOp.Abs ty => assign (DstOp.Abs(cvtTy ty))
170 :     | SrcOp.Max ty => assign (DstOp.Max(cvtTy ty))
171 :     | SrcOp.Min ty => assign (DstOp.Min(cvtTy ty))
172 : jhr 3529 | SrcOp.Clamp ty => assign (DstOp.Clamp(cvtTy ty))
173 :     | SrcOp.Lerp ty => assign (DstOp.Lerp(cvtTy ty))
174 :     | SrcOp.PrincipleEvec ty => assign (DstOp.PrincipleEvec(cvtTy ty))
175 :     | SrcOp.Zero ty => assign (DstOp.Zero(cvtTy ty))
176 : jhr 3534 | SrcOp.TensorSlice(SrcTy.TensorTy argTy, mask) => let
177 : jhr 3529 val args' = let
178 : jhr 3534 fun f x = let
179 :     val SrcIR.LIT(Literal.Int i) = getRHS x
180 : jhr 3529 in
181 :     IntInf.toInt i
182 :     end
183 :     in
184 :     List.map f (List.drop(args, 1))
185 :     end
186 :     val DstTy.TensorTy rstTy = DstIR.Var.ty y
187 :     val rator = MkOperators.slice (argTy, mask, args', rstTy)
188 :     val a = Env.renameList(env, args)
189 :     in
190 :     [(y, DstIR.EINAPP(rator, a))]
191 :     end
192 : jhr 3534 | SrcOp.TensorIndex(ty as SrcTy.TensorTy _) => assign (DstOp.Subscript(cvtTy ty))
193 : jhr 3529 | SrcOp.Select(ty as SrcTy.SeqTy _, i) => assign (DstOp.Index(cvtTy ty, i))
194 : jhr 3534 | SrcOp.Subscript(ty as SrcTy.SeqTy _) => assign (DstOp.Subscript(cvtTy ty))
195 : jhr 3582 | SrcOp.MkDynamic(ty, n) => assign (DstOp.MkDynamic(cvtTy ty, n))
196 :     | SrcOp.Append ty => assign (DstOp.Append(cvtTy ty))
197 :     | SrcOp.Prepend ty => assign (DstOp.Prepend(cvtTy ty))
198 :     | SrcOp.Concat ty => assign (DstOp.Concat(cvtTy ty))
199 :     | SrcOp.Range => assign DstOp.Range
200 :     | SrcOp.Length ty => assign (DstOp.Length(cvtTy ty))
201 :     | SrcOp.SphereQuery(ty1, ty2) => assign (DstOp.SphereQuery(cvtTy ty1, cvtTy ty2))
202 : jhr 3529 | SrcOp.IntToReal => assign DstOp.IntToReal
203 :     | SrcOp.TruncToInt => cvtToInt (DstOp.Trunc 1)
204 :     | SrcOp.RoundToInt => cvtToInt (DstOp.Round 1)
205 :     | SrcOp.CeilToInt => cvtToInt (DstOp.Ceiling 1)
206 :     | SrcOp.FloorToInt => cvtToInt (DstOp.Floor 1)
207 : jhr 3582 (* FIXME: are we going to use these? *)
208 :     | SrcOp.R_All ty => assign (DstOp.R_All(cvtTy ty))
209 :     | SrcOp.R_Exists ty => assign (DstOp.R_Exists(cvtTy ty))
210 :     | SrcOp.R_Max ty => assign (DstOp.R_Max(cvtTy ty))
211 :     | SrcOp.R_Min ty => assign (DstOp.R_Min(cvtTy ty))
212 :     | SrcOp.R_Sum ty => assign (DstOp.R_Sum(cvtTy ty))
213 :     | SrcOp.R_Product ty => assign (DstOp.R_Product(cvtTy ty))
214 :     | SrcOp.R_Mean ty => assign (DstOp.R_Mean(cvtTy ty))
215 :     | SrcOp.R_Variance ty => assign (DstOp.R_Variance(cvtTy ty))
216 : jhr 3529 | SrcOp.Kernel h => assign (DstOp.Kernel h)
217 :     | SrcOp.Inside _ => (case args
218 :     of [pos, fld] => expandInside(env, y, pos, fld)
219 :     (* end case *))
220 : jhr 3582 | SrcOp.ImageDim(info, i) => assign (DstOp.ImageDim(info, i))
221 :     | SrcOp.BorderCtlDefault info => (case args
222 :     of [x, _] => [(y, DstIR.VAR(Env.rename(env, x)))]
223 :     (* end case *))
224 :     | SrcOp.BorderCtlClamp info => copy()
225 :     | SrcOp.BorderCtlMirror info => copy()
226 :     | SrcOp.BorderCtlWrap info => copy()
227 :     | SrcOp.LoadSeq(ty, file) => assign (DstOp.LoadSeq(cvtTy ty, file))
228 :     | SrcOp.LoadImage(ty, file) => assign (DstOp.LoadImage(cvtTy ty, file))
229 : jhr 3529 | rator => raise Fail("bogus operator " ^ SrcOp.toString rator)
230 :     (* end case *)
231 :     end
232 :     handle ex => (print(concat["error converting ", SrcOp.toString rator, "\n"]); raise ex)
233 :    
234 :     (* expandEINAPP: env* midil.var*EIN*mid-ilvar->DstIR.ASSGN list
235 :     * Field operators are changed to zero
236 :     *)
237 :     fun expandEINAPP (env, srcy, y, rator, args) = (case SrcIR.Var.ty srcy
238 :     of SrcTy.FieldTy => [DstIR.ASSGN(y, DstIR.LIT(Literal.Int 0))]
239 :     | _ => if (useCount srcy > 0)
240 : jhr 3550 then HandleEin.expand (y, rator, Env.renameList(env, args))
241 : jhr 3529 else []
242 :     (* end case *))
243 :     handle ex => (print(concat["error converting: ", MidIR.Var.toString y, " = ",
244 :     EinPP.toString rator, " ", "(", String.concatWithMap ", " HighIR.Var.toString args, ")\n"]);
245 :     raise ex)
246 :    
247 :     (* expand a SrcIR assignment to a list of DstIR assignments *)
248 :     fun expand (env, (y, rhs)) = let
249 :     fun assign rhs = [DstIR.ASSGN(Env.rename (env, y), rhs)]
250 :     in
251 :     case rhs
252 :     of SrcIR.GLOBAL x => assign (DstIR.GLOBAL(Env.renameGV(env, x)))
253 :     | SrcIR.STATE x => assign (DstIR.STATE(Env.renameSV(env, x)))
254 :     | SrcIR.VAR x => assign (DstIR.VAR(Env.rename(env, x)))
255 :     | SrcIR.LIT lit => assign (DstIR.LIT lit)
256 :     | SrcIR.OP(rator, args) =>
257 :     List.map DstIR.ASSGN (expandOp (env, Env.rename (env, y), rator, args))
258 : jhr 3534 | SrcIR.CONS(args, ty) => assign (DstIR.CONS(Env.renameList(env, args), cvtTy ty))
259 :     | SrcIR.SEQ(args, ty) => assign (DstIR.SEQ(Env.renameList(env, args), cvtTy ty))
260 : jhr 3529 | SrcIR.EINAPP(rator, args) =>
261 :     expandEINAPP (env, y, Env.rename (env, y), rator, args)
262 :     (* end case *)
263 :     end
264 :    
265 :     (* expand a SrcIR multi-assignment to a DstIR CFG *)
266 :     fun mexpand (env, (ys, rator, xs)) = let
267 :     val ys' = Env.renameList(env, ys)
268 :     val rator' = (case rator
269 :     of SrcOp.Eigen2x2 => DstOp.EigenVecs2x2
270 :     | SrcOp.Eigen3x3 => DstOp.EigenVecs3x3
271 :     | SrcOp.Print tys => DstOp.Print(List.map cvtTy tys)
272 :     | _ => raise Fail("bogus operator " ^ SrcOp.toString rator)
273 :     (* end case *))
274 :     val xs' = Env.renameList(env, xs)
275 :     val nd = DstIR.Node.mkMASSIGN(ys', rator', xs')
276 :     in
277 :     DstIR.CFG{entry=nd, exit=nd}
278 :     end
279 :    
280 :     structure Trans = TranslateFn (
281 :     struct
282 :     open Env
283 :     val expand = DstIR.CFG.mkBlock o expand
284 :     val mexpand = mexpand
285 :     end)
286 :    
287 :     fun translate prog = let
288 :     (* need a prepass to add Inside tests for border control *)
289 :     val prog = Trans.translate prog
290 :     in
291 : jhr 3534 MidCensus.init prog;
292 : jhr 3529 prog
293 :     end
294 :    
295 :     end

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