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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2838, Tue Nov 25 03:40:24 2014 UTC revision 3174, Mon Mar 30 11:46:58 2015 UTC
# Line 4  Line 4 
4   * All rights reserved.   * All rights reserved.
5   *)   *)
6    
7     (*
8      During the transition from high-IL to mid-IL, complicated EIN expressions are split into simpler ones in order to better identify methods for code generation and common subexpressions. Combining EIN operators in the optimization phase can lead to large and complicated EIN operators. A general code generator would need to expand every operation to work on scalars, which could miss the opportunity for vectorization and lead to poor code generation. Instead, every EIN operator is split into a set of simple EIN operators.  Each EIN expression then only has one operation working on  constants, tensors, deltas, epsilons, images and kernels.
9    
10     (1) When the outer EIN operator is $ \in {--, +, -, *, /, \sum}$ then for each subexpression analyze to see if they need to be rewritten.
11    
12     (1a.) When a subexpression is a field expression $\circledast,\nabla $ then it becomes 0. When it is another operation $ {@ --, +, -, *, /, \sum}$ then we lift that subexpression and create a new EIN operator. We replace the subexpression with a tensor expression that represent it's size.
13    
14     (1b) Call cleanIndex.sml to clean the indices in the subexpression, and get the shape for the tensor replacement.
15    
16     (1c) Call cleanParams.sml to clean the params in the subexpression.\\
17     *)
18    
19  structure Split = struct  structure Split = struct
20    
21      local      local
22    
23      structure E = Ein      structure E = Ein
     structure mk= mkOperators  
     structure SrcIL = HighIL  
     structure SrcTy = HighILTypes  
     structure SrcOp = HighOps  
     structure SrcSV = SrcIL.StateVar  
     structure VTbl = SrcIL.Var.Tbl  
24      structure DstIL = MidIL      structure DstIL = MidIL
25      structure DstTy = MidILTypes      structure DstTy = MidILTypes
     structure DstOp = MidOps  
26      structure DstV = DstIL.Var      structure DstV = DstIL.Var
27      structure SrcV = SrcIL.Var  
28      structure P=Printer      structure P=Printer
     structure F=Filter  
     structure T=TransformEin  
     structure Var = MidIL.Var  
29      structure cleanP=cleanParams      structure cleanP=cleanParams
30      structure cleanI=cleanIndex      structure cleanI=cleanIndex
31    
     val testing=1  
     in  
32    
33        in
34    
35        val numFlag=1   (*remove common subexpression*)
36        val testing=0
37      fun setEin(params,index,body)=Ein.EIN{params=params, index=index, body=body}      fun setEin(params,index,body)=Ein.EIN{params=params, index=index, body=body}
38      fun assignEinApp(y,params,index,body,args)= (y,DstIL.EINAPP(setEin(params,index,body),args))      fun assignEinApp(y,params,index,body,args)= (y,DstIL.EINAPP(setEin(params,index,body),args))
39      fun setEinZero(y,params,index,args)=  (y,DstIL.EINAPP(setEin(params,index,E.Const 0),args))      val einappzero=DstIL.EINAPP(setEin([],[],E.Const 0),[])
40        fun setEinZero y=  (y,einappzero)
41      fun cleanParams e =cleanP.cleanParams e      fun cleanParams e =cleanP.cleanParams e
42      fun cleanIndex e =cleanI.cleanIndex e      fun cleanIndex e =cleanI.cleanIndex e
43        fun printEINAPP e=MidToString.printEINAPP e
44      fun itos i =Int.toString i      fun itos i =Int.toString i
45        fun filterSca e=Filter.filterSca e
46      fun err str=raise Fail str      fun err str=raise Fail str
47      val cnt = ref 0      val cnt = ref 0
48        fun incUse (DstIL.V{useCnt, ...}) = (useCnt := !useCnt + 1)
49      fun genName prefix = let      fun genName prefix = let
50          val n = !cnt          val n = !cnt
51      in      in
# Line 53  Line 57 
57          | _ =>(print(String.concat n);1)          | _ =>(print(String.concat n);1)
58          (*end case*))          (*end case*))
59    
     fun printEINAPP(id, DstIL.EINAPP(rator, args))=let  
         val a=String.concatWith " , " (List.map Var.toString args)  
         in  
             String.concat([(DstTy.toString (Var.ty id)),"<",Var.toString id,"> ==",P.printerE rator, a,"\n"])  
         end  
       | printEINAPP(id, DstIL.OP(rator, args))=let  
           val a=String.concatWith " , " (List.map Var.toString args)  
          in  
             String.concat([(DstTy.toString (Var.ty id)),"<",Var.toString id,"> =",DstOp.toString rator,a,"\n"])  
           end  
   
        | printEINAPP(id,_)= String.concat([Var.toString id,"<",(DstTy.toString (Var.ty id)),"> non-einapp\n"])  
   
   
     (* mkreplacement:params*index*index_list*int list* ein_exp-> ein_exp* params*args*code*  
     *creates new param and replacement tensor for the original ein_exp  
     *Then cleans params for suebxpression  
     *)  
     fun mkreplacement(params,args,tshape,sizes,body)=let  
         val id=length(params)  
         val params'=params@[E.TEN(1,sizes)]  
         val e'=E.Tensor(id,tshape)  
         val M  = DstV.new (genName ("TLifted_"^itos id), DstTy.TensorTy sizes)  
         val args'=args@[M]  
         val einapp=cleanParams(M,body,params',sizes,args')  
     in  
             (e',params',args',[einapp])  
     end  
   
60      (* lift:ein_app*params*index*sum_id*args-> (ein_exp* params*args*code)      (* lift:ein_app*params*index*sum_id*args-> (ein_exp* params*args*code)
61      *lifts expression and returns replacement tensor      *lifts expression and returns replacement tensor
62      * cleans the index and params of subexpression      * cleans the index and params of subexpression
63        *creates new param and replacement tensor for the original ein_exp
64      *)      *)
65      fun lift(e,params,index,sx,args)=let      fun lift(name,e,params,index,sx,args,fieldset,flag)=let
66          val (tshape,sizes,body)=cleanIndex(e,index,sx)          val (tshape,sizes,body)=cleanIndex(e,index,sx)
67          val (Re,Rparams,Rargs,code)=mkreplacement(params,args,tshape,sizes,body)          val id=length(params)
68      in          val Rparams=params@[E.TEN(1,sizes)]
69          (Re,Rparams,Rargs,code)          val Re=E.Tensor(id,tshape)
70            val M  = DstV.new (genName (name^"_l_"^itos id), DstTy.TensorTy sizes)
71            val Rargs=args@[M]
72            val einapp=cleanParams(M,body,Rparams,sizes,Rargs)
73            val (_,einapp0)=einapp
74            val (Rargs,newbies,fieldset) =(case flag
75                of 1=> let
76                    val (fieldset,var) = einSet.rtnVar(fieldset,M,einapp0)
77                    in (case var
78                        of NONE=> (args@[M],[einapp],fieldset)
79                        | SOME v=> (incUse v ;(args@[v],[],fieldset))
80                        (*end case*))
81      end      end
82                | _=>(args@[M],[einapp],fieldset)
83      (* simplelift:ein_app*params*index*sum_id*args-> (ein_exp* params*args*code)                (*end case*))
     *lifts expression and returns replacement tensor  
     * cleans params of subexpression  
     *)  
     fun simplelift(e,params,index,args)=(*let  
         val tshape=List.map (fn x => E.V x) index  
         val(Re,Rparams,Rargs,code)=mkreplacement(params,args,tshape,index,e)  
84          in          in
85          (Re,Rparams,Rargs,code)              (Re,Rparams,Rargs,newbies,fieldset)
86          end          end
         *)lift(e,params,index,[],args)  
   
87    
88    
89      (* isOp: ein->int      (* isOp: ein->int
# Line 117  Line 96 
96          | E.Apply _   => 0          | E.Apply _   => 0
97          | E.Lift _    => 0          | E.Lift _    => 0
98          | E.Neg _     => 1          | E.Neg _     => 1
99            | E.Sqrt _    => 1
100            | E.Cosine _      => 1
101            | E.ArcCosine _   => 1
102            | E.Sine _        => 1
103            | E.ArcSine _     => 1
104            | E.PowInt _      => 1
105            | E.PowReal _     => 1
106          | E.Add _     => 1          | E.Add _     => 1
107          | E.Sub _     => 1          | E.Sub _     => 1
108          | E.Prod _    => 1          | E.Prod _    => 1
# Line 131  Line 117 
117      (*end case*))      (*end case*))
118    
119    
     (* simpleOp:ein_exp*params*index*args-> ein_exp*params*args*code  
      * If e1 an op then call simplelift() to replace it  
      * Otherwise rewrite to 0 or it remains the same  
      *)  
     fun simpleOp(e1,params,index,args)=(case (isOp e1)  
         of  0   => (E.Const 0,params,args,[])  
         | 2     => (e1,params,args,[])  
         | _     => simplelift(e1,params,index,args)  
         (*end*))  
120    
121        fun rewriteOp3(name,sx,e1,x)=let
122            val ((y, DstIL.EINAPP(ein,args)),fieldset,flag)=x
123            val params=Ein.params ein
124            val index=Ein.index ein
125            in (case (isOp e1)
126                of  0   => (E.Const 0,params,args,[],fieldset)
127                | 1     => lift(name,e1,params,index,sx,args,fieldset,flag)
128                | 2     => (e1,params,args,[],fieldset)
129                (*end*))
130            end
131    
132      (* simpleOps:ein_exp list*params*index*args-> ein_exp list*params*args*code      (* rewriteOp:ein_exp*params*index*args-> ein_exp*params*args*code
133       * calls simpleOp on ein_exp list      * If e1 an op then call lift() to replace it
134       *)       *)
135      fun simpleOps(list1,params,index,args)=let      fun rewriteOp(name,e1,params,index,sx,args,fieldset,flag)=(case (isOp e1)
136          fun m([],rest,params,args,code)=(rest,params,args,code)          of  0   => (E.Const 0,params,args,[],fieldset)
137          | m(e1::es,rest,params,args,code)=let          | 1     => lift(name,e1,params,index,sx,args,fieldset,flag)
138              val (e1',params',args',code')= simpleOp(e1,params,index,args)          | 2     => (e1,params,args,[],fieldset)             (*not lifted*)
139            (*end*))
140    
141    
142    
143    
144        fun rewriteOps(name,list1,params,index,sx,args,fieldset0,flag)=let
145            fun m([],rest,params,args,code,fieldset)=(rest,params,args,code,fieldset)
146            | m(e1::es,rest,params,args,code,fieldset)=let
147    
148                val (e1',params',args',code',fieldset)= rewriteOp(name,e1,params,index,sx,args,fieldset,flag)
149              in              in
150                  m(es,rest@[e1'],params',args',code@code')                  m(es,rest@[e1'],params',args',code@code',fieldset)
151              end              end
152          in          in
153              m(list1,[],params,args,[])                  m(list1,[],params,args,[],fieldset0)
154          end          end
155    
156      (* prodOps:ein_exp list*params*index*sum_id list*args-> ein_exp list*params*args*code  
157       * calls lift  on ein_exp list      (*rewriteOrig: var* ein_exp* params*index list*mid-il vars
158               When the operation is zero then we return a real.
159            -Moved is Zero to before split.
160       *)       *)
161      fun prodOps(list1,params,index,sx,args)=let      fun rewriteOrig(y,body,params,index,sx,args) =cleanParams(y,body,params,index,args)
162          fun m([],rest,params,args,code)=(rest,params,args,code)  
163          | m(e1::es,rest,params,args,code)=(case (isOp e1)      fun rewriteOrig3(sx,body,params,args,x) =let
164              of  0   => m(es,rest@[E.Const 0],params,args,code)          val ((y,DstIL.EINAPP(ein,_)),_,_)=x
165              | 2     => m(es,rest@[e1],params,args,code)          val index=Ein.index ein
166              | 1     => let          in  cleanParams(y,body,params,index,args)
167                  val (e1',params',args',code')= lift(e1,params,index,sx,args)          end
168    
169        (* handleNeg:var*ein_exp *params*index*args-> (var*einap)*code
170        * calls rewriteOp() lift  on ein_exp
171        *)
172        fun handleNeg(e1,x)=let
173            val (e1',params',args',code,fieldset)=  rewriteOp3("neg",[],e1,x)
174            val body' =E.Neg e1'
175            val einapp= rewriteOrig3([],body',params',args',x)
176                  in                  in
177                      m(es,rest@[e1'],params',args',code@code')              (einapp,code,fieldset)
178                  end                  end
179              (*end case*))  
180        (* handleSqrt:var*ein_exp *params*index*args-> (var*einap)*code
181        * calls rewriteOp() lift  on ein_exp
182        *)
183        fun handleSqrt(y,e1,params,index,args,fieldset,flag)=let
184            val (e1',params',args',code,fieldset)=  rewriteOp("sqrt", e1,params,index,[],args,fieldset,flag)
185            val body =E.Sqrt e1'
186            val einapp= rewriteOrig(y,body,params',index,[],args')
187          in          in
188              m(list1,[],params,args,[])          (einapp,code,fieldset)
189          end          end
190    
191    
192      fun isZero(y,body,params,index,args) =(case (cleanI.isZero body)      (* handleCosine:var*ein_exp *params*index*args-> (var*einap)*code
193          of 1=>  setEinZero(y,params,[],args)      * calls rewriteOp() lift  on ein_exp
194          | _ =>  cleanParams(y,body,params,index,args)      *)
195      (*end case*))      fun handleCosine(y,e1,params,index,args,fieldset,flag)=let
196            val (e1',params',args',code,fieldset)=  rewriteOp("cosine", e1,params,index,[],args,fieldset,flag)
197            val body =E.Cosine e1'
198            val einapp= rewriteOrig(y,body,params',index,[],args')
199            in
200                (einapp,code,fieldset)
201        end
202    
203      (* handleNeg:var*ein_exp *params*index*args-> (var*einap)*code      (* handleArcCosine:var*ein_exp *params*index*args-> (var*einap)*code
204      * calls simpleOp() lift  on ein_exp      * calls rewriteOp() lift  on ein_exp
205      *)      *)
206      fun handleNeg(y,e1,params,index,args)=let      fun handleArcCosine(y,e1,params,index,args,fieldset,flag)=let
207          val (e1',params',args',code)=  simpleOp(e1,params,index,args)          val (e1',params',args',code,fieldset)=  rewriteOp("ArcCosine", e1,params,index,[],args,fieldset,flag)
208          val body =E.Neg e1'          val body =E.ArcCosine e1'
209          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
210      in      in
211          (einapp,code)              (einapp,code,fieldset)
212      end      end
213    
214        (* handleSine:var*ein_exp *params*index*args-> (var*einap)*code
215        * calls rewriteOp() lift  on ein_exp
216        *)
217        fun handleSine(y,e1,params,index,args,fieldset,flag)=let
218            val (e1',params',args',code,fieldset)=  rewriteOp("sine", e1,params,index,[],args,fieldset,flag)
219            val body =E.Sine e1'
220            val einapp= rewriteOrig(y,body,params',index,[],args')
221            in
222                (einapp,code,fieldset)
223        end
224    
225        (* handleSine:var*ein_exp *params*index*args-> (var*einap)*code
226        * calls rewriteOp() lift  on ein_exp
227        *)
228        fun handleArcSine(y,e1,params,index,args,fieldset,flag)=let
229            val (e1',params',args',code,fieldset)=  rewriteOp("ArcSine", e1,params,index,[],args,fieldset,flag)
230            val body =E.ArcSine e1'
231            val einapp= rewriteOrig(y,body,params',index,[],args')
232            in
233                (einapp,code,fieldset)
234            end
235    
236    
237     (* handleSub:var*ein_exp*ein_exp *params*index*args-> (var*einap)*code     (* handleSub:var*ein_exp*ein_exp *params*index*args-> (var*einap)*code
238      * calls simpleOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
239      *)      *)
240      fun handleSub(y,e1,e2,params,index,args)=let      fun handleSub(y,e1,e2,params,index,args,fieldset,flag)=let
241          val ([e1',e2'],params',args',code)=  simpleOps([e1,e2],params,index,args)          val ([e1',e2'],params',args',code,fieldset)=  rewriteOps("subt",[e1,e2],params,index,[],args,fieldset,flag)
242          val body =E.Sub(e1',e2')          val body =E.Sub(e1',e2')
243          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
244      in      in
245          (einapp,code)              (einapp,code,fieldset)
246      end      end
247    
248      (* handleDiv:var*ein_exp *ein_exp*params*index*args-> (var*einap)*code      (* handleDiv:var*ein_exp *ein_exp*params*index*args-> (var*einap)*code
249      * calls simpleOp() lift  on ein_exp      * calls rewriteOp() lift  on ein_exp
250      *)      *)
251      fun handleDiv(y,e1,e2,params,index,args)=let      fun handleDiv(y,e1,e2,params,index,args,fieldset,flag)=let
252          val (e1',params1',args1',code1')=simpleOp(e1,params,index,args)          val (e1',params1',args1',code1',fieldset)=rewriteOp("div-num",e1,params,index,[],args,fieldset,flag)
253          val (e2',params2',args2',code2')=simpleOp(e2,params1',[],args1')          val (e2',params2',args2',code2',fieldset)=rewriteOp("div-denom",e2,params1',index,[],args1',fieldset,flag)
254          val body =E.Div(e1',e2')          val body =E.Div(e1',e2')
255          val einapp= isZero(y,body,params2',index,args2')          val einapp= rewriteOrig(y,body,params2',index,[],args2')
256      in      in
257              (einapp,code1'@code2')                  (einapp,code1'@code2',fieldset)
258      end      end
259    
   
260      (* handleAdd:var*ein_exp list *params*index*args-> (var*einap)*code      (* handleAdd:var*ein_exp list *params*index*args-> (var*einap)*code
261      * calls simpleOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
262      *)      *)
263      fun handleAdd(y,e1,params,index,args)=let      fun handleAdd(y,e1,params,index,args,fieldset,flag)=let
264          val (e1',params',args',code)=  simpleOps(e1,params,index,args)  
265            val (e1',params',args',code,fieldset)=  rewriteOps("add",e1,params,index,[],args,fieldset,flag)
266          val body =E.Add e1'          val body =E.Add e1'
267          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
268      in      in
269          (einapp,code)              (einapp,code,fieldset)
270      end      end
271    
272      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code
273       * calls prodOps() lift  on ein_exp       * calls rewriteOps() lift  on ein_exp
274       *)       *)
275      fun handleProd(y,e1,params,index,args)=let      fun handleProd(y,e1,params,index,args,fieldset,flag)=let
276          val (e1',params',args',code)=  prodOps(e1,params,index,[],args)          val (e1',params',args',code,fieldset)=  rewriteOps("prod",e1,params,index,[],args,fieldset,flag)
277          val body =E.Prod e1'          val body =E.Prod e1'
278          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
279      in      in
280          (einapp,code)              (einapp,code,fieldset)
281      end      end
282    
283     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code
284      * calls prodOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
285      *)      *)
286      fun handleSumProd(y,e1,params,index,sx,args)=let      fun handleSumProd(y,e1,params,index,sx,args,fieldset,flag)=let
287          val _ =List.map (fn (_,_,ub)=> Int.toString ub) sx          val (e1',params',args',code,fieldset)=  rewriteOps("sumprod",e1,params,index,sx,args,fieldset,flag)
         val (e1',params',args',code)=  prodOps(e1,params,index,sx,args)  
288          val body= E.Sum(sx,E.Prod e1')          val body= E.Sum(sx,E.Prod e1')
289          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,sx,args')
290      in      in
291          (einapp,code)              (einapp,code,fieldset)
292      end      end
293    
294      (* split:var*ein_app-> (var*einap)*code      (* split:var*ein_app-> (var*einap)*code
295      * split ein expression into smaller pieces      * split ein expression into smaller pieces
296          note we leave summation around probe exp
297      *)      *)
298      fun split(y,einapp as DstIL.EINAPP(Ein.EIN{params, index, body},args))=let      fun split((y,einapp as DstIL.EINAPP(Ein.EIN{params, index, body},args)),fieldset,flag) =let
299          val zero=   (setEinZero(y,params,[],args),[])          val x= ((y,einapp),fieldset,flag)
300          val default=((y,einapp),[])          val zero=   (setEinZero y,[],fieldset)
301            val default=((y,einapp),[],fieldset)
302          val sumIndex=ref []          val sumIndex=ref []
303            val str="Poorly formed EIN operator. Argument needs to be applied in High-IL"^(P.printbody body)
304            val _=testp["\n\nStarting split",P.printbody body]
305          fun rewrite b=(case b          fun rewrite b=(case b
306              of E.Probe _              => default              of E.Probe (E.Conv _,_)   => default
307                | E.Probe(E.Field _,_)    => raise Fail str
308                | E.Probe _               => raise Fail str
309              | E.Conv _                => zero              | E.Conv _                => zero
310              | E.Field _               => zero              | E.Field _               => zero
311              | E.Apply _               => zero              | E.Apply _               => zero
312              | E.Lift e                => zero              | E.Lift e                => zero
313              | E.Delta _               => default              | E.Delta _               => default
314              | E.Epsilon _             => default              | E.Epsilon _             => default
315                | E.Eps2 _                => default
316              | E.Tensor _              => default              | E.Tensor _              => default
317              | E.Const _               => default              | E.Const _               => default
318              | E.Neg e1                => handleNeg(y,e1,params,index,args)              | E.ConstR _              => default
319              | E.Sub (e1,e2)           => handleSub(y,e1,e2,params,index,args)              | E.Neg e1                => handleNeg(e1,x)
320              | E.Div (e1,e2)           => handleDiv(y,e1,e2,params,index,args)              | E.Sqrt e1               => handleSqrt(y,e1,params,index,args,fieldset,flag)
321              | E.Sum(_,E.Probe _)      => default              | E.Cosine e1             => handleCosine(y,e1,params,index,args,fieldset,flag)
322              | E.Sum(_,E.Conv _)       => zero              | E.ArcCosine e1          => handleArcCosine(y,e1,params,index,args,fieldset,flag)
323              | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args)              | E.Sine e1               => handleSine(y,e1,params,index,args,fieldset,flag)
324              | E.Sum(sx,E.Neg n)       => rewrite (E.Neg(E.Sum(sx,n)))              | E.ArcSine e1            => handleArcSine(y,e1,params,index,args,fieldset,flag)
325              | E.Sum(sx,E.Add a)       => rewrite (E.Add(List.map (fn e=> E.Sum(sx,e)) a))              | E.PowInt e1             => err(" PowInt unsupported")
326              | E.Sum(sx,E.Sub (e1,e2)) => rewrite (E.Sub(E.Sum(sx,e1),E.Sum(sx,e2)))              | E.PowReal e1            => err(" PowReal unsupported")
327              | E.Sum(sx,E.Div(e1,e2))  => rewrite(E.Div(E.Sum(sx,e1),E.Sum(sx,e2)))              | E.Sub (e1,e2)           => handleSub(y,e1,e2,params,index,args,fieldset,flag)
328              | E.Sum(c1, E.Sum (c2,e)) => rewrite (E.Sum (c1@c2,e))              | E.Div (e1,e2)           => handleDiv(y,e1,e2,params,index,args,fieldset,flag)
329              | E.Sum(sx,_)             => default              | E.Sum(_,E.Prod[E.Eps2 _, E.Probe(E.Conv _,_)  ])      => default
330              | E.Add e1                => handleAdd(y,e1,params,index,args)              | E.Sum(_,E.Prod[E.Epsilon _, E.Probe(E.Conv _,_)  ])      => default
331              | E.Prod e1               => handleProd(y,e1,params,index,args)              | E.Sum(_,E.Probe(E.Conv _,_))    => default
332                | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args,fieldset,flag)
333                | E.Sum(sx,E.Delta d)     => handleSumProd(y,[E.Delta d],params,index,sx,args,fieldset,flag)
334                | E.Sum(sx,_)             => err(" summation not distributed:"^str)
335                | E.Add e1                => handleAdd(y,e1,params,index,args,fieldset,flag)
336                | E.Prod e1               => handleProd(y,e1,params,index,args,fieldset,flag)
337              | E.Partial _             => err(" Partial used after normalize")              | E.Partial _             => err(" Partial used after normalize")
338              | E.Krn _                 => err("Krn used before expand")              | E.Krn _                 => err("Krn used before expand")
339              | E.Value _               => err("Value used before expand")              | E.Value _               => err("Value used before expand")
340              | E.Img _                 => err("Probe used before expand")              | E.Img _                 => err("Probe used before expand")
341              (*end case *))              (*end case *))
342            val (einapp2,newbies,fieldset) =rewrite body
         val (einapp2,newbies) =rewrite body  
343          in          in
344              (einapp2,newbies)              ((einapp2,newbies),fieldset)
345          end          end
346          |split(y,app) =((y,app),[])          |split((y,app),fieldset,_) =(((y,app),[]),fieldset)
347    
348    
349      (* iterMultiple:code*code=> (code*code)      fun iterMultiple(einapp2,newbies2,fieldset)=let
350       * recursively split ein expression into smaller pieces          fun itercode([],rest,code,_)=(rest,code)
351      *)            | itercode(e1::newbies,rest,code,cnt)=let
352      fun iterMultiple(einapp2,newbies2)=let                  val ((einapp3,code3),_) = split(e1,fieldset,numFlag)
353          fun itercode([],rest,code)=(rest,code)                      val (rest4,code4)=itercode(code3,[],[],cnt+1)
354          | itercode(e1::newbies,rest,code)=let          in
355              val (einapp3,code3) =split(e1)              itercode(newbies,rest@[einapp3],code4@( rest4)@code,cnt+2)
             val (rest4,code4)=itercode(code3,[],[])  
             in itercode(newbies,rest@[einapp3],code4@rest4@code)  
356              end              end
357          val(rest,code)= itercode(newbies2,[],[])              val(rest,code)= itercode(newbies2,[],[],1)
358          in          in
359              (einapp2,code@rest)              ((code)@rest@[einapp2])
360          end          end
361    
362    
363      fun iterSplit(y,einapp)=let      fun iterAll(einapp2,fieldset)=let
364          val (einapp2,newbies2)=split(y,einapp)          fun itercode([],rest,code,_)=(rest,code)
365            | itercode(e1::newbies,rest,code,cnt)=let
366                val ((einapp3,code3),_) = split(e1,fieldset,numFlag)
367                val (rest4,code4)=itercode(code3,[],[],cnt+1)
368      in      in
369          iterMultiple(einapp2,newbies2)                  itercode(newbies,rest@[einapp3],code4@( rest4)@code,cnt+2)
370                end
371            val(rest,code)= itercode(einapp2,[],[],0)
372            in
373                (code@rest)
374      end      end
375    
376        fun splitEinApp einapp3= let
377            val fieldset= einSet.EinSet.empty
378    
379            (* **** split in parts **** *)
380      (* gettest:code*code=> (code*code)          (*
381      * print results for splitting einapp          val ((einapp4,newbies4),fieldset)=split(einapp3,fieldset,0)
382            val _ =testp["\n\t===>\n",printEINAPP(einapp4),"\nand\n",(String.concatWith",\n\t"(List.map printEINAPP newbies4))]
383            val (newbies5)= iterMultiple(einapp4,newbies4,fieldset)
384      *)      *)
385      fun gettest(einapp)=(case testing  
386          of 0=>iterSplit(einapp)          (* **** split all at once **** *)
387          | _=>let          val (newbies5)= iterAll([einapp3],fieldset)
388              val star="\n*************\n"  
             val _ =print(String.concat[star])  
             val (einapp2,newbies)=iterSplit(einapp)  
             val a=printEINAPP einapp2  
             val b=String.concatWith",\n\t"(List.map printEINAPP newbies)  
             val _ =print(String.concat[printEINAPP einapp,"=>",a," newbies\n\t",b, "\n",a,star])  
389              in              in
390                  (einapp2,newbies)              newbies5
391              end              end
         (*end case*))  
392    
393    
394    end; (* local *)    end; (* local *)

Legend:
Removed from v.2838  
changed lines
  Added in v.3174

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