Home My Page Projects Code Snippets Project Openings diderot

# SCM Repository

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

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

revision 2838, Tue Nov 25 03:40:24 2014 UTC revision 3194, Wed May 13 02:57:42 2015 UTC
# Line 4  Line 4
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
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
150                    m(es,rest@[e1'],params',args',code@code',fieldset)
151                end
152              in              in
153                  m(es,rest@[e1'],params',args',code@code')                  m(list1,[],params,args,[],fieldset0)
154              end              end
155
156
157        (*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 rewriteOrig(y,body,params,index,sx,args) =cleanParams(y,body,params,index,args)
162
163        fun rewriteOrig3(sx,body,params,args,x) =let
164            val ((y,DstIL.EINAPP(ein,_)),_,_)=x
165            val index=Ein.index ein
166            in  cleanParams(y,body,params,index,args)
167            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(list1,[],params,args,[])              (einapp,code,fieldset)
178          end          end
179
180      (* prodOps:ein_exp list*params*index*sum_id list*args-> ein_exp list*params*args*code      (* handleSqrt:var*ein_exp *params*index*args-> (var*einap)*code
181       * calls lift  on ein_exp list      * calls rewriteOp() lift  on ein_exp
182       *)       *)
183      fun prodOps(list1,params,index,sx,args)=let      fun handleSqrt(y,e1,params,index,args,fieldset,flag)=let
184          fun m([],rest,params,args,code)=(rest,params,args,code)          val (e1',params',args',code,fieldset)=  rewriteOp("sqrt", e1,params,index,[],args,fieldset,flag)
185          | m(e1::es,rest,params,args,code)=(case (isOp e1)          val body =E.Sqrt e1'
186              of  0   => m(es,rest@[E.Const 0],params,args,code)          val einapp= rewriteOrig(y,body,params',index,[],args')
| 2     => m(es,rest@[e1],params,args,code)
| 1     => let
val (e1',params',args',code')= lift(e1,params,index,sx,args)
187                  in                  in
188                      m(es,rest@[e1'],params',args',code@code')          (einapp,code,fieldset)
189                  end                  end
190              (*end case*))
191
192        (* handleCosine:var*ein_exp *params*index*args-> (var*einap)*code
193        * calls rewriteOp() lift  on ein_exp
194        *)
195        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          in
200              m(list1,[],params,args,[])              (einapp,code,fieldset)
201          end          end
202
203        (* handleArcCosine:var*ein_exp *params*index*args-> (var*einap)*code
204        * calls rewriteOp() lift  on ein_exp
205        *)
206        fun handleArcCosine(y,e1,params,index,args,fieldset,flag)=let
207            val (e1',params',args',code,fieldset)=  rewriteOp("ArcCosine", e1,params,index,[],args,fieldset,flag)
208            val body =E.ArcCosine e1'
209            val einapp= rewriteOrig(y,body,params',index,[],args')
210            in
211                (einapp,code,fieldset)
212        end
213
214      fun isZero(y,body,params,index,args) =(case (cleanI.isZero body)      (* handleSine:var*ein_exp *params*index*args-> (var*einap)*code
215          of 1=>  setEinZero(y,params,[],args)      * calls rewriteOp() lift  on ein_exp
216          | _ =>  cleanParams(y,body,params,index,args)      *)
217      (*end case*))      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      (* handleNeg:var*ein_exp *params*index*args-> (var*einap)*code      (* handleSine:var*ein_exp *params*index*args-> (var*einap)*code
226      * calls simpleOp() lift  on ein_exp      * calls rewriteOp() lift  on ein_exp
227      *)      *)
228      fun handleNeg(y,e1,params,index,args)=let      fun handleArcSine(y,e1,params,index,args,fieldset,flag)=let
229          val (e1',params',args',code)=  simpleOp(e1,params,index,args)          val (e1',params',args',code,fieldset)=  rewriteOp("ArcSine", e1,params,index,[],args,fieldset,flag)
230          val body =E.Neg e1'          val body =E.ArcSine e1'
231          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
232      in      in
233          (einapp,code)              (einapp,code,fieldset)
234      end      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

261      * calls simpleOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
262      *)      *)
264          val (e1',params',args',code)=  simpleOps(e1,params,index,args)
266    fun pb es=String.concatWith "\n\n\t-*-" (List.map P.printbody es)
267    (*)val _ =print("\n****Inside Add:"^Int.toString(length index)^"\n -"^ pb e1 ^"----- newbies\n-"^ pb e1')*)
268
270    val einapp= rewriteOrig(y,body,params',index,[],args')
271    in
272    (einapp,code,fieldset)
273    end
275
277            fun pb es=String.concatWith "\n-" (List.map P.printbody es)
278
279
281          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
282      in      in
283          (einapp,code)              (einapp,code,fieldset)
284      end      end
285
286      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code      (* handleProd:var*ein_exp list*params*index*args-> (var*einap)*code
287       * calls prodOps() lift  on ein_exp       * calls rewriteOps() lift  on ein_exp
288       *)       *)
289      fun handleProd(y,e1,params,index,args)=let      fun handleProd(y,e1,params,index,args,fieldset,flag)=let
290          val (e1',params',args',code)=  prodOps(e1,params,index,[],args)          val (e1',params',args',code,fieldset)=  rewriteOps("prod",e1,params,index,[],args,fieldset,flag)
291          val body =E.Prod e1'          val body =E.Prod e1'
292          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,[],args')
293      in      in
294          (einapp,code)              (einapp,code,fieldset)
295      end      end
296
297     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code     (* handleSumProd:var*ein_exp *params*index*args-> (var*einap)*code
298      * calls prodOps() lift  on ein_exp      * calls rewriteOps() lift  on ein_exp
299      *)      *)
300      fun handleSumProd(y,e1,params,index,sx,args)=let      fun handleSumProd(y,e1,params,index,sx,args,fieldset,flag)=let
301          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)
302          val body= E.Sum(sx,E.Prod e1')          val body= E.Sum(sx,E.Prod e1')
303          val einapp= isZero(y,body,params',index,args')          val einapp= rewriteOrig(y,body,params',index,sx,args')
304      in      in
305          (einapp,code)              (einapp,code,fieldset)
306      end      end
307
308      (* split:var*ein_app-> (var*einap)*code      (* split:var*ein_app-> (var*einap)*code
309      * split ein expression into smaller pieces      * split ein expression into smaller pieces
310          note we leave summation around probe exp
311      *)      *)
312      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
313          val zero=   (setEinZero(y,params,[],args),[])          val x= ((y,einapp),fieldset,flag)
314          val default=((y,einapp),[])          val zero=   (setEinZero y,[],fieldset)
315            val default=((y,einapp),[],fieldset)
316          val sumIndex=ref []          val sumIndex=ref []
317            val str="Poorly formed EIN operator. Argument needs to be applied in High-IL"^(P.printbody body)
318            val _=testp["\n\nStarting split",P.printbody body]
319          fun rewrite b=(case b          fun rewrite b=(case b
320              of E.Probe _              => default              of E.Probe (E.Conv _,_)   => default
321                | E.Probe(E.Field _,_)    => raise Fail str
322                | E.Probe _               => raise Fail str
323              | E.Conv _                => zero              | E.Conv _                => zero
324              | E.Field _               => zero              | E.Field _               => zero
325              | E.Apply _               => zero              | E.Apply _               => zero
326              | E.Lift e                => zero              | E.Lift e                => zero
327              | E.Delta _               => default              | E.Delta _               => default
328              | E.Epsilon _             => default              | E.Epsilon _             => default
329                | E.Eps2 _                => default
330              | E.Tensor _              => default              | E.Tensor _              => default
331              | E.Const _               => default              | E.Const _               => default
332              | E.Neg e1                => handleNeg(y,e1,params,index,args)              | E.ConstR _              => default
333              | E.Sub (e1,e2)           => handleSub(y,e1,e2,params,index,args)              | E.Neg e1                => handleNeg(e1,x)
334              | E.Div (e1,e2)           => handleDiv(y,e1,e2,params,index,args)              | E.Sqrt e1               => handleSqrt(y,e1,params,index,args,fieldset,flag)
335              | E.Sum(_,E.Probe _)      => default              | E.Cosine e1             => handleCosine(y,e1,params,index,args,fieldset,flag)
336              | E.Sum(_,E.Conv _)       => zero              | E.ArcCosine e1          => handleArcCosine(y,e1,params,index,args,fieldset,flag)
337              | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args)              | E.Sine e1               => handleSine(y,e1,params,index,args,fieldset,flag)
338              | E.Sum(sx,E.Neg n)       => rewrite (E.Neg(E.Sum(sx,n)))              | E.ArcSine e1            => handleArcSine(y,e1,params,index,args,fieldset,flag)
339              | E.Sum(sx,E.Add a)       => rewrite (E.Add(List.map (fn e=> E.Sum(sx,e)) a))              | E.PowInt e1             => err(" PowInt unsupported")
340              | E.Sum(sx,E.Sub (e1,e2)) => rewrite (E.Sub(E.Sum(sx,e1),E.Sum(sx,e2)))              | E.PowReal e1            => err(" PowReal unsupported")
341              | 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)
342              | 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)
343              | E.Sum(sx,_)             => default  (*
344              | E.Add e1                => handleAdd(y,e1,params,index,args)              | E.Sum(_,E.Prod[E.Eps2 _, E.Probe(E.Conv _,_)  ])      => default
345              | E.Prod e1               => handleProd(y,e1,params,index,args)              | E.Sum(_,E.Prod[E.Epsilon _, E.Probe(E.Conv _,_)  ])      => default
346    *)
347                | E.Sum(_,E.Probe(E.Conv _,_))    => default
348                | E.Sum(sx,E.Prod e1)     => handleSumProd(y,e1,params,index,sx,args,fieldset,flag)
349                | E.Sum(sx,E.Delta d)     => handleSumProd(y,[E.Delta d],params,index,sx,args,fieldset,flag)
350                | E.Sum(sx,E.Tensor _)    => default
351                | E.Sum(sx,_)             => err(" summation not distributed:"^str)
353                | E.Prod e1               => handleProd(y,e1,params,index,args,fieldset,flag)
354              | E.Partial _             => err(" Partial used after normalize")              | E.Partial _             => err(" Partial used after normalize")
355              | E.Krn _                 => err("Krn used before expand")              | E.Krn _                 => err("Krn used before expand")
356              | E.Value _               => err("Value used before expand")              | E.Value _               => err("Value used before expand")
357              | E.Img _                 => err("Probe used before expand")              | E.Img _                 => err("Probe used before expand")
358              (*end case *))              (*end case *))
359            val (einapp2,newbies,fieldset) =rewrite body
val (einapp2,newbies) =rewrite body
360          in          in
361              (einapp2,newbies)              ((einapp2,newbies),fieldset)
362          end          end
363          |split(y,app) =((y,app),[])          |split((y,app),fieldset,_) =(((y,app),[]),fieldset)
364
365
366      (* iterMultiple:code*code=> (code*code)      fun iterMultiple(einapp2,newbies2,fieldset)=let
367       * recursively split ein expression into smaller pieces          fun itercode([],rest,code,_)=(rest,code)
368      *)            | itercode(e1::newbies,rest,code,cnt)=let
369      fun iterMultiple(einapp2,newbies2)=let                  val ((einapp3,code3),_) = split(e1,fieldset,numFlag)
370          fun itercode([],rest,code)=(rest,code)                      val (rest4,code4)=itercode(code3,[],[],cnt+1)
371          | itercode(e1::newbies,rest,code)=let          in
372              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)
373              end              end
374          val(rest,code)= itercode(newbies2,[],[])              val(rest,code)= itercode(newbies2,[],[],1)
375          in          in
376              (einapp2,code@rest)              ((code)@rest@[einapp2])
377          end          end
378
379
380      fun iterSplit(y,einapp)=let      fun iterAll(einapp2,fieldset)=let
381          val (einapp2,newbies2)=split(y,einapp)          fun itercode([],rest,code,_)=(rest,code)
382            | itercode(e1::newbies,rest,code,cnt)=let
383                val ((einapp3,code3),_) = split(e1,fieldset,numFlag)
384                val (rest4,code4)=itercode(code3,[],[],cnt+1)
385                    val _ =testp [printEINAPP(e1),"\n\t===>\n",printEINAPP(einapp3),"\nand\n",(String.concatWith",\n\t"(List.map printEINAPP (code4@rest4)))]
386      in      in
387          iterMultiple(einapp2,newbies2)                  itercode(newbies,rest@[einapp3],code4@( rest4)@code,cnt+2)
388                end
389            val(rest,code)= itercode(einapp2,[],[],0)
390            in
391                (code@rest)
392      end      end
393
394        fun splitEinApp einapp3= let
395            val fieldset= einSet.EinSet.empty
396
397            (* **** split in parts **** *)
398      (* gettest:code*code=> (code*code)          (*
399      * print results for splitting einapp          val ((einapp4,newbies4),fieldset)=split(einapp3,fieldset,0)
400            val _ =testp["\n\t===>\n",printEINAPP(einapp4),"\nand\n",(String.concatWith",\n\t"(List.map printEINAPP newbies4))]
401            val (newbies5)= iterMultiple(einapp4,newbies4,fieldset)
402      *)      *)
403      fun gettest(einapp)=(case testing
404          of 0=>iterSplit(einapp)          (* **** split all at once **** *)
405          | _=>let          val (newbies5)= iterAll([einapp3],fieldset)
406              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])
407              in              in
408                  (einapp2,newbies)              newbies5
409              end              end
(*end case*))
410
411
412    end; (* local *)    end; (* local *)

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