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

SCM Repository

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

Diff of /branches/vis12/src/compiler/high-to-mid/high-to-mid.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 511, Tue Feb 8 17:01:43 2011 UTC revision 1116, Thu May 5 04:49:02 2011 UTC
# Line 22  Line 22 
22    
23      type var_env = DstIL.var VTbl.hash_table      type var_env = DstIL.var VTbl.hash_table
24    
25        fun getRHS x  = (case SrcIL.Var.binding x
26               of SrcIL.VB_RHS(SrcIL.OP(rator, args)) => (rator, args)
27                | SrcIL.VB_RHS(SrcIL.VAR x') => getRHS x'
28                | vb => raise Fail(concat[
29                      "expected rhs operator for ", SrcIL.Var.toString x,
30                      "but found ", SrcIL.vbToString vb
31                    ])
32              (* end case *))
33    
34      fun cvtTy SrcTy.BoolTy = DstTy.BoolTy      fun cvtTy SrcTy.BoolTy = DstTy.BoolTy
35        | cvtTy SrcTy.StringTy = DstTy.StringTy        | cvtTy SrcTy.StringTy = DstTy.StringTy
36        | cvtTy SrcTy.IntTy = DstTy.intTy        | cvtTy SrcTy.IntTy = DstTy.intTy
37        | cvtTy (SrcTy.TensorTy[]) = DstTy.realTy        | cvtTy (SrcTy.TensorTy dd) = DstTy.tensorTy dd
38        | cvtTy (SrcTy.TensorTy[d]) = DstTy.VecTy d      (* we replace Kernel and Field operations by 0, so the types are mapped to int *)
39        | cvtTy SrcTy.ImageTy = DstTy.ImageTy        | cvtTy SrcTy.KernelTy = DstTy.intTy
40          | cvtTy SrcTy.FieldTy = DstTy.intTy
41        | cvtTy ty = raise Fail("unexpected type " ^ SrcTy.toString ty)        | cvtTy ty = raise Fail("unexpected type " ^ SrcTy.toString ty)
42    
43      fun rename (env : var_env, x) = (case VTbl.find env x      fun rename (env : var_env, x) = (case VTbl.find env x
44             of SOME x' => x'             of SOME x' => x'
45              | NONE => let              | NONE => let
46                  val x' = DstIL.Var.new (SrcIL.Var.name x, cvtTy(SrcIL.Var.ty x))                  val dstTy = (case SrcIL.Var.ty x
47                           of SrcTy.ImageTy _ => (
48                              (* for variables with image type, we need more detailed information
49                               * about the image for the MidIL type.
50                               *)
51                                case getRHS x
52                                 of (SrcOp.LoadImage v, _) => DstTy.ImageTy v
53                                  | _ => raise Fail "bogus image variable"
54                                (* end case *))
55                            | _ => cvtTy(SrcIL.Var.ty x)
56                          (* end case *))
57                    val x' = DstIL.Var.new (SrcIL.Var.name x, dstTy)
58                  in                  in
59                    VTbl.insert env (x, x');                    VTbl.insert env (x, x');
60                    x'                    x'
61                  end                  end
62            (* end case *))            (* end case *))
63    handle Fail msg => raise Fail(concat["rename(_, ", SrcIL.Var.toString x, "): ", msg])
64    
65      fun renameList (env, xs) = List.map (fn x => rename(env, x)) xs      fun renameList (env, xs) = List.map (fn x => rename(env, x)) xs
66    
67    (* expand the field Inside operator into a image-space test *)    (* expand raising a real to an integer power.  When we know the exponent, we can inline
68      fun expandInside (env, result, pos, fld) = let     * multiplications.
69            val pos = rename (env, pos)     *)
70            val fld = (case SrcIL.Var.binding fld      fun expandPower (env, y, [x, n]) = let
71                   of SrcIL.VB_RHS(SrcIL.OP(SrcOp.Field fld, [])) => fld            fun getConst x = (case SrcIL.Var.binding x
72                    | _ => raise Fail "bogus field binding"                   of SrcIL.VB_RHS(SrcIL.VAR x') => getConst x'
73                      | SrcIL.VB_RHS(SrcIL.LIT(Literal.Int n)) => SOME n
74                      | vb => NONE
75                  (* end case *))                  (* end case *))
76            fun expand (FieldDef.CONV(_, img, _)) = let            val x = rename(env, x)
77                  val imgPos = DstIL.Var.new ("x", DstTy.VecTy(ImageInfo.dim img))            fun pow () = let
78                    val t = DstIL.Var.new("n", DstTy.realTy)
79                  in [                  in [
80                    (imgPos, DstIL.OP(DstOp.PosToImgSpace img, [pos])),                    (t, DstIL.OP(DstOp.IntToReal, [rename(env, n)])),
81                    (result, DstIL.OP(DstOp.Inside img, [imgPos]))                    (y, DstIL.APPLY(ILBasis.pow, [x, t]))
82                  ] end                  ] end
             | expand (FieldDef.NEG fld) = expand fld  
             | expand (FieldDef.SUM(fld1, dlf2)) = raise Fail "expandInside: SUM"  
83            in            in
84              expand fld              case getConst n
85                 of SOME 0 => [(y, DstIL.LIT(Literal.Float(FloatLit.one)))]
86                  | SOME 1 => [(y, DstIL.VAR x)]
87                  | SOME ~1 => let
88                      val t = DstIL.Var.new("one", DstTy.realTy)
89                      in [
90                        (t, DstIL.LIT(Literal.Float(FloatLit.one))),
91                        (y, DstIL.OP(DstOp.Div DstTy.realTy, [t, x]))
92                      ] end
93    (* FIXME: expand into multiplications
94                  | SOME n =>
95    *) | SOME _ => pow()
96                  | NONE => pow()
97            end            end
98    
99      fun expandProbe (env, result, fld, pos) = let    (* expand the field Inside operator into a image-space test *)
100        fun expandInside (env, result, pos, fld) = (case getRHS fld
101               of (SrcOp.Field d, [img, h]) => (case (getRHS img, getRHS h)
102                     of ((SrcOp.LoadImage v, _), (SrcOp.Kernel(h, _), [])) => let
103            val pos = rename (env, pos)            val pos = rename (env, pos)
104            val fld = (case SrcIL.Var.binding fld                        val img = rename (env, img)
105                   of SrcIL.VB_RHS(SrcIL.OP(SrcOp.Field fld, [])) => fld                        val imgPos = DstIL.Var.new ("x", DstTy.vecTy d)
106                          val s = Kernel.support h
107                          in [
108                            (imgPos, DstIL.OP(DstOp.PosToImgSpace v, [img, pos])),
109                            (result, DstIL.OP(DstOp.Inside(v, s), [imgPos, img]))
110                          ] end
111                      | _ => raise Fail "bogus kernel binding"
112                    (* end case *))
113                    | _ => raise Fail "bogus field binding"                    | _ => raise Fail "bogus field binding"
114                  (* end case *))                  (* end case *))
115    
116        fun expandProbe (env, result, fld, pos) = (case getRHS fld
117               of (SrcOp.Field _, [img, h]) => (case (getRHS img, getRHS h)
118                     of ((SrcOp.LoadImage v, _), (SrcOp.Kernel(h, k), _)) => Probe.expand {
119                            result = result,
120                            img = rename (env, img),
121                            v = v, h = h, k = k,
122                            pos = rename (env, pos)
123                          }
124                      | _ => raise Fail "bogus image/kernel binding"
125                    (* end case *))
126                | _ => raise Fail "bogus field binding"
127              (* end case *))
128    
129      (* expand the outer product of vectors v1 and v2, with dimensions d1 and d2 (resp.) *)
130        fun expandOuter (env, y, d1, d2, v1, v2) = let
131              val rowTy = DstTy.tensorTy[d1]
132              val colTy = DstTy.tensorTy[d2]
133              fun mkVar (i, j) = DstIL.Var.new (concat["o_", Int.toString i, "_", Int.toString j], DstTy.realTy)
134              fun mkRowVar i = DstIL.Var.new ("r_" ^ Int.toString i, DstTy.TensorTy[d2])
135              fun rowLp (i, rowVars, code) = if (i < d1)
136                    then let
137                      fun colLp (j, colVars, code) = if (j < d2)
138                            then let
139                              val a = DstIL.Var.new("a", DstTy.realTy)
140                              val ix = DstIL.Var.new("i", DstTy.intTy)
141                              val b = DstIL.Var.new("b", DstTy.realTy)
142                              val jx = DstIL.Var.new("j", DstTy.intTy)
143                              val x = mkVar (i, j)
144                              val code = (x, DstIL.OP(DstOp.Mul DstTy.realTy, [a, b]))
145                                    :: (b, DstIL.OP(DstOp.Subscript colTy, [v2, jx]))
146                                    :: (jx, DstIL.LIT(Literal.intLit j))
147                                    :: (a, DstIL.OP(DstOp.Subscript rowTy, [v1, ix]))
148                                    :: (ix, DstIL.LIT(Literal.intLit i))
149                                    :: code
150            in            in
151              Probe.expand (result, fld, pos)                              colLp (j+1, x::colVars, code)
152                              end
153                            else let
154                              val r = mkRowVar i
155                              in
156                                rowLp (i+1, r::rowVars,
157                                  (r, DstIL.CONS(rowTy, List.rev colVars)) :: code)
158                              end
159                      in
160                        colLp (0, [], code)
161                      end
162                    else List.rev ((y, DstIL.CONS(DstTy.TensorTy[d1,d2], List.rev rowVars)) :: code)
163              in
164                rowLp (0, [], [])
165            end            end
166    
167      fun arity (SrcTy.TensorTy[]) = 1      fun arity (SrcTy.TensorTy[]) = 1
# Line 77  Line 171 
171      fun expandOp (env, y, rator, args) = let      fun expandOp (env, y, rator, args) = let
172            fun assign rator' =            fun assign rator' =
173                  [(y, DstIL.OP(rator', renameList(env, args)))]                  [(y, DstIL.OP(rator', renameList(env, args)))]
174              fun cvtToInt rator' = let
175                    val t = DstIL.Var.new ("t", DstTy.realTy)
176                    in [
177                      (t, DstIL.OP(rator', renameList(env, args))),
178                      (y, DstIL.OP(DstOp.RealToInt 1, [t]))
179                    ] end
180              fun dummy () = [(y, DstIL.LIT(Literal.Int 0))]
181            in            in
182              case rator              case rator
183               of SrcOp.Add ty => assign (DstOp.Add(cvtTy ty))               of SrcOp.Add ty => assign (DstOp.Add(cvtTy ty))
# Line 84  Line 185 
185                | SrcOp.Mul ty => assign (DstOp.Mul(cvtTy ty))                | SrcOp.Mul ty => assign (DstOp.Mul(cvtTy ty))
186                | SrcOp.Div ty => assign (DstOp.Div(cvtTy ty))                | SrcOp.Div ty => assign (DstOp.Div(cvtTy ty))
187                | SrcOp.Neg ty => assign (DstOp.Neg(cvtTy ty))                | SrcOp.Neg ty => assign (DstOp.Neg(cvtTy ty))
188                  | SrcOp.Abs ty => assign (DstOp.Abs(cvtTy ty))
189                | SrcOp.LT ty => assign (DstOp.LT(cvtTy ty))                | SrcOp.LT ty => assign (DstOp.LT(cvtTy ty))
190                | SrcOp.LTE ty => assign (DstOp.LTE(cvtTy ty))                | SrcOp.LTE ty => assign (DstOp.LTE(cvtTy ty))
191                | SrcOp.EQ ty => assign (DstOp.EQ(cvtTy ty))                | SrcOp.EQ ty => assign (DstOp.EQ(cvtTy ty))
192                | SrcOp.NEQ ty => assign (DstOp.NEQ(cvtTy ty))                | SrcOp.NEQ ty => assign (DstOp.NEQ(cvtTy ty))
193                | SrcOp.GT ty => assign (DstOp.GT(cvtTy ty))                | SrcOp.GT ty => assign (DstOp.GT(cvtTy ty))
194                | SrcOp.GTE ty => assign (DstOp.GTE(cvtTy ty))                | SrcOp.GTE ty => assign (DstOp.GTE(cvtTy ty))
195                  | SrcOp.Power => expandPower(env, y, args)
196                  | SrcOp.Not => assign DstOp.Not
197                  | SrcOp.Max => assign DstOp.Max
198                  | SrcOp.Min => assign DstOp.Min
199                  | SrcOp.Lerp ty => assign (DstOp.Lerp(cvtTy ty))
200                | SrcOp.Dot ty => assign (DstOp.Dot(arity ty))                | SrcOp.Dot ty => assign (DstOp.Dot(arity ty))
201                  | SrcOp.MulVecMat(SrcTy.TensorTy[d1, d2]) => assign (DstOp.MulVecMat(d1, d2))
202                  | SrcOp.MulMatVec(SrcTy.TensorTy[d1, d2]) => assign (DstOp.MulMatVec(d1, d2))
203                  | SrcOp.MulMatMat(SrcTy.TensorTy[d1, d2], SrcTy.TensorTy[d2', d3]) =>
204                      assign (DstOp.MulMatMat(d1, d2, d3))
205                | SrcOp.Cross => assign DstOp.Cross                | SrcOp.Cross => assign DstOp.Cross
206                | SrcOp.Norm ty => assign (DstOp.Norm(arity ty))                | SrcOp.Outer(SrcTy.TensorTy[d1, d2]) => let
207                | SrcOp.Scale ty => assign (DstOp.Scale(arity ty))                    val [v1, v2] = renameList(env, args)
208                | SrcOp.InvScale ty => assign (DstOp.InvScale(arity ty))                    in
209                        expandOuter (env, y, d1, d2, v1, v2)
210                      end
211                  | SrcOp.Norm ty => assign (DstOp.Norm(cvtTy ty))
212                  | SrcOp.Normalize ty => assign (DstOp.Normalize(arity ty))
213                  | SrcOp.Scale ty => assign (DstOp.Scale(cvtTy ty))
214                | SrcOp.CL => assign DstOp.CL                | SrcOp.CL => assign DstOp.CL
215                | SrcOp.PrincipleEvec ty => assign (DstOp.PrincipleEvec(cvtTy ty))                | SrcOp.PrincipleEvec ty => assign (DstOp.PrincipleEvec(cvtTy ty))
216                  | SrcOp.Identity n => assign (DstOp.Identity n)
217                  | SrcOp.Zero ty => assign (DstOp.Zero(cvtTy ty))
218                  | SrcOp.Trace(SrcTy.TensorTy[d, _]) => assign (DstOp.Trace d)
219                  | SrcOp.Slice(ty, mask) => raise Fail "FIXME: Slice"
220                | SrcOp.Subscript ty => assign (DstOp.Subscript(cvtTy ty))                | SrcOp.Subscript ty => assign (DstOp.Subscript(cvtTy ty))
               | SrcOp.Max => assign DstOp.Max  
               | SrcOp.Min => assign DstOp.Min  
               | SrcOp.Sin => assign DstOp.Sin  
               | SrcOp.Cos => assign DstOp.Cos  
               | SrcOp.Pow => assign DstOp.Pow  
               | SrcOp.Not => assign DstOp.Not  
221                | SrcOp.IntToReal => assign DstOp.IntToReal                | SrcOp.IntToReal => assign DstOp.IntToReal
222                | SrcOp.TruncToInt => assign (DstOp.TruncToInt 1)                | SrcOp.TruncToInt => cvtToInt (DstOp.Trunc 1)
223                | SrcOp.RoundToInt => assign (DstOp.RoundToInt 1)                | SrcOp.RoundToInt => cvtToInt (DstOp.Round 1)
224                | SrcOp.CeilToInt => assign (DstOp.CeilToInt 1)                | SrcOp.CeilToInt => cvtToInt (DstOp.Ceiling 1)
225                | SrcOp.FloorToInt => assign (DstOp.FloorToInt 1)                | SrcOp.FloorToInt => cvtToInt (DstOp.Floor 1)
226                  | SrcOp.Kernel _ => dummy()
227                | SrcOp.LoadImage info => assign (DstOp.LoadImage info)                | SrcOp.LoadImage info => assign (DstOp.LoadImage info)
228                | SrcOp.Inside _ => (case args                | SrcOp.Inside _ => (case args
229                     of [pos, fld] => expandInside(env, y, pos, fld)                     of [pos, fld] => expandInside(env, y, pos, fld)
230                    (* end case *))                    (* end case *))
               | SrcOp.Field fld => raise Fail "impossible"  
231                | SrcOp.Probe _ => (case args                | SrcOp.Probe _ => (case args
232                     of [fld, pos] => expandProbe(env, y, fld, pos)                     of [fld, pos] => expandProbe(env, y, fld, pos)
233                    (* end case *))                    (* end case *))
234                (* fields are used in the Inside and Probe operations, but are otherwise ignored *)
235                  | SrcOp.Field _ => dummy()
236                  | SrcOp.AddField => dummy()
237                  | SrcOp.SubField => dummy()
238                  | SrcOp.ScaleField => dummy()
239                  | SrcOp.NegField => dummy()
240                  | SrcOp.DiffField => dummy()
241                | SrcOp.Input(ty, s) => assign (DstOp.Input(cvtTy ty, s))                | SrcOp.Input(ty, s) => assign (DstOp.Input(cvtTy ty, s))
242                | SrcOp.InputWithDefault(ty, s) => assign (DstOp.InputWithDefault(cvtTy ty, s))                | SrcOp.InputWithDefault(ty, s) => assign (DstOp.InputWithDefault(cvtTy ty, s))
243                | _ => raise Fail("unexpected " ^ SrcOp.toString rator)                | rator => raise Fail("bogus operator " ^ SrcOp.toString rator)
244              (* end case *)              (* end case *)
245            end            end
246    
# Line 132  Line 253 
253                | SrcIL.LIT lit => assign (DstIL.LIT lit)                | SrcIL.LIT lit => assign (DstIL.LIT lit)
254                | SrcIL.OP(SrcOp.Field _, args) => []                | SrcIL.OP(SrcOp.Field _, args) => []
255                | SrcIL.OP(rator, args) => expandOp (env, rename (env, y), rator, args)                | SrcIL.OP(rator, args) => expandOp (env, rename (env, y), rator, args)
256                | SrcIL.CONS args => assign (DstIL.CONS(renameList(env, args)))                | SrcIL.APPLY(f, args) => assign(DstIL.APPLY(f, renameList(env, args)))
257                  | SrcIL.CONS(ty, args) => assign (DstIL.CONS(cvtTy ty, renameList(env, args)))
258              (* end case *)              (* end case *)
259            end            end
260    
# Line 144  Line 266 
266          type var_env = var_env          type var_env = var_env
267    
268          val rename = rename          val rename = rename
269          val expand = expand          val renameList = renameList
270            val expand = DstIL.CFG.mkBlock o expand
271        end)        end)
272    
273      fun translate (SrcIL.Program{globals, globalInit, strands}) = let      fun translate prog = let
274            val env = VTbl.mkTable (256, Fail "env")            val prog = Trans.translate prog
           fun transMethod (SrcIL.Method{name, stateIn, stateOut, body}) =  
                 DstIL.Method{  
                     name = name,  
                     stateIn = renameList (env, stateIn),  
                     stateOut = renameList (env, stateOut),  
                     body = Trans.translate (env, body)  
                   }  
           fun transStrand (SrcIL.Strand{name, params, state, stateInit, methods}) =  
                 DstIL.Strand{  
                     name = name,  
                     params = renameList (env, params),  
                     state = renameList (env, state),  
                     stateInit = Trans.translate (env, stateInit),  
                     methods = List.map transMethod methods  
                   }  
         (* filter out field variables, since they will be made explicit in  
          * the MidIL.  
          *)  
           val globals = let  
                 fun filter x = (case SrcIL.Var.ty x  
                        of SrcTy.FieldTy => NONE  
                         | _ => SOME x  
                       (* end case *))  
275                  in                  in
276                    List.mapPartial filter globals              MidILCensus.init prog;
277                  end              prog
           in  
             DstIL.Program{  
                 globals = renameList (env, globals),  
                 globalInit = Trans.translate (env, globalInit),  
                 strands = List.map transStrand strands  
               }  
278            end            end
279    
280    end    end

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

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