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

SCM Repository

[diderot] Annotation of /branches/charisee/src/compiler/high-to-mid/split-einHtM.sml
ViewVC logotype

Annotation of /branches/charisee/src/compiler/high-to-mid/split-einHtM.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2523 - (view) (download)

1 : cchiw 2522 (* Split Functions before code generation process*)
2 :     structure splitHtM = struct
3 :     local
4 :     structure E = Ein
5 :     structure DstIL = MidIL
6 :     structure DstTy = MidILTypes
7 :     structure shift=shiftHtM
8 :    
9 :     structure P=Printer
10 :     structure Var = MidIL.Var
11 :     structure HVar = HighIL.Var
12 :     in
13 :    
14 :    
15 :     fun printA(id,e,arg)=let
16 :     val a=String.concatWith " , " (List.map Var.toString arg)
17 :     in String.concat([(Var.toString id)," ==",P.printerE e, a])
18 :     end
19 :    
20 :     fun printAA(id,e,arg)=let
21 :     val a=String.concatWith " , " (List.map HVar.toString arg)
22 :     in String.concat([(Var.toString id)," ==",P.printerE e, a])
23 :     end
24 :    
25 :    
26 :     fun createEin( params,index, body)=Ein.EIN{params=params, index=index, body=body}
27 :     fun flat xs = List.foldr op@ [] xs
28 :     val counter=ref 0
29 :    
30 :     (*How to create new ein variable*)
31 :     fun fresh _=let
32 :     val ref x=counter
33 :     val m=x+1
34 :     val x=DstIL.Var.new("Q" ^ Int.toString(m) ,DstTy.intTy)
35 :     in (counter:=m;x) end
36 :    
37 :     fun createnewb (params,index,args,(id,e))=let
38 :     val (p',b',args)=shift.cleanParams(e,params,args)
39 :     val a=createEin(p',index, b')
40 :     in (id,a,args)
41 :     end
42 :    
43 :     fun createnewP (params,args,(id,e,ix))=let
44 :     val (p',b',args)=shift.cleanParams(e,params,args)
45 :     val a=createEin(p',ix, b')
46 :     in (id,a,args)
47 :     end
48 :    
49 :    
50 :    
51 :     (*Outside Operator is Neg*)
52 :     fun handleNeg(params, index,e,args)=let
53 :     val id=ref (length params)
54 :     val ix=List.map (fn e=> E.V e) index
55 :     fun mkTensor _=let val ref idx= id in (id:=(idx+1);E.Tensor(idx,ix)) end
56 :    
57 :     fun replace e'= let
58 :     val q=fresh 1
59 :     val t=mkTensor 0
60 :     val newbie=createEin( params,index,e')
61 :     in ([(q,newbie,args)],(params@[E.TEN 1], E.Neg t,[q]))
62 :     end
63 :    
64 :    
65 :     in (case e
66 :     of E.Add _=> replace e
67 :     | E.Sub _=> replace e
68 :     | E.Prod _=> replace e
69 :     | E.Div _=> replace e
70 :     | E.Sum _=> replace e
71 :     | _=>([],(params, e, args))
72 :     (*end case*))
73 :     end
74 :    
75 :    
76 :    
77 :    
78 :     (*Outside Operator is Add*)
79 :     fun handleAdd(params, index,list1,args)=let
80 :     val id=ref (length params)
81 :     val n=length index
82 :     val ix=List.tabulate (n,fn v=> E.V(v))
83 :     fun mkTensor _=let val ref idx= id in (id:=(idx+1);[E.Tensor(idx,ix)]) end
84 :    
85 :     fun foundOp(e,es,(lft,newbies,params,args))=let
86 :     val q=fresh 1
87 :     in (es,(lft@(mkTensor 0), newbies@[(q, e)],params@[E.TEN 1],args@[q]))
88 :     end
89 :    
90 :    
91 :     fun sort([], m)=m
92 :     | sort(e::es,m)=(case e
93 :     of E.Add p => sort(p@es, m)
94 :     | E.Sub _=>sort (foundOp(e, es,m))
95 :     | E.Prod _=>sort (foundOp(e, es,m))
96 :     | E.Div _=>sort (foundOp(e, es,m))
97 :     | E.Neg _=>sort (foundOp(e, es,m))
98 :     | E.Sum _=>sort (foundOp(e, es,m))
99 :     | _ => let
100 :     val (l,n, p, a)=m
101 :     in sort(es,(l@[e],n,p,a)) end
102 :     (*end case *))
103 :    
104 :     val (lft, newbies,params',args')=sort(list1,([],[],[],[]))
105 :     val (p',b',args')= shift.cleanParams(E.Add(lft),params@params', args@args')
106 :     val z=List.map (fn(e)=> createnewb(params,index,args,e) ) newbies
107 :     in
108 :     (z,(p',b',args'))
109 :     end
110 :    
111 :    
112 :    
113 :     fun findOp e=(case e
114 :     of E.Neg _=>1
115 :     | E.Add _=>1
116 :     | E.Sub _=>1
117 :     | E.Prod _=>1
118 :     | E.Div _=>1
119 :     | E.Sum _ =>1
120 :     | _=>0
121 :     (*end case*))
122 :    
123 :    
124 :     (*Outside Operator is Sub*)
125 :     fun handleSub(params, index,e1,e2,args)=let
126 :     val id=ref (length params)
127 :     val n=length index
128 :     val ix=List.tabulate (n,fn v=> E.V(v))
129 :    
130 :     fun mkTensor _=let val ref idx= id in (id:=(idx+1);E.Tensor(idx,ix)) end
131 :    
132 :     fun subsort(e)= let
133 :     val s=findOp e
134 :     in (case s
135 :     of 0=>(e,[],[],[])
136 :    
137 :     | _=> let
138 :     val q=fresh 1
139 :     in (mkTensor 0, [(q, e)],[E.TEN 1],[q]) end
140 :     (*end case*))
141 :     end
142 :    
143 :     val (lft1, newbies1,params1,args1)=subsort e1
144 :     val (lft2, newbies2,params2,args2)=subsort e2
145 :     val (p',b',args')= shift.cleanParams(E.Sub(lft1,lft2), params@params1@params2, args@args1@args2)
146 :     val newbies=newbies1@newbies2
147 :     val z=List.map (fn(e)=> createnewb(params,index,args,e) ) newbies
148 :     in
149 :     (z,(p',b',args'))
150 :     end
151 :    
152 :     (*Outside Operator is Div *)
153 :     fun handleDiv(params, index,e1,e2,args)=let
154 :     val id=ref (length params)
155 :     val ix=List.map (fn e=> E.V e) index
156 :     fun mkTensor _=let val ref idx= id in (id:=(idx+1);E.Tensor(idx,ix)) end
157 :     fun mkSca _=let val ref idx= id in (id:=(idx+1);E.Tensor(idx,[])) end
158 :    
159 :     fun divsort(e,nextfn)= let
160 :     val s=findOp e
161 :     in (case s
162 :     of 0=>(e,[],[],[])
163 :    
164 :     | _=> let
165 :     val q=fresh 1
166 :     in (nextfn 0, [(q, e)],[E.TEN 1],[q]) end
167 :     (*end case*))
168 :     end
169 :    
170 :     val (lft1, newbies1,params1,args1)=divsort(e1,mkTensor)
171 :     val (lft2, newbies2,params2,args2)=divsort(e2,mkSca)
172 :     val (p',b',args')= shift.cleanParams(E.Div(lft1,lft2),params@params1@params2, args@args1@args2)
173 :    
174 :     val z1=List.map (fn(e)=> createnewb(params,index,args,e) ) newbies1
175 :     val z2=List.map (fn(e)=> createnewb(params,[],args,e) ) newbies2
176 :     in
177 :     (z1@z2,(p',b',args'))
178 :     end
179 :    
180 :    
181 :    
182 :     fun hProd(params, index,list1,args)=let
183 :     val id=ref (length params)
184 :     val n=length index
185 :    
186 :     fun mkPTensor e=let
187 :     val ref idx= id
188 :     val (ix,index',e')=shift.cleanIndex(e, n, index)
189 :     in (id:=(idx+1);([E.Tensor(idx,ix)],index',e')) end
190 :    
191 :    
192 :     fun foundOp (e,es,(lft,newbies, params, args))=let
193 :     val q=fresh 1
194 :     val (p,ix,e')=mkPTensor e
195 :     in (es,(lft@p, newbies@[(q, e',ix)],params@[E.TEN 1],args@[q])) end
196 :    
197 :    
198 :     fun sort([], m)=m
199 :     | sort(e::es,m)=(case e
200 :     of E.Add _ => sort (foundOp(e,es,m))
201 :     | E.Sub _=>sort (foundOp(e, es,m))
202 :     | E.Prod p=>sort (p@es,m)
203 :     | E.Div _=>sort (foundOp(e, es,m))
204 :     | E.Neg _=>sort (foundOp(e, es,m))
205 :     | E.Sum _=>sort (foundOp(e, es,m))
206 :     | E.Probe _=> raise Fail("Probe- Should have been expanded")
207 :     | _ => let
208 :     val (l,n, p, a)=m
209 :     in sort(es,(l@[e],n,p,a)) end
210 :     (*end case *))
211 :    
212 :     in
213 :     sort(list1,([],[],[],[]))
214 :     end
215 :    
216 :     fun handleProd(params, index,list1,args)=let
217 :     val (lft, newbies,params',args')=hProd(params, index,list1,args)
218 :     val (p',b',args')= shift.cleanParams(E.Prod lft, params@params', args@args')
219 :     val z=List.map (fn(e)=> createnewP(params,args,e) ) newbies
220 :     in
221 :     (z,(p',b',args'))
222 :     end
223 :    
224 :     fun handleSumProd(params, ind,sx,list1,args)=let
225 :     val id=ref (length params)
226 :     val n=length ind
227 :    
228 :    
229 :    
230 :     fun g(lft,[],_)=(1,lft)
231 :     | g(lft,(E.V s,0,ub)::es,n')=if(s=n') then g(lft@[ub],es,n'+1) else (0,[])
232 :     | g _ =(0,[])
233 :    
234 :     val (c,index')= g([],sx,n)
235 :    
236 :     in case c
237 :     of 0=> ([],(params,E.Sum(sx, E.Prod(list1)),args))
238 :     |_=>let
239 :     val index=ind@index'
240 :     val (lft, newbies,params',args')=hProd(params, index,list1,args)
241 :     val (p',b',args')= shift.cleanParams(E.Sum(sx,E.Prod lft), params@params', args@args')
242 :     val z=List.map (fn(e)=> createnewP(params,args,e) ) newbies
243 :     in
244 :     (z,(p',b',args'))
245 :     end
246 :     end
247 :    
248 :    
249 :    
250 :    
251 :    
252 :     fun genfn(id,Ein.EIN{params, index, body},args)= let
253 :    
254 :     val notDone=([],(params,body,args))
255 :     fun gen body=(case body
256 :     of E.Field _ =>raise Fail(concat["Invalid Field here "] )
257 :     | E.Partial _ =>raise Fail(concat["Invalid Partial here "] )
258 :     | E.Apply _ =>raise Fail(concat["Invalid Apply here "] )
259 :     | E.Probe _ => raise Fail("Probe- Should have been expanded")
260 :     | E.Conv _ =>notDone
261 :     | E.Krn _ =>notDone
262 :     | E.Img _=> notDone
263 :     | E.Const _=> notDone
264 :     | E.Tensor(id,[])=> notDone
265 :     | E.Prod(E.Img _ :: _)=>notDone
266 :     | E.Neg(E.Neg e)=> gen e
267 :     | E.Neg e=> handleNeg(params, index,e,args)
268 :     | E.Add a => handleAdd(params, index,a,args)
269 :     | E.Sub(E.Sub(a,b),E.Sub(c,d))=> gen(E.Sub(E.Add[a,d],E.Add[b,c]))
270 :     | E.Sub(E.Sub(a,b),e2)=>gen (E.Sub(a,E.Add[b,e2]))
271 :     | E.Sub(e1,E.Sub(c,d))=>gen(E.Add([E.Sub(e1,c),d]))
272 :     | E.Sub(e1,e2)=>handleSub(params, index,e1,e2,args)
273 :     | E.Div(E.Div(a,b),E.Div(c,d))=> gen(E.Div(E.Prod[a,d],E.Prod[b,c]))
274 :     | E.Div(E.Div(a,b),c)=> gen(E.Div(a, E.Prod[b,c]))
275 :     | E.Div(a,E.Div(b,c))=> gen(E.Div(E.Prod[a,c],b))
276 :     | E.Div(e1,e2)=>handleDiv(params, index,e1,e2,args)
277 :     | E.Prod e=> handleProd(params, index,e,args)
278 :    
279 :     | E.Sum(_,E.Prod(E.Img _ :: _ ))=>notDone
280 :     | E.Sum(sx,E.Prod e)=> handleSumProd(params, index,sx,e,args)
281 : cchiw 2523
282 :    
283 : cchiw 2522 | _=> notDone
284 :     (*end case*))
285 :    
286 :    
287 :     val (newbie,(p,b,arg))= gen body
288 :     val e'=createEin(p,index, b)
289 :    
290 :    
291 :     val f= (id,e',arg)
292 :     in (newbie, f)
293 :     end
294 :    
295 :    
296 :    
297 :     fun splitIt (change,e)=let
298 :     val (newbie, e')= genfn e
299 :     in (case length(newbie)
300 :     of 0=>(change,[e'])
301 :     | _=> let
302 :     val a=List.map (fn(e1)=>splitIt(1,e1)) newbie
303 :     val newbie'=flat(List.map (fn(e1,e2)=>e2) a)
304 :     in (1,newbie'@[e']) end
305 :     (*end case *))
306 :    
307 :     end
308 :    
309 :     fun splitein(id,E.EIN{params,index,body},arg)=let
310 :     val m=print(printA(id,E.EIN{params=params,index=index,body=body},arg))
311 :     val g=print "\n \t changed to =>\n \t"
312 :     val (p',i',b',args')=shiftHtM.clean(params, index, body, arg)
313 :     val einn'=createEin(p',i', b')
314 :     val m=print(printA(id,einn',args'))
315 :    
316 :     in
317 :     splitIt(0,(id,einn',args'))
318 :     end
319 :    
320 :    
321 :    
322 :    
323 :    
324 :     end (* local *)
325 :    
326 :     end

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