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

SCM Repository

[diderot] Annotation of /branches/charisee_dev/src/compiler/high-to-mid/ProbeEin.sml
ViewVC logotype

Annotation of /branches/charisee_dev/src/compiler/high-to-mid/ProbeEin.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3503 - (view) (download)

1 : cchiw 2845 (* Expands probe ein
2 : cchiw 2606 *
3 : jhr 3349 * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2015 The University of Chicago
6 : cchiw 2606 * All rights reserved.
7 :     *)
8 :    
9 :     structure ProbeEin = struct
10 :    
11 :     local
12 :    
13 :     structure E = Ein
14 :     structure DstIL = MidIL
15 :     structure DstOp = MidOps
16 : jhr 3060 structure P = Printer
17 :     structure T = TransformEin
18 :     structure MidToS = MidToString
19 : cchiw 2976 structure DstV = DstIL.Var
20 :     structure DstTy = MidILTypes
21 :    
22 : cchiw 2606 in
23 :    
24 : cchiw 2870 (* This file expands probed fields
25 :     * Take a look at ProbeEin tex file for examples
26 :     *Note that the original field is an EIN operator in the form <V_alpha * H^(deltas)>(midIL.var list )
27 :     * Param_ids are used to note the placement of the argument in the midIL.var list
28 :     * Index_ids keep track of the shape of an Image or differentiation.
29 :     * Mu bind Index_id
30 :     * Generally, we will refer to the following
31 :     *dim:dimension of field V
32 :     * s: support of kernel H
33 :     * alpha: The alpha in <V_alpha * H^(deltas)>
34 :     * deltas: The deltas in <V_alpha * H^(deltas)>
35 :     * Vid:param_id for V
36 :     * hid:param_id for H
37 :     * nid: integer position param_id
38 :     * fid :fractional position param_id
39 : cchiw 3166 * img-imginfo about V
40 : cchiw 2870 *)
41 : cchiw 3033
42 : cchiw 2923 val testing=0
43 : cchiw 3325 val valnumflag=true
44 : cchiw 3459 val tsplitvar=true
45 :     val fieldliftflag=true
46 : cchiw 3460 val constflag=true
47 : cchiw 3459 val detflag =true
48 :     val detsumflag=true
49 : cchiw 3503 fun incUse (DstIL.V{useCnt, ...}) = (useCnt := !useCnt + 1)
50 :     fun decUse (DstIL.V{useCnt, ...}) = (useCnt := !useCnt - 1)
51 : cchiw 3307
52 : cchiw 2845 val cnt = ref 0
53 :     fun transformToIndexSpace e=T.transformToIndexSpace e
54 :     fun transformToImgSpace e=T.transformToImgSpace e
55 : cchiw 3268 fun toStringBind e=(MidToString.toStringBind e)
56 : cchiw 3260 fun mkEin e=Ein.mkEin e
57 : cchiw 3033 fun mkEinApp(rator,args)=DstIL.EINAPP(rator,args)
58 : cchiw 3441 fun setConst e = E.setConst e
59 :     fun setNeg e = E.setNeg e
60 :     fun setExp e = E.setExp e
61 :     fun setDiv e= E.setDiv e
62 :     fun setSub e= E.setSub e
63 :     fun setProd e= E.setProd e
64 :     fun setAdd e= E.setAdd e
65 : cchiw 3472 fun mkCx es =List.map (fn c => E.C (c,true)) es
66 :     fun mkCxSingle c = E.C (c,true)
67 : cchiw 3441
68 : cchiw 2845 fun testp n=(case testing
69 :     of 0=> 1
70 : cchiw 3472 | _ =>(print(String.concat n);1)
71 : cchiw 2845 (*end case*))
72 : cchiw 3260
73 :    
74 : cchiw 2845 fun getRHSDst x = (case DstIL.Var.binding x
75 :     of DstIL.VB_RHS(DstIL.OP(rator, args)) => (rator, args)
76 :     | DstIL.VB_RHS(DstIL.VAR x') => getRHSDst x'
77 :     | vb => raise Fail(concat[ "expected rhs operator for ", DstIL.Var.toString x, "but found ", DstIL.vbToString vb])
78 :     (* end case *))
79 : cchiw 2838
80 : cchiw 2606
81 : cchiw 2845 (* getArgsDst:MidIL.Var* MidIL.Var->int, ImageInfo, int
82 :     uses the Param_ids for the image, kernel,
83 :     and position tensor to get the Mid-IL arguments
84 :     returns the support of ther kernel, and image
85 :     *)
86 : jhr 3060 fun getArgsDst(hArg,imgArg,args) = (case (getRHSDst hArg, getRHSDst imgArg)
87 :     of ((DstOp.Kernel(h, i), _ ), (DstOp.LoadImage(_, _, img), _ ))=> let
88 : cchiw 2845 in
89 : jhr 3060 ((Kernel.support h) ,img,ImageInfo.dim img)
90 : cchiw 2845 end
91 : cchiw 3441 | ((k,_),(i,_)) => raise Fail (String.concat["Expected kernel:", (DstOp.toString k ),"Expected Image:", (DstOp.toString i)])
92 : cchiw 2845 (*end case*))
93 : cchiw 2606
94 :    
95 : cchiw 2845 (*handleArgs():int*int*int*Mid IL.Var list
96 :     ->int*Mid.ILVars list* code*int* low-il-var
97 :     * uses the Param_ids for the image, kernel, and tensor
98 :     * and gets the mid-IL vars for each.
99 :     *Transforms the position to index space
100 :     *P is the mid-il var for the (transformation matrix)transpose
101 :     *)
102 :     fun handleArgs(Vid,hid,tid,args)=let
103 :     val imgArg=List.nth(args,Vid)
104 :     val hArg=List.nth(args,hid)
105 :     val newposArg=List.nth(args,tid)
106 :     val (s,img,dim) =getArgsDst(hArg,imgArg,args)
107 :     val (argsT,P,code)=transformToImgSpace(dim,img,newposArg,imgArg)
108 : cchiw 2606 in
109 : cchiw 2845 (dim,args@argsT,code, s,P)
110 : cchiw 2606 end
111 : cchiw 2838
112 : cchiw 2845 (*createBody:int*int*int,mu list, param_id, param_id, param_id, param_id
113 :     * expands the body for the probed field
114 :     *)
115 :     fun createBody(dim, s,sx,alpha,deltas,Vid, hid, nid, fid)=let
116 :     (*1-d fields*)
117 :     fun createKRND1 ()=let
118 :     val sum=sx
119 : cchiw 3472 val dels=List.map (fn e=>(mkCxSingle 0,e)) deltas
120 : cchiw 3441 val pos=[setAdd[E.Tensor(fid,[]),E.Value(sum)]]
121 :     val rest= E.Krn(hid,dels,setSub(E.Tensor(nid,[]),E.Value(sum)))
122 : cchiw 2845 in
123 : cchiw 3441 setProd[E.Img(Vid,alpha,pos),rest]
124 : cchiw 2843 end
125 : cchiw 2845 (*createKRN Image field and kernels *)
126 : cchiw 3441 fun createKRN(0,imgpos,rest)=setProd ([E.Img(Vid,alpha,imgpos)] @rest)
127 : cchiw 2845 | createKRN(dim,imgpos,rest)=let
128 :     val dim'=dim-1
129 :     val sum=sx+dim'
130 : cchiw 3472 val dels=List.map (fn e=>(mkCxSingle dim',e)) deltas
131 :     val pos=[setAdd[E.Tensor(fid,[mkCxSingle dim']),E.Value(sum)]]
132 :     val rest'= E.Krn(hid,dels,setSub(E.Tensor(nid,[mkCxSingle dim']),E.Value(sum)))
133 : cchiw 2845 in
134 :     createKRN(dim',pos@imgpos,[rest']@rest)
135 :     end
136 :     val exp=(case dim
137 :     of 1 => createKRND1()
138 :     | _=> createKRN(dim, [],[])
139 :     (*end case*))
140 :     (*sumIndex creating summaiton Index for body*)
141 :     val slb=1-s
142 : cchiw 3383 val _=List.tabulate(dim, (fn dim=> (String.concat[" sx:",Int.toString(sx)," dim:",Int.toString(dim),"esum",Int.toString(sx+dim) ]) ))
143 : cchiw 2845 val esum=List.tabulate(dim, (fn dim=>(E.V (dim+sx),slb,s)))
144 : cchiw 2843 in
145 : cchiw 2845 E.Sum(esum, exp)
146 : cchiw 2606 end
147 :    
148 : cchiw 2845 (*getsumshift:sum_indexid list* int list-> int
149 :     *get fresh/unused index_id, returns int
150 :     *)
151 : cchiw 3383 fun getsumshift(sx,n) =let
152 : cchiw 2845 val nsumshift= (case sx
153 : cchiw 3383 of []=> n
154 : cchiw 2845 | _=>let
155 :     val (E.V v,_,_)=List.hd(List.rev sx)
156 :     in v+1
157 :     end
158 :     (* end case *))
159 : cchiw 3383
160 : cchiw 2845 val aa=List.map (fn (E.V v,_,_)=>Int.toString v) sx
161 : cchiw 3383 val _ =(String.concat["\n", "SumIndex:" ,(String.concatWith"," aa),
162 :     "\n\t Index length:",Int.toString n,
163 :     "\n\t Freshindex: ", Int.toString nsumshift])
164 : cchiw 2845 in
165 :     nsumshift
166 :     end
167 : cchiw 2611
168 : cchiw 2845 (*formBody:ein_exp->ein_exp
169 :     *just does a quick rewrite
170 :     *)
171 :     fun formBody(E.Sum([],e))=formBody e
172 :     | formBody(E.Sum(sx,e))= E.Sum(sx,formBody e)
173 : cchiw 3441 | formBody(E.Opn(E.Prod, [e]))=e
174 : cchiw 2845 | formBody e=e
175 : cchiw 2606
176 : cchiw 2976 (* silly change in order of the product to match vis branch WorldtoSpace functions*)
177 : cchiw 3441 fun multiPs([P0,P1,P2],sx,body)= formBody(E.Sum(sx, setProd[P0,P1,P2,body]))
178 : cchiw 3353 (*
179 : cchiw 3441 | multiPs([P0,P1],sx,body)=formBody(E.Sum(sx, setProd([P0,body,P1])))
180 : cchiw 3353 *)
181 : cchiw 3441 | multiPs([P0,P1,P2,P3],sx,body)= formBody(E.Sum(sx, setProd[P0,P1,P2,P3,body]))
182 :     | multiPs(Ps,sx,body)=formBody(E.Sum(sx,setProd([body]@Ps)))
183 : cchiw 3195
184 : cchiw 2976
185 : cchiw 3441 fun multiMergePs([P0,P1],[sx0,sx1],body)=E.Sum([sx0],setProd[P0,E.Sum([sx1],setProd[P1,body])])
186 : cchiw 3195 | multiMergePs e=multiPs e
187 :    
188 :    
189 : cchiw 3472 (* ******************************************* Replace probe ******************************************* *)
190 :     (* replaceProbe
191 : cchiw 2845 * Transforms position to world space
192 :     * transforms result back to index_space
193 :     * rewrites body
194 :     * replace probe with expanded version
195 :     *)
196 : cchiw 3472 fun replaceProbe((y, DstIL.EINAPP(e,args)),p ,sx)
197 : cchiw 3048 =let
198 :     val originalb=Ein.body e
199 :     val params=Ein.params e
200 :     val index=Ein.index e
201 : cchiw 3267 val _ = testp["\n***************** \n Replace ************ \n"]
202 : cchiw 3260 val _= toStringBind (y, DstIL.EINAPP(e,args))
203 : cchiw 3048
204 :     val E.Probe(E.Conv(Vid,alpha,hid,dx),E.Tensor(tid,_))=p
205 : cchiw 2845 val fid=length(params)
206 :     val nid=fid+1
207 :     val Pid=nid+1
208 :     val nshift=length(dx)
209 :     val (dim,argsA,code,s,PArg) = handleArgs(Vid,hid,tid,args)
210 : cchiw 3383 val freshIndex=getsumshift(sx,length(index))
211 : cchiw 2845 val (dx,newsx1,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)
212 :     val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim]),E.TEN(1,[dim,dim])]
213 :     val body' = createBody(dim, s,freshIndex+nshift,alpha,dx,Vid, hid, nid, fid)
214 : cchiw 2976 val body' = multiPs(Ps,newsx1,body')
215 : cchiw 3033
216 :     val body'=(case originalb
217 :     of E.Sum(sx, E.Probe _) => E.Sum(sx,body')
218 : cchiw 3441 | E.Sum(sx,E.Opn(E.Prod,[eps0,E.Probe _ ])) => E.Sum(sx,setProd[eps0,body'])
219 : cchiw 3033 | _ => body'
220 :     (*end case*))
221 :    
222 : cchiw 2845 val args'=argsA@[PArg]
223 : cchiw 3033 val einapp=(y,mkEinApp(mkEin(params',index,body'),args'))
224 :     in
225 :     code@[einapp]
226 : cchiw 2845 end
227 : cchiw 2976
228 : cchiw 3472 (* ******************************************* Lift probe ******************************************* *)
229 : cchiw 3048 fun createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)= let
230 : cchiw 2976 val Pid=0
231 :     val tid=1
232 : cchiw 3260
233 :     (*Assumes body is already clean*)
234 : cchiw 3048 val (newdx,newsx,Ps)=transformToIndexSpace(freshIndex,dim,dx,Pid)
235 :    
236 :     (*need to rewrite dx*)
237 : cchiw 3260 val (_,sizes,e as E.Conv(_,alpha',_,dx))=(case sx@newsx
238 : cchiw 3048 of []=> ([],index,E.Conv(9,alpha,7,newdx))
239 : cchiw 3260 | _ => cleanIndex.cleanIndex(E.Conv(9,alpha,7,newdx),index,sx@newsx)
240 : cchiw 3048 (*end case*))
241 :    
242 :     val params=[E.TEN(1,[dim,dim]),E.TEN(1,sizes)]
243 : cchiw 3260 fun filterAlpha []=[]
244 :     | filterAlpha(E.C _::es)= filterAlpha es
245 :     | filterAlpha(e1::es)=[e1]@(filterAlpha es)
246 :    
247 :     val tshape=filterAlpha(alpha')@newdx
248 : cchiw 3033 val t=E.Tensor(tid,tshape)
249 : cchiw 3441
250 : cchiw 3195 val (splitvar,body)=(case originalb
251 : cchiw 3441 of E.Sum(sx, E.Probe _) => (true,multiPs(Ps,sx@newsx,t))
252 :     | E.Sum(sx,E.Opn(E.Prod,[eps0,E.Probe _ ])) => (false,E.Sum(sx,setProd[eps0,multiPs(Ps,newsx,t)]))
253 : cchiw 3195 | _ => (case tsplitvar
254 : cchiw 3441 of(* true => (true,multiMergePs(Ps,newsx,t)) (*pushes summations in place*)
255 : cchiw 3259 | false*) _ => (true,multiPs(Ps,newsx,t))
256 : cchiw 3195 (*end case*))
257 : cchiw 3441 (*end case*))
258 : cchiw 3048
259 : cchiw 3324 val _ =(case splitvar
260 : cchiw 3325 of true=> (String.concat["splitvar is true", P.printbody body])
261 :     | _ => (String.concat["splitvar is false",P.printbody body])
262 : cchiw 3324 (*end case*))
263 :    
264 :    
265 : cchiw 3048 val ein0=mkEin(params,index,body)
266 : cchiw 2976 in
267 : cchiw 3260 (splitvar,ein0,sizes,dx,alpha')
268 : cchiw 2976 end
269 : cchiw 3048
270 : cchiw 3472 fun liftProbe((y, DstIL.EINAPP(e,args)),p ,sx)=let
271 : cchiw 3441 val _=testp["\n******* Lift Geneirc Probe ***\n"]
272 : cchiw 3048 val originalb=Ein.body e
273 :     val params=Ein.params e
274 : cchiw 3189 val index=Ein.index e
275 : cchiw 3383 val _ = (toStringBind (y, DstIL.EINAPP(e,args)))
276 : cchiw 2976
277 : cchiw 3048 val E.Probe(E.Conv(Vid,alpha,hid,dx),E.Tensor(tid,_))=p
278 : cchiw 2976 val fid=length(params)
279 :     val nid=fid+1
280 :     val nshift=length(dx)
281 : cchiw 3048 val (dim,args',code,s,PArg) = handleArgs(Vid,hid,tid,args)
282 : cchiw 3383 val freshIndex=getsumshift(sx,length(index))
283 : cchiw 2976
284 :     (*transform T*P*P..Ps*)
285 : cchiw 3260 val (splitvar,ein0,sizes,dx,alpha')= createEinApp(originalb,alpha,index,freshIndex,dim,dx,sx)
286 : cchiw 3441
287 : cchiw 3048 val FArg = DstV.new ("F", DstTy.TensorTy(sizes))
288 :     val einApp0=mkEinApp(ein0,[PArg,FArg])
289 : cchiw 3195 val rtn0=(case splitvar
290 : cchiw 3324 of false => [(y,mkEinApp(ein0,[PArg,FArg]))]
291 :     | _ => let
292 :     val bind3 = (y,DstIL.EINAPP(SummationEin.main ein0,[PArg,FArg]))
293 : cchiw 3440 in Split.splitEinApp bind3
294 : cchiw 3324 end
295 : cchiw 3195 (*end case*))
296 : cchiw 2976
297 :     (*lifted probe*)
298 :     val params'=params@[E.TEN(3,[dim]),E.TEN(1,[dim])]
299 : cchiw 3383 val freshIndex'= length(sizes)
300 :    
301 :     val body' = createBody(dim, s,freshIndex',alpha',dx,Vid, hid, nid, fid)
302 : cchiw 3033 val ein1=mkEin(params',sizes,body')
303 : cchiw 2976 val einApp1=mkEinApp(ein1,args')
304 : cchiw 3048 val rtn1=(FArg,einApp1)
305 : cchiw 3195 val rtn=code@[rtn1]@rtn0
306 : cchiw 3260 val _= List.map toStringBind ([rtn1]@rtn0)
307 : cchiw 3383 val _=(String.concat["\n* end Lift Geneirc Probe ******** \n"])
308 : cchiw 2976 in
309 :     rtn
310 :     end
311 : cchiw 3383
312 : cchiw 3472 (* ******************************************* Reconstruction -> Lift|Replace probe ******************************************* *)
313 :     (* scans dx for contant
314 :     * arg:(1,code1, body1,[])
315 :     *)
316 :     fun reconstruction([],arg)= replaceProbe arg
317 :     | reconstruction(dx,arg)=(case (constflag,fieldliftflag)
318 :     of (true,true) => liftProbe arg
319 :     | (_,false) => replaceProbe arg
320 :     | _ => let
321 :     fun fConst [] = liftProbe arg
322 :     | fConst (E.C _::_) = replaceProbe arg
323 :     | fConst (_ ::es)= fConst es
324 :     in fConst dx end
325 :     (* end case*))
326 : cchiw 3383
327 : cchiw 3472 (* **************************************************** Index Tensor **************************************************** *)
328 :     (*Push constant indices to tensor replacement*)
329 :     fun getF (e,fieldset,dim,newvx)= let
330 : cchiw 3324 val (y, DstIL.EINAPP(ein,args))=e
331 :     val index0=Ein.index ein
332 : cchiw 3472 val index1 = index0@dim
333 :     val b=Ein.body ein
334 : cchiw 3324
335 : cchiw 3472 val (c1,dx,body1)=(case b
336 :     of E.Sum([(vsum,0,n)],E.Probe(E.Conv(V,[c1,v0],h,dx),pos))=>let
337 :     val shiftdx=List.tabulate(length(dx),fn n=>E.V (n+2))
338 :     val b=E.Probe(E.Conv(V,[E.V 0,E.V 1],h,shiftdx),pos)
339 :     in (c1,dx,b) end
340 :     | E.Probe(E.Conv(V,[c1,v0],h,dx),pos)=> let
341 :     val body1_unshifted= E.Probe(E.Conv(V,[E.V newvx, v0],h,dx),pos)
342 :     (* clean to get body indices in order *)
343 :     val ( _ , _, body1)= cleanIndex.cleanIndex(body1_unshifted,index1,[])
344 :     in (c1,dx,body1) end
345 :     | E.Probe(E.Conv(V,[c1],h,dx),pos)=> let
346 :     val body1_unshifted= E.Probe(E.Conv(V,[E.V newvx],h,dx),pos)
347 :     val ( _ , _, body1)= cleanIndex.cleanIndex(body1_unshifted,index1,[])
348 :     in (c1,dx,body1) end
349 :     (*end case*))
350 :    
351 : cchiw 3324 val lhs1=DstV.new ("L", DstTy.TensorTy(index1))
352 :     val ein1 = mkEin(Ein.params ein,index1,body1)
353 :     val code1= (lhs1,mkEinApp(ein1,args))
354 : cchiw 3472
355 :     val (_,(lhs0,codeAll))= (case valnumflag
356 :     of false => (fieldset,(lhs1, reconstruction(dx,(code1,body1,[]))))
357 : cchiw 3503 | true => (case (einVarSet.rtnVarN(fieldset,code1))
358 : cchiw 3472 of (fieldset,NONE) => (fieldset,(lhs1, reconstruction(dx,(code1,body1,[]))))
359 :     | (fieldset,SOME m) => (fieldset,(m,[]))
360 :     (*end case*))
361 : cchiw 3383 (*end case*))
362 : cchiw 3472
363 : cchiw 3324 (*Probe that tensor at a constant position c1*)
364 :     val param0 = [E.TEN(1,index1)]
365 : cchiw 3472 val nx=List.tabulate(newvx,fn n=>E.V n)
366 :     val body0 = (case b
367 :     of E.Sum([(vsum,0,n)],_)=> E.Sum([(vsum,0,n)],E.Tensor(0,[vsum,vsum]@nx))
368 :     | _ => E.Tensor(0,[c1]@nx)
369 :     (*end case*))
370 : cchiw 3324 val ein0 = mkEin(param0,index0,body0)
371 : cchiw 3472 val einApp0 = mkEinApp(ein0,[lhs0])
372 : cchiw 3324 val code0 = (y,einApp0)
373 : cchiw 3472 val _= toStringBind code0
374 : cchiw 3324 in
375 : cchiw 3472 codeAll@[code0]
376 :     end
377 :     (* **************************************************** General Fn **************************************************** *)
378 : cchiw 2845 (* expandEinOp: code-> code list
379 : cchiw 3259 * A this point we only have simple ein ops
380 :     * Looks to see if the expression has a probe. If so, replaces it.
381 : cchiw 2845 * Note how we keeps eps expressions so only generate pieces that are used
382 :     *)
383 : cchiw 3503 fun expandEinOp( e0 as (y, DstIL.EINAPP(ein,args)),fieldset,varset)=let
384 :     fun rewriteBody(e,p as E.Probe(E.Conv(_,alpha,_,dx),_))= (case (detflag,alpha,dx)
385 : cchiw 3472 of (true,[E.C(_,true), E.V 0],[]) => getF(e,fieldset,[3],1)
386 :     | (true,[E.C(_,true), E.V 0],[E.V 1]) => getF(e,fieldset,[3],2)
387 :     | (true,[E.C(_,true), E.V 0],[E.V 1,E.V 2]) => getF(e,fieldset,[3],3)
388 :     | (true,[E.C(_,true)],[]) => getF(e,fieldset,[3],0)
389 :     | (true,[E.C(_,true)],[E.V 0]) => getF(e,fieldset,[3],1)
390 :     | (true,[E.C(_,true)],[E.V 0,E.V 1]) => getF(e,fieldset,[3],2)
391 :     | (true,[E.C(_,true)],[E.V 0,E.V 1,E.V 2]) => getF(e,fieldset,[3],3)
392 :     | _ => reconstruction(dx,(e,p,[]))
393 :     (*end case*))
394 : cchiw 3503 | rewriteBody(e,E.Sum(sx,p as E.Probe(E.Conv(_,alpha,_,dx),_)))= (case (detsumflag,sx,alpha,dx)
395 : cchiw 3472 of (true,[(E.V 0,0,_)],[E.V 0 ,E.V 0],[]) => getF(e,fieldset,[3,3],0)
396 :     | (true,[(E.V 1,0,_)],[E.V 1 ,E.V 1],[E.V 0]) => getF(e,fieldset,[3,3],1)
397 :     | (true,[(E.V 2,0,_)],[E.V 2 ,E.V 2],[E.V 0,E.V 1]) => getF(e,fieldset,[3,3],2)
398 :     | (_,_,_,[]) => replaceProbe(e,p, sx) (*no dx*)
399 :     | (_,_,[],_) => reconstruction(dx,(e,p,sx))
400 :     | _ => replaceProbe(e,p, sx)
401 : cchiw 2845 (* end case *))
402 : cchiw 3503 | rewriteBody(e,E.Sum(sx,E.Opn(E.Prod,[eps,E.Probe p]))) = replaceProbe(e,E.Probe p,sx)
403 :     | rewriteBody (e,_) = [e]
404 : cchiw 3174
405 : cchiw 3472 val b=Ein.body ein
406 :     fun matchField()=(case b
407 : cchiw 3271 of E.Probe _ => 1
408 :     | E.Sum (_, E.Probe _)=>1
409 : cchiw 3441 | E.Sum(_, E.Opn(E.Prod,[ _ ,E.Probe _]))=>1
410 : cchiw 3271 | _ =>0
411 :     (*end case*))
412 : cchiw 3503 val (fieldset,varset,code,flag) = (case valnumflag
413 :     of true => (case (einVarSet.rtnVarN(fieldset,e0))
414 :     of (fldset,NONE) => (fldset,varset,rewriteBody(e0,b),0)
415 :     | (fldset,SOME v) => (fldset,varset,[(y,DstIL.VAR v)],1)
416 :     (*of (fldset, NONE) => (fldset,varset,rewriteBody((y,DstIL.EINAPP(ein,List.map (fn a=>einVarSet.replaceArg(varset,a)) args)), b),0)
417 :     | (fldset,SOME v) => (fldset,einVarSet.VarSet.add(varset,einVarSet.VAR(v,y)),[],1)*)
418 : cchiw 3472 (*end case*))
419 : cchiw 3503 | _ => (fieldset,varset,rewriteBody(e0, b),0)
420 : cchiw 3327 (*end case*))
421 : cchiw 3472 val m=matchField()
422 : cchiw 3503 in (code,fieldset,varset,m,flag) end
423 : cchiw 2843
424 : cchiw 2606 end; (* local *)
425 :    
426 : cchiw 2845 end (* local *)

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