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

SCM Repository

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

Annotation of /branches/vis15/src/compiler/mid-to-low/eval-img.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3745 - (view) (download)

1 : jhr 3745 (* eval-img.sml
2 :     *
3 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2016 The University of Chicago
6 :     * All rights reserved.
7 :     *)
8 :    
9 : cchiw 3744 structure EvalImg : sig
10 :    
11 : jhr 3745 (* expand a MidIR probe to LowIR code. The arguments are:
12 :     *
13 :     * avail -- available LowIR assignments
14 :     * mapp -- mapping from iteration indices to deBruijn indices
15 :     * sx -- summation bounds
16 :     * imgexp -- ein expression for image expression
17 :     * args -- the actual arguments of the enclosing Ein expression
18 :     *)
19 : cchiw 3744 val expand : {
20 : jhr 3745 avail : AvailRHS.t,
21 :     mapp : int IntRedBlackMap.map,
22 :     sx : Ein.sumrange list,
23 :     imgexp : Ein.ein_exp,
24 :     args : LowIR.var list
25 :     } -> LowIR.var list
26 : cchiw 3744
27 : jhr 3745 end = struct
28 : cchiw 3744
29 : cchiw 3741 structure Op = LowOps
30 :     structure Ty = LowTypes
31 : cchiw 3743 structure IR = LowIR
32 : cchiw 3744 structure Var = IR.Var
33 : cchiw 3741 structure E = Ein
34 :     structure P = EinPP
35 :     structure Mk = MkLowIR
36 :     structure IMap = IntRedBlackMap
37 :    
38 : jhr 3745 fun assignOP (avail, opss, args, pre, ty) = AvailRHS.addAssign(avail, pre, ty, IR.OP(opss, args))
39 : cchiw 3743 fun mkAddPtr (avail, args, ty) = assignOP (avail, Op.RAdd, args, "addPtr", ty)
40 :     fun mkProdInt (avail, args) = assignOP (avail, Op.RMul, args, "prodInt", Ty.intTy)
41 : jhr 3745 fun mkInt (avail, n) = Mk.intLit(avail, IntInf.fromInt n)
42 : cchiw 3741
43 : jhr 3745 (* The image "vImg" is probed at positions
44 :     * Σ_{sx} V_alpha[pos0::px]
45 :     * sumPos () iterates over the summation indices and creates a mapp for the indicies
46 :     * once mapp (j->2 k->0) is created sumPos () calls createImgVar () to get the addr
47 :     * of Σ_k V_{i}[T_j, T_k] createImgVar () uses mkpos (), getPosAddr (), and
48 :     * getImgAddr () to get imgvar
49 :     *)
50 : cchiw 3744 fun expand{avail, mapp, sx, imgexp, args} = let
51 : jhr 3745 val E.Img(imgId, v_alpha, pos0::px, s, border) = imgexp
52 :     val range = 2*s
53 :     val lb = 1-s
54 : cchiw 3744 (* get the image argument *)
55 : jhr 3745 val vImg = List.nth(args, imgId)
56 :     val imgInfo = (case IR.Var.getDef vImg
57 :     of IR.OP(Op.LoadImage(Ty.ImageTy img, _), _) => img
58 :     | IR.GLOBAL gv => raise Fail "FIXME: input variable"
59 :     | _ => raise Fail "unable to get image argument"
60 :     (* end case *))
61 :     val dim = ImageInfo.dim imgInfo
62 :     val ptyTy = Ty.AddrTy imgInfo
63 :     val sizes = ImageInfo.sizes imgInfo
64 : cchiw 3741 (*base address*)
65 : jhr 3745 val vBase = assignOP (avail, Op.BaseAddr imgInfo, [vImg], "baseAddr", ptyTy)
66 : cchiw 3741 (*shift of the image field.*)
67 : jhr 3745 val vShapeShift = mkInt (avail, foldl (fn (a, b) => b*a) 1 (ImageInfo.voxelShape imgInfo))
68 :     (* Since the image is loaded as a vector
69 :     * we evaluate the first position just once
70 :     * Σ_{ij..} V[T+i, T+j...]-> Σ_{j..} V[T+j...]
71 :     * and we drop the first summation index
72 :     * Additionally, summation indices are reversed
73 :     * that inner loop is second (y) axis and outer loop is third (z) axis
74 :     *)
75 :     val (vPos0, sxx) = let
76 :     val E.Opn(E.Add, [E.Tensor (id, ix), _ ]) = pos0
77 :     val vA = Mk.tensorIndex (avail, mapp, List.nth (args, id), ix)
78 :     val vB = mkInt (avail, lb)
79 :     val vC = Mk.realAdd (avail, vA, vB)
80 :     val sxx = List.revMap (fn (E.V sid, _, _) => sid) (List.tl sx)
81 :     in
82 :     (vC, sxx)
83 :     end
84 : cchiw 3741 (* mkpos:ein_exp list*var list*IR.Mk.assignOP list
85 : jhr 3745 * transform ein_exp to low-il
86 :     * returns var for the position
87 :     *)
88 :     fun mkpos (e, mapp, rest) = (case e
89 :     of [] => List.rev rest
90 :     | (E.Opn(E.Add, ([E.Tensor (id, [E.C(c)]), E.Value v1])) :: es) => let
91 :     val vA = Mk.tensorIndex (avail, mapp, List.nth (args, id), [E.C c])
92 :     val rest' = (case Mk.lookupIdx (mapp, v1)
93 :     of 0 => vA
94 :     | j => Mk.realAdd (avail, vA, mkInt (avail, j))
95 :     (* end case *))
96 :     in
97 :     mkpos (es, mapp, rest' :: rest)
98 :     end
99 :     | e1 :: _ => raise Fail ("Incorrect pos for Image: " ^ P.expToString e1)
100 :     (* end case *))
101 : cchiw 3741 (* getPosAddr:var list->var*IR.Mk.assignOP list
102 : jhr 3745 * create position addr based on image info's shapeshift, image info's sizes, and args
103 :     * args are the variables for this specific positions. V_ ([x, y])
104 :     * returns vPosAddr, PosAddrcode
105 :     *)
106 :     fun getPosAddr args = (case (sizes, args)
107 :     of ([_], [i]) => mkProdInt (avail, [vShapeShift, i]) (*1-d*)
108 :     | ([x, _], [i, j]) => let (*2-d*)
109 :     val vA = mkInt (avail, x)
110 :     val vB = mkProdInt (avail, [vA, j])
111 :     val vC = Mk.realAdd (avail, i, vB)
112 :     in
113 :     mkProdInt (avail, [vShapeShift, vC])
114 :     end
115 :     | ([x, y, _], [i, j, k]) => let (*3-d*)
116 :     val vA = mkInt (avail, y)
117 :     val vB = mkProdInt (avail, [vA, k])
118 :     val vC = Mk.realAdd (avail, j, vB)
119 :     val vD = mkInt (avail, x)
120 :     val vE = mkProdInt (avail, [vD, vC])
121 :     val vF = Mk.realAdd (avail, i, vE)
122 :     in
123 :     mkProdInt (avail, [vShapeShift, vF])
124 :     end
125 :     (* end case *))
126 :     fun indexImageShape [] = 0
127 :     | indexImageShape [i] = i
128 :     | indexImageShape [i, j] = let
129 :     val [a, b] = ImageInfo.voxelShape imgInfo
130 :     in
131 :     (b*j) + i
132 :     end
133 :     | indexImageShape _ = raise Fail "Image shape not supported"
134 : cchiw 3741 (* getImgAddr:int list *var->var*IR.Mk.assignOP list
135 : jhr 3745 * creates image address with ^position address, imgType, and base address
136 :     * imgType are image specific indices V[0, 1] (_)
137 :     * ->returns (vImgAddr, ImgAddrcode)
138 :     *)
139 :     fun getImgAddr (imgType, vPosAddr) = (case imgType
140 :     of [] => mkAddPtr (avail, [vBase, vPosAddr], ptyTy)
141 :     | [0] => mkAddPtr (avail, [vBase, vPosAddr], ptyTy)
142 :     | _ => let
143 :     val vA = mkAddPtr (avail, [vBase, vPosAddr], ptyTy)
144 :     val vB = mkInt (avail, indexImageShape imgType)
145 :     in
146 :     mkAddPtr (avail, [vB, vA], ptyTy)
147 :     end
148 :     (* end case *))
149 : cchiw 3741 (* createImgVar:dict->var*IR.Mk.assignOP list
150 : jhr 3745 * gets low-il var for loading an image address
151 :     *)
152 :     fun createImgVar mapp = let
153 :     (* transforms the probed position to low-il *)
154 :     val vAs = mkpos (px, mapp, [])
155 :     (* adds intial position to ^*)
156 :     val posArgs = vPos0::vAs
157 :     (*img specific index*)
158 :     val imgType = List.map (fn e1 => Mk.lookupMu (mapp, e1)) v_alpha
159 :     (* position address and img address *)
160 :     fun imgAddr e = getImgAddr (imgType, getPosAddr e)
161 :     val vImgAddr = (case border
162 :     of E.None => imgAddr posArgs
163 :     | _ => let
164 :     (* transforms border control and creates controlIndex wrapper *)
165 :     val ictl = (case border
166 :     of E.Clamp => IndexCtl.Clamp
167 :     | E.Mirror => IndexCtl.Mirror
168 :     | E.Wrap => IndexCtl.Wrap
169 :     | E.Default => raise Fail "Default boarder control")
170 :     (* img var, offset img address, border *)
171 :     fun controlIndex ([], n) = []
172 :     | controlIndex (e1::es, n) =
173 :     assignOP (
174 :     avail, Op.ControlIndex(imgInfo, ictl, n), [vImg, e1],
175 :     "cntrl"^Int.toString(n), Ty.realTy
176 :     ) :: controlIndex(es, n+1)
177 :     in
178 :     imgAddr (controlIndex(posArgs, 0))
179 :     end
180 :     (* to create voxel address with control
181 :     val op1 = Op.VoxelAddressWithCtl(imgInfo, indexImageShape imgType, ictl)
182 :     in
183 :     assignOP(avail, op1, vImg::posArgs, "voxeladdresswithcontrol", ptyTy)
184 :     end
185 :     *)
186 :     (* end case *))
187 :     in
188 :     assignOP(avail, Op.imgLoad(imgInfo, dim, range), [vImgAddr], "imgrng", Ty.tensorTy [range])
189 :     end
190 :     val rangeList = List.tabulate (range, fn e =>e)
191 :     (* sumPos:index_id * var list*LowIR.Mk.assignOP list*dict*int
192 :     * ->var*LowIR.Mk.assignOP list
193 :     * sumPos iterates over the summation indices and creates mapp
194 :     *)
195 :     fun sumPos ([], rest, dict, _) = createImgVar dict :: rest
196 :     | sumPos ([sid], rest, dict, [r]) = let
197 :     val n' = lb+r
198 :     in
199 :     createImgVar (IMap.insert (dict, sid, n')) :: rest
200 :     end
201 :     | sumPos ([sid], rest, dict, r::es) = let
202 :     val n' = lb+r
203 :     val rest' = createImgVar (IMap.insert (dict, sid, n'))
204 :     in
205 :     sumPos ([sid], rest'::rest, dict, es)
206 :     end
207 :     | sumPos (sid::sxx, rest, dict, [r]) = let
208 :     val n' = lb+r
209 :     in
210 :     sumPos (sxx, rest, IMap.insert (dict, sid, n'), rangeList)
211 :     end
212 :     | sumPos (sid::sxx, rest, dict, r::es) = let
213 :     val n' = lb+r
214 :     val rest' = sumPos (sxx, rest, IMap.insert (dict, sid, n'), rangeList)
215 :     in
216 :     sumPos (sid::sxx, rest', dict, es)
217 :     end
218 :     val ids = sumPos (sxx, [], mapp, rangeList)
219 :     in
220 :     List.rev ids
221 :     end
222 : cchiw 3741
223 : jhr 3745 end

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