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

SCM Repository

[diderot] Annotation of /branches/charisee/src/compiler/mid-to-low/evalImg-set.sml
ViewVC logotype

Annotation of /branches/charisee/src/compiler/mid-to-low/evalImg-set.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3444 - (view) (download)

1 : cchiw 3444 structure EvalImgSet = struct
2 :     local
3 :    
4 :     structure DstOp = LowOps
5 :     structure DstTy = LowILTypes
6 :     structure DstIL = LowIL
7 :     structure LowToS= LowToString
8 :     structure Var = LowIL.Var
9 :     structure E = Ein
10 :     structure P=Printer
11 :    
12 :     structure H=HelperSet
13 :    
14 :    
15 :     in
16 :    
17 :     val testing=0
18 :     fun lookup e =H.lookup e
19 :     fun insert e=H.insertP e
20 :     fun find e=H.find e
21 :     fun mapIndex e=H.mapIndex e
22 :     fun mkInt n =H.mkInt n
23 :     fun assgn e=H.assignOP e
24 :     fun indexTensor e = H.indexTensor e
25 :     fun mkAddInt e= H.mkAddInt e
26 :     fun mkAddPtr e = H.mkAddPtr e
27 :     fun mkProdInt e= H.mkProdInt e
28 :    
29 :     fun iTos n=Int.toString n
30 :     fun err str=raise Fail(str)
31 :     val intTy=DstTy.IntTy
32 :     fun testp n =(case testing
33 :     of 0 => 1
34 :     | _ => (print(String.concat n);1)
35 :     (*end case *))
36 :     fun psize n=foldl (fn (a,b) => b*a) 1 n
37 :     fun asize n=foldl (fn (a,b) => b+a) 0 n
38 :    
39 :     (* mkImg:dict*string*E.params*var list*sum_id list*()*image*var*int*int*int
40 :     * ->var*lowIL.assgn
41 :     * The image "imgarg" is probed at positions
42 :     * Σ_{sx} V_alpha[pos0::px]
43 :     * sumPos() iterates over the summation indices and creates a mapp for the indicies
44 :     * once mapp(j->2 k->0) is created sumPos() calls createImgVar() to get the addr of Σ_k V_{i}[T_j,T_k]
45 :     * createImgVar() uses mkpos(), getPosAddr() and getImgAddr() to get imgvar
46 :     *)
47 :     fun mkImg(setOrig,mappOrig,lhs,params,args, sx,(_,v_alpha,pos0::px),v,imgarg,lb,range0,range1)=let
48 :    
49 :     val dim=ImageInfo.dim v
50 :     val ptyTy=DstTy.AddrTy v
51 :     val sizes=ImageInfo.sizes v
52 :     val (setBase,vBase,base)=assgn(setOrig,DstOp.baseAddr v,[imgarg],"baseAddr",ptyTy) (*base address*)
53 :     val (setShapeShift,vShapeShift,ShapeShiftcode)= mkInt(setBase,psize (ImageInfo.voxelShape v)) (*shift of the image field.*)
54 :    
55 :    
56 :     (*Since the image is loaded as a vector
57 :     * we evaluate the first position just once
58 :     * Σ_{ij..} V[T+i,T+j...]-> Σ_{j..} V[T+j...]
59 :     * and we drop the first summation index
60 :     * Additionally, summation indices are reversed
61 :     * that inner loop is second(y) axis and outer loop is third(z)axis
62 :     *)
63 :     val (setPos0,vPos0,Pos0code,sxx)=let
64 :     val E.Add[E.Tensor(t1,ix1),_ ]=pos0
65 :     val (setA,vA,A)=indexTensor(setShapeShift,mappOrig,("",params,args, t1,ix1,intTy))
66 :     val (setB,vB,B)= mkInt(setA, lb)
67 :     val (setC,vC,C)= mkAddInt(setB, [vA,vB])
68 :     val _ =testp["\nsxx\n original:"]
69 :     val sxx= List.map(fn (E.V sid,_,_)=> sid) sx
70 :     val _ =List.map (fn e=> testp["-",iTos e]) sxx
71 :     val sxx=List.rev(List.tl(sxx))
72 :     val _ =testp["\n used:"]
73 :     val _ =List.map (fn e=> testp["-",iTos e]) sxx
74 :    
75 :     in
76 :     (setC,vC,A@B@C,sxx)
77 :     end
78 :    
79 :    
80 :     (* mkpos:ein_exp list*var list*DstIL.assgn list
81 :     * transform ein_exp to low-il
82 :     * returns var for the position
83 :     *)
84 :     fun mkpos(setPos,e,mapp,rest,code)=(case e
85 :     of [] => (setPos,rest,code)
86 :     | ((E.Add[ E.Tensor(t1,ix1),E.Value v1])::es)=> let
87 :     val (setA,vA,A)=indexTensor(setPos,mapp,("",params,args,t1,ix1,intTy))
88 :     val j=find(v1,mapp)
89 :     val (setD,rest',code')=(case j
90 :     of 0 => (setPos,vA,A)
91 :     | _ => let
92 :     val (setB,vB,B)= mkInt(setA, j)
93 :     val (setC,vC,C)=mkAddInt(setB,[vA,vB])
94 :     in (setC,vC,A@B@C) end
95 :     (*end case*))
96 :     in mkpos(setD,es,mapp,rest@[rest'],code@code') end
97 :     | e1::_ => raise Fail("Incorrect pos for Image: "^P.printbody e1)
98 :     (*end case*))
99 :    
100 :     (* getPosAddr:var list->var*DstIL.assgn list
101 :     * create position addr based on image info's shapeshift,image info's sizes,and args
102 :     * args are the variables for this specific positions. V_([x,y])
103 :     * returns vPosAddr,PosAddrcode
104 :     *)
105 :     fun getPosAddr(setPosAddr, args)=(case (sizes,args)
106 :     of([ _ ],[i]) =>mkProdInt(setPosAddr,[vShapeShift,i]) (*1-d*)
107 :     | ([x, _ ],[i,j]) =>let (*2-d*)
108 :     val (setA,vA,A)= mkInt(setPosAddr, x)
109 :     val (setB,vB,B)= mkProdInt (setA,[vA,j])
110 :     val (setC,vC,C)= mkAddInt(setB, [i,vB])
111 :     val (setD,vD,D)= mkProdInt(setC,[vShapeShift,vC])
112 :     in (setD,vD,A@B@C@D) end
113 :     | ([x,y,_],[i,j,k]) =>let (*3-d*)
114 :     val (setA,vA,A)= mkInt(setPosAddr, y)
115 :     val (setB,vB,B)= mkProdInt(setA, [vA,k])
116 :     val (setC,vC,C)= mkAddInt(setB ,[j,vB])
117 :     val (setD,vD,D)= mkInt(setC, x)
118 :     val (setE,vE,E)= mkProdInt (setD,[vD,vC])
119 :     val (setF,vF,F)= mkAddInt(setE, [i,vE])
120 :     val( setG,vG,G)= mkProdInt(setF,[vShapeShift,vF])
121 :     in (setG,vG,A@B@C@D@E@F@G) end
122 :     (*end case*))
123 :    
124 :     (* getImgAddr:int list *var->var*DstIL.assgn list
125 :     * creates image address with ^position address,imgType, and base address
126 :     * imgType are image specific indices V[0,1](_)
127 :     * ->returns (vImgAddr,ImgAddrcode)
128 :     *)
129 :     fun getImgAddr (setImgAddr,imgType,vPosAddr) =(case imgType
130 :     of [] => mkAddPtr(setImgAddr,[vBase,vPosAddr],ptyTy)
131 :     | [0] => mkAddPtr(setImgAddr,[vBase,vPosAddr],ptyTy)
132 :     | [_] => let
133 :     val (setA,vA,A)= mkAddPtr(setImgAddr,[vBase,vPosAddr],ptyTy)
134 :     val (setB,vB,B)= mkInt(setA,asize imgType)
135 :     val (setC,vC,C)= mkAddPtr(setB,[vB, vA],ptyTy)
136 :     in (setC,vC,A@B@C)end
137 :     | [i,j] => let
138 :     val [a,b]=ImageInfo.voxelShape v
139 :     (*val _=print(String.concat[Int.toString i,"-",Int.toString j,"\nvoxel",Int.toString a,"-",Int.toString b])*)
140 :     val (setA,vA,A)= mkAddPtr(setImgAddr,[vBase,vPosAddr],ptyTy)
141 :     val (setB,vB,B)= mkInt (setA,(b*j)+i)
142 :     val (setC,vC,C)= mkAddPtr(setB,[vB, vA],ptyTy)
143 :     in (setC,vC,A@B@C)end
144 :     (*end case*))
145 :    
146 :     (* createImgVar:dict->var*DstIL.assgn list
147 :     * gets low-il var for loading an image address
148 :     *)
149 :     fun createImgVar(setI, mapp)=let
150 :     val (setA,vA,A)= mkpos(setI,px,mapp,[],[]) (*transforms the probed position to low-il*)
151 :     val posArgs=[vPos0]@vA (*adds intial position to ^*)
152 :     val (setPosAddr,vPosAddr,PosAddrcode)=getPosAddr(setA, posArgs) (*position address*)
153 :     val imgType=List.map (fn (e1)=> mapIndex(e1,mapp)) v_alpha (*img specific index*)
154 :     val (setImgAddr,vImgAddr,ImgAddrcode)=getImgAddr (setPosAddr,imgType,vPosAddr) (*img address*)
155 :     val (setD,vD,D)=assgn(setImgAddr,DstOp.imgLoad(v,dim,range1),[vImgAddr],"imgrng",DstTy.tensorTy([range1]))
156 :     in
157 :     (setD,vD,A@PosAddrcode@ImgAddrcode@D)
158 :     end
159 :    
160 :     val range0List=List.tabulate(range0+1,fn e=>e)
161 :    
162 :     (* sumPos:index_id * var list*lowil.assgn list*dict*int
163 :     * ->var*lowil.assgn list
164 :     * sumPos iterates over the summation indices and creates mapp
165 :     *)
166 :     fun sumPos(setSx,[],lft,code,dict,_)=let
167 :     val (set',lft', code')= createImgVar(setSx, dict)
168 :     in (set',lft@[lft'],code@code') end
169 :     | sumPos(setSx,[sid],lft,code,dict,[r])=let
170 :     val n'=lb+r
171 :     val _=testp["\n insert",iTos sid, "->",iTos n']
172 :     val mapp=insert (sid, n') dict
173 :     val (set',lft', code')= createImgVar(setSx, mapp)
174 :     in (set',lft@[lft'],code@code') end
175 :     | sumPos(setSx,[sid],lft,code,dict,r::es)=let
176 :     val n'=lb+r
177 :     val _=testp["\n insert",iTos sid, "->",iTos n']
178 :     val mapp=insert (sid, n') dict
179 :     val (set',lft', code')= createImgVar(setSx, mapp)
180 :     in sumPos(set',[sid],lft@[lft'],code@code',dict,es) end
181 :     | sumPos(setSx,sid::sxx,lft,code,dict,[r])=let
182 :     val n'=lb+r
183 :     val _=testp["\n insert",iTos sid, "->",iTos n']
184 :     val mapp=insert (sid, n') dict
185 :     val (set',lft',code')=sumPos(setSx,sxx,lft,[],mapp,range0List)
186 :     in (set',lft',code@code') end
187 :    
188 :     | sumPos(setSx,sid::sxx,lft,code,dict,r::es)=let
189 :     val n'=lb+r
190 :     val _=testp["\n insert",iTos sid, "->",iTos n']
191 :     val mapp=insert (sid, n') dict
192 :     val (set',lft',code')=sumPos(setSx,sxx,lft,[],mapp,range0List)
193 :     in
194 :     sumPos(set',sid::sxx,lft',code@code',dict,es)
195 :     end
196 :    
197 :    
198 :     (* fun sumPos(setSx,[],lft,code,dict,_)=let
199 :     val (set',lft', code')= createImgVar(setSx, dict)
200 :     in (set',[lft']@lft,code'@code) end
201 :     | sumPos(setSx,[sid],lft,code,dict,0)=let
202 :     val n'=lb
203 :     val _=testp["\n insert",iTos sid, "->",iTos n']
204 :     val mapp=insert (sid, n') dict
205 :     val (set',lft', code')= createImgVar(setSx, mapp)
206 :     in (set',[lft']@lft,code'@code) end
207 :     | sumPos(setSx,[sid],lft,code,dict,r)=let
208 :     val n'=lb+r
209 :     val _=testp["\n insert",iTos sid, "->",iTos n']
210 :     val mapp=insert (sid, n') dict
211 :     val (set',lft', code')= createImgVar(setSx, mapp)
212 :     in sumPos(set',[sid],[lft']@lft,code'@code,dict,r-1) end
213 :     | sumPos(setSx,sid::sxx,lft,code,dict,0)=let
214 :     val n'=lb
215 :     val _=testp["\n insert",iTos sid, "->",iTos n']
216 :     val mapp=insert (sid, n') dict
217 :     val (set',lft',code')=sumPos(setSx,sxx,lft,[],mapp,range0)
218 :     in (set',lft',code'@code) end
219 :    
220 :     | sumPos(setSx,sid::sxx,lft,code,dict,r)=let
221 :     val n'=lb+r
222 :     val _=testp["\n insert",iTos sid, "->",iTos n']
223 :     val mapp=insert (sid, n') dict
224 :     val (set',lft',code')=sumPos(setSx,sxx,lft,[],mapp,range0)
225 :     in
226 :     sumPos(set',sid::sxx,lft',code'@code,dict,r-1)
227 :     end
228 :     *)
229 :     val(setSx,lft,code)=sumPos(setPos0,sxx,[],[],mappOrig,range0List)
230 :     val q=base@ShapeShiftcode@Pos0code@code
231 :    
232 :     in
233 :     (setSx,lft,base@ShapeShiftcode@Pos0code@code)
234 :     end
235 :    
236 :    
237 :     end (* local *)
238 :    
239 :     end

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