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

SCM Repository

[diderot] Annotation of /branches/charisee_dev/src/compiler/low-il/ein-to-low.sml
ViewVC logotype

Annotation of /branches/charisee_dev/src/compiler/low-il/ein-to-low.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3616 - (view) (download)

1 : cchiw 3541 (*
2 :     * genfn-Does preliminary scan of the body of EIN.EIN for vectorization potential
3 :     * If there is a field then passes to FieldToLow
4 :     * If there is a tensor then passes to handle*() functions to check if indices match
5 :     * i.e. <A_ij+B_ij>_ij vs.<A_ji+B_ij>_ij
6 :     *
7 :     * (1) If indices match then passes to Iter->VecToLow functions.
8 :     * Creates LowIL vector operators.
9 :     * (2) Iter->ScaToLow
10 :     * Creates Low-IL scalar operators
11 :     * Note. The Iter function creates LowIL.CONS and therefore binds the indices in the EIN.body
12 :     *)
13 :     structure EinToLowSet = struct
14 :     local
15 :    
16 :     structure Var = LowIL.Var
17 :     structure E = Ein
18 :     structure P=Printer
19 :     structure Iter=IterSet
20 :     structure EtoFld= FieldToLowSet
21 :     structure EtoSca= ScaToLowSet
22 :     structure EtoVec= VecToLowSet
23 :     structure H=HelperSet
24 :    
25 :     in
26 :    
27 :     fun iter e=Iter.prodIter e
28 :     fun evalField e= EtoFld.evalField e
29 :     fun intToReal n=H.intToReal n
30 :    
31 :     fun testp p=(String.concat p)
32 :    
33 :     (*dropIndex: a list-> int*a*alist
34 :     * alpha::i->returns length of list-1,i,alpha
35 :     *)
36 :     fun dropIndex alpha=let
37 :     val (e1::es)=List.rev(alpha)
38 :     in (length alpha-1,e1,List.rev es)
39 :     end
40 :    
41 :     (*matchLast:E.alpha*int -> (E.alpha) Option
42 :     * Is the last index of alpha E.V n.
43 :     * If so, return the rest of the list
44 :     *)
45 :     fun matchLast(alpha, n)=let
46 :     val (e1::es)=List.rev(alpha)
47 :     in (case e1
48 :     of E.V v =>(case (n=v)
49 :     of true => SOME(List.rev es)
50 :     |_ => NONE
51 :     (*end case*))
52 :     | _ => NONE
53 :     (*end case*))
54 :     end
55 :    
56 :     (*matchFindLast:E.alpha *int -> E.alpha option* E.mu option
57 :     * Is the last index of alpha =n.
58 :     * is n anywhere else?
59 :     *)
60 :     fun matchFindLast(alpha, n)=let
61 :     val es=List.tl(List.rev(alpha))
62 :     val f=List.find(fn E.V e=>e=n|_=>false) es
63 :     in
64 :     (matchLast(alpha,n),f)
65 :     end
66 :    
67 :     (*runGeneralCase:Var*E.EIN*Var-> Var*LowIL.ASSN list
68 :     * does not do vector projections
69 :     * instead approach like a general EIN
70 :     *)
71 :    
72 :     fun runGeneralCase(lhs:string,e:Ein.ein,args:LowIL.var list)=let
73 :     val info=(lhs,e,args)
74 :     val index=Ein.index e
75 :     val opset= lowSet.LowSet.empty
76 :    
77 :     val rtn= iter(opset,index,index,EtoSca.generalfn,info)
78 :     val (_,_,code)=rtn
79 :     val n= length(code)
80 :     (*
81 :     val _ =if (n>10) then print(String.concat["\n Gen(",Int.toString(n),")",P.printerE(e)]) else print""*)
82 :     in rtn end
83 :    
84 :    
85 :     (*handleNeg:.body* int list*info ->Var*LowIL.ASSN list
86 :     * info:(string*E.EIN*Var list)
87 :     * low-IL code for scaling a vector with negative 1.
88 :     *)
89 :     fun handleNeg(E.Op1(E.Neg,E.Tensor(id ,alpha)),index,info)=let
90 :     val (n,vecIndex,index')=dropIndex index
91 :     in (case (matchLast(alpha,n))
92 :     of SOME ix1 => let
93 :     val setT= lowSet.LowSet.empty
94 :     val (setA,vA,A)= intToReal( setT, ~1)
95 :     val (lhs,e,args)=info
96 :     val nextfnargs=(lhs,Ein.params e,args,vecIndex, vA, id,ix1)
97 :     val (setB,vB,B)=iter(setA,index,index',EtoVec.negV,nextfnargs)
98 :     in
99 :     (setB,vB,A@B)
100 :     end
101 :     | NONE => runGeneralCase info
102 :     (*end case*))
103 :     end
104 :    
105 :     (*handleSub:E.body*int list*info ->Var*LowIL.ASSN list
106 :     * info:(string*E.EIN*Var list)
107 :     * low-IL code for subtracting two vectors
108 :     *)
109 :     fun handleSub(E.Op2(E.Sub,E.Tensor(id1,alpha),E.Tensor(id2,beta)),index,info)=let
110 :     val (n,vecIndex,index')=dropIndex index
111 :     in (case(matchLast(alpha,n) , matchLast(beta,n)) of
112 :     (SOME ix1,SOME ix2)=>let
113 :     val (lhs,e,args)=info
114 :     val setT= lowSet.LowSet.empty
115 :     val nextfnargs=(lhs,Ein.params e, args,vecIndex,id1,ix1,id2,ix2)
116 :     in
117 :     iter(setT,index,index',EtoVec.subV,nextfnargs)
118 :     end
119 :     | _ => runGeneralCase info
120 :     (*end case*))
121 :     end
122 :    
123 :    
124 :     (*handleAdd:E.body*int list*info ->Var*LowIL.ASSN list
125 :     * info:(string*E.EIN*Var list)
126 :     * low-IL code for adding two vectors
127 :     *)
128 :     fun handleAdd(E.Opn(E.Add, es),index,info)=let
129 :     val (n,vecIndex,index')=dropIndex index
130 :     (*check that each tensor in addition list has matching indices*)
131 :     fun sample([],rest)=let
132 :     val (lhs,e,args)=info
133 :     val setT= lowSet.LowSet.empty
134 :     val nextfnargs=(lhs,Ein.params e, args,vecIndex,rest)
135 :     in
136 :     iter(setT,index,index',EtoVec.addV,nextfnargs)
137 :     end
138 :     | sample(E.Tensor(id,alpha)::ts,rest) =(case (matchLast(alpha,n))
139 :     of SOME ix1 => sample(ts,rest@[(id,ix1)])
140 :     | _ => runGeneralCase info
141 :     (*end case*))
142 :     | sample _ = runGeneralCase info
143 :     in
144 :     sample(es,[])
145 :     end
146 :    
147 :    
148 :    
149 :     (*handleScale:E.tensor_id*E.tensor_id*E.alpha*int list*info ->Var*LowIL.ASSN list
150 :     * info:(string*E.EIN*Var list)
151 :     * low-IL code for adding scaling a vector
152 :     *)
153 :     fun handleScale(id1,id2,alpha2,index,info)=let
154 :     val (n,vecIndex,index')=dropIndex index
155 :     in (case matchLast(alpha2,n)
156 :     of SOME ix2=> let
157 :     val (lhs,e,args)=info
158 :     val setT= lowSet.LowSet.empty
159 :     val nextfnargs=(lhs,Ein.params e, args,vecIndex,id1,[],id2,ix2)
160 :     in
161 :     iter(setT,index,index',EtoVec.scaleV,nextfnargs)
162 :     end
163 :     | _=>runGeneralCase info
164 :     (*end case*))
165 :     end
166 :    
167 :     (*handleProd:E.body*int list*info ->Var*LowIL.ASSN list
168 :     * info:(string*E.EIN*Var list)
169 :     * low-IL code for vector product
170 :     *)
171 :     fun handleProd(E.Opn(E.Prod,[E.Tensor(id1 , alpha), E.Tensor(id2, beta)]),index,info)=let
172 :     val (lhs,e,args)=info
173 :     val (n,vecIndex,index')=dropIndex index
174 :     val setT= lowSet.LowSet.empty
175 :     in (case(matchFindLast(alpha,n),matchFindLast(beta,n))
176 :     of ((SOME ix1,NONE),(SOME ix2,NONE)) => let
177 :     (*n is the last index of alpha, beta and nowhere else,possible modulate*)
178 :    
179 :     val nextfnargs=(lhs,Ein.params e, args,vecIndex,id1,ix1,id2,ix2)
180 :     in
181 :     iter(setT,index,index',EtoVec.prodV,nextfnargs)
182 :     end
183 :     | ((NONE,NONE),(SOME ix2,NONE)) =>let
184 :     (*n is the last index of beta and nowhere else,possible scaleVector*)
185 :     val nextfnargs=(lhs,Ein.params e, args,vecIndex,id1,alpha,id2,ix2)
186 :     in
187 :     iter(setT,index,index',EtoVec.scaleV,nextfnargs)
188 :     end
189 :     | ((SOME ix1,NONE),(NONE,NONE)) =>let
190 :     (*n is the last index of alpha and nowhere else,ossile scaleVector*)
191 :     val nextfnargs=(lhs,Ein.params e, args,vecIndex,id2,beta,id1,ix1)
192 :     in
193 :     iter(setT,index,index',EtoVec.scaleV,nextfnargs)
194 :     end
195 :     | _ =>runGeneralCase info
196 :     (*end case*))
197 :     end
198 :    
199 :     (*handleSumProd:E.body*int list*info ->Var*LowIL.ASSN list
200 :     * info:(string*E.EIN*Var list)
201 :     * low-IL code for dot product
202 :     *)
203 :     fun (*handleSumProd1(E.Sum([(E.V 1,_,ub)],E.Opn(E.Prod,[E.Tensor(id1 , [E.V 1]), E.Tensor(id2, [E.V 1,E.V 0])]) ),[i],info)=let
204 :     val (lhs,e,args)=info
205 :     val setT= lowSet.LowSet.empty
206 :     val nextfnargs=(lhs,Ein.params e, args,ub+1,id1,[],id2,[E.V 0])
207 :     in
208 :     iter(setT,[i],[i],EtoVec.VM,nextfnargs)
209 :     end
210 :    
211 :     | handleSumProd1(E.Sum([(E.V 2,_,ub)],E.Prod[E.Tensor(id1 , [E.V 0,E.V 2]), E.Tensor(id2, [E.V 2,E.V 1])]),index as [_,_],info)=let
212 :     val (lhs,e,args)=info
213 :     val setT= lowSet.LowSet.empty
214 :     val nextfnargs=(lhs,Ein.params e, args,ub+1,id1,[E.V 0],id2,[E.V 1],index)
215 :     val _ ="\nuses projFirst"
216 :     in
217 :     iter(setT,index,index,EtoVec.MM3,nextfnargs)
218 :     end
219 :    
220 :     |*) handleSumProd1(E.Sum([(E.V v,_,ub)],E.Opn(E.Prod,[E.Tensor(id1 , alpha), E.Tensor(id2, beta)])),index,info)=
221 :     (case(matchFindLast(alpha,v),matchFindLast(beta,v))
222 :     of ((SOME ix1,NONE),(SOME ix2,NONE)) => let
223 :     (*v is the last index of alpha, beta and nowhere else,possible sumProd*)
224 :     val (lhs,e,args)=info
225 :     val setT= lowSet.LowSet.empty
226 :     val nextfnargs=(lhs,Ein.params e, args,ub+1,id1,ix1,id2,ix2)
227 :     in
228 :     iter(setT,index,index,EtoVec.dotV,nextfnargs)
229 :     end
230 :     | _ =>runGeneralCase info
231 :     (*end case*))
232 :    
233 :     (*handleSumProd:E.body*int list*info ->Var*LowIL.ASSN list
234 :     * info:(string*E.EIN*Var list)
235 :     * low-IL code for double dot product
236 :     * Sigma_{i,j} A_ij B_ij
237 :     *)
238 :     fun handleSumProd2(E.Sum([(E.V v1,lb1,ub1),(E.V v2,lb2,ub2)],E.Opn(E.Prod,[E.Tensor(id1 , alpha), E.Tensor(id2, beta)])),index,info)=let
239 :     fun check(v,ub,sx)=(case(matchFindLast(alpha,v),matchFindLast(beta,v))
240 :     of ((SOME ix1,NONE),(SOME ix2,NONE)) => let
241 :     (*v is the last index of alpha, beta and nowhere else,possible sumProd*)
242 :     val (lhs,e,args)=info
243 :     val setT= lowSet.LowSet.empty
244 :     val nextfnargs=(lhs,Ein.params e, args,sx,ub+1,id1,ix1,id2,ix2)
245 :     in
246 :     SOME(iter(setT,index,index,EtoVec.sumDotV,nextfnargs))
247 :     end
248 :     | _=> NONE
249 :     (*end case*))
250 :     in (case check(v1,ub1,(E.V v2,lb2,ub2))
251 :     of SOME e=>e
252 :     | _=> (case check(v2,ub2,(E.V v1,lb1,ub1))
253 :     of SOME e=> e
254 :     |_ =>runGeneralCase info
255 :     (*end case*))
256 :     (*end case*))
257 :     end
258 :    
259 :    
260 :     (*scan:var*E.Ein*Var list * Var list-> Var*LowIL.Assgn list
261 :     *scans body for vectorization potential
262 :     *)
263 :     fun q(y,e:Ein.ein,args:LowIL.var list)= let
264 :     val lhs=LowIL.Var.name y
265 :     val b=Ein.body e
266 :     val index=Ein.index e
267 :     val info=(lhs,e,args)
268 :     val all=(b,index,info)
269 :    
270 :     fun gen body=(case (index,body)
271 :     of (_::es,E.Op2(E.Sub,E.Tensor(_,i::ix),E.Tensor(_,j::jx)))
272 :     => handleSub all
273 :     | (_::es, E.Opn(E.Add,(E.Tensor(_,i::ix)::_)))
274 :     => handleAdd all
275 :     | (_::es,E.Op1(E.Neg,E.Tensor(_ ,i::ix)))
276 :     => handleNeg all
277 :     | (_::es, E.Opn(E.Prod,[E.Tensor(s, []), E.Tensor(v, j::jx)]))
278 :     => handleScale(s,v,j::jx,index,info)
279 :     | (_::es,E.Opn(E.Prod,[E.Tensor(v, j::jx), E.Tensor(s , [])]))
280 :     => handleScale(s,v,j::jx,index,info)
281 :     | (_::es,E.Opn(E.Prod,[E.Tensor(_ , i::ix), E.Tensor(_, j::jx)]))
282 :     => handleProd all
283 :     | ( _,E.Sum([_], E.Opn(E.Prod,[E.Tensor(_ , i::ix), E.Tensor(_, j::jx)])))
284 :     => handleSumProd1 all
285 :     | ( _ ,E.Sum([_,_],E.Opn( E.Prod,[E.Tensor(_ , i::ix), E.Tensor(_, j::jx)])))
286 :     => handleSumProd2 all
287 : cchiw 3596 | (_,_ )=> runGeneralCase info
288 : cchiw 3541 (*end case*))
289 :    
290 :    
291 :     fun scanSize body=(case (index,body)
292 :     of ([3,3],_) => runGeneralCase info
293 :     | ([3,3,3],_) => runGeneralCase info
294 :     | (_, E.Opn(E.Prod,E.Tensor(_,_::_::_)::_))=> runGeneralCase info
295 :     | (_,E.Sum(_,E.Opn(E.Prod,(E.Tensor(_,_::_::_)::_))))=> runGeneralCase info
296 :     | (_,E.Sum(_,E.Opn(E.Prod,(_::E.Tensor(_,_::_::_)::_))))=> runGeneralCase info
297 :     | (_,_ )=> gen b
298 :     (*end case*))
299 :     in
300 : cchiw 3616 gen b
301 : cchiw 3541 end
302 :    
303 :     end (* local *)
304 :    
305 :     end

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