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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/tree-il/low-to-tree-fn.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/tree-il/low-to-tree-fn.sml

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

revision 2691, Fri Sep 5 01:59:12 2014 UTC revision 2692, Mon Sep 8 22:57:47 2014 UTC
# Line 39  Line 39 
39      structure LowOpToTreeOp  = LowOpToTreeOp      structure LowOpToTreeOp  = LowOpToTreeOp
40      structure Dst = TreeIL      structure Dst = TreeIL
41      structure DstOp = TreeOps      structure DstOp = TreeOps
42           structure DstV = Dst.Var
43      structure TreeToOpr=TreeToOpr      structure TreeToOpr=TreeToOpr
44      structure Fnc=TreeFunc      structure Fnc=TreeFunc
45      structure TySet= Fnc.TySet      structure TySet= Fnc.TySet
46      structure OprSet= Fnc.OprSet      structure OprSet= Fnc.OprSet
47    
   
48    (* create new tree IL variables *)    (* create new tree IL variables *)
49      local      local
50        val newVar = Dst.Var.new        val newVar = Dst.Var.new
# Line 137  Line 137 
137         of GLOB y => "GLOB " ^ Dst.Var.name y         of GLOB y => "GLOB " ^ Dst.Var.name y
138          | TREE e => "TREE"          | TREE e => "TREE"
139          | DEF(Dst.E_Var y) => "DEFVar " ^ Dst.Var.name y          | DEF(Dst.E_Var y) => "DEFVar " ^ Dst.Var.name y
140          | DEF e => "DEF"          | DEF e => "DEF"^Dst.toString  e
141        (* end case *))        (* end case *))
142  fun dumpEnv (E{tbl, ...}) = let  fun dumpEnv (E{tbl, ...}) = let
143        fun prEntry (x, binding) =        fun prEntry (x, binding) =
# Line 152  Line 152 
152      fun newEnv () = E{tbl = VT.mkTable (512, Fail "tbl"),  types=TySet.empty, functs=OprSet.empty, locals=[]}      fun newEnv () = E{tbl = VT.mkTable (512, Fail "tbl"),  types=TySet.empty, functs=OprSet.empty, locals=[]}
153    
154    (* use a variable.  If it is a pending expression, we remove it from the table *)    (* use a variable.  If it is a pending expression, we remove it from the table *)
155            fun peek (env as E{tbl, ...}) x =  (case (VT.find tbl x)
156                    of NONE=>"none"
157                    | SOME e=> bindToString e
158                (*end case *))
159    
160      fun useVar (env as E{tbl, ...}) x = (case VT.find tbl x      fun useVar (env as E{tbl, ...}) x = (case VT.find tbl x
161             of SOME(GLOB x') => Dst.E_Var x'             of SOME(GLOB x') => Dst.E_Var x'
162              | SOME(TREE e) => (              | SOME(TREE e) => (
# Line 170  Line 175 
175            (* end case *))            (* end case *))
176    
177    (* record a local variable *)    (* record a local variable *)
178    
179        fun getLocal(E{tbl, types,functs,locals})=let
180            val n=List.length locals
181                      val _ =print ("No. of locals:" ^Int.toString n )
182            in
183                      List.map (fn e=>print("\n\t VAr-"^DstV.name e)) locals
184    
185            end
186      fun addLocal (E{tbl, types,functs,locals}, x) = E{tbl=tbl,types=types, functs=functs,locals=x::locals}      fun addLocal (E{tbl, types,functs,locals}, x) = E{tbl=tbl,types=types, functs=functs,locals=x::locals}
187      fun addLocals (E{tbl, types,functs,locals}, x) = E{tbl=tbl,types=types, functs=functs,locals=x@locals}      fun addLocals (E{tbl, types,functs,locals}, x) =let
188                      val n=List.length locals
189                      val n2=List.length x
190                      val _ =print ("No. of locals:" ^Int.toString n^" newbies " ^Int.toString n2)
191                      val env= E{tbl=tbl,types=types, functs=functs,locals=x@locals}
192                      val _ = getLocal env
193                      in
194                        env
195                    end
196    
197      fun testp t=print(String.concat t)      fun testp t=print(String.concat t)
198      fun global (E{tbl, ...}, x, x') =( testp[("\n using global function "^SrcV.name x^":\n")];      fun global (E{tbl, ...}, x, x') =( testp[("\n using global function "^SrcV.name x^":\n")];
199                      VT.insert tbl (x, GLOB x'))                      VT.insert tbl (x, GLOB x'))
# Line 185  Line 207 
207            VT.insert tbl (x, DEF(Dst.E_Var x'));            VT.insert tbl (x, DEF(Dst.E_Var x'));
208            env)            env)
209    
210        fun renameGlob (env as E{tbl, ...}, x, x') = (
211            VT.insert tbl (x, GLOB( x'));
212            env)
213    
214      fun renameExp (env as E{tbl, ...}, x, x') = (      fun renameExp (env as E{tbl, ...}, x, x') = (
215          VT.insert tbl (x, DEF( x'));          VT.insert tbl (x, DEF( x'));
216          env)          env)
# Line 197  Line 223 
223      (* end case *))      (* end case *))
224    
225    
226            (*creates load expressions if needed*)
227            fun bindCons (env, lhs,t, ty as Ty.TensorTy [oSize],args) =let
228                 val _=print "\n In bind cons ----\n"
229                val _= dumpEnv env
230                val _="\n ----\n"
231                val _= dumpEnv env
232                val name=SrcV.name lhs
233                in (case (SrcV.useCount lhs)
234                of _ =>let
235                         val _=print(String.concat(["\n Global cons \n\t \t lHS-",name, "\n\t t -",DstV.name t,"\n"]))
236                      in (env,[Dst.S_Cons(t,ty,args)]) end
237                (* | _ => let
238    
239    
240                           val _=print "\n\t new envs-plain \n "
241                      val _= dumpEnv env
242                      val (isFill,nSize,Pieces)=Target.getVecTy oSize
243    
244                     val  (xs,rhs,stmts)=LowOpToTreeOp.consArrToTree(lhs,nSize,oSize,Pieces,args,isFill)
245    
246    
247    
248                       val _ =print(String.concat(["\n\t vars: "]@ List.map (fn e=>Dst.toString(Dst.E_Var e ) )xs))
249    
250                      val st=String.concatWith ",\n\t " (List.map Dst.toStringS stmts)
251                      val _=print(String.concat(["\n Global cons \n\t ",st,"\n\t lHS-",SrcV.name lhs, "\n\t t -",DstV.name t,"\n \t RHS-" ,Dst.toString rhs,"\n "]))
252    
253                      val env=renameExp(addLocals(env,xs),lhs,rhs)
254    
255                      in
256                        (env,stmts)
257                      end
258                  *)
259            (*end case*))
260            end
261    
262    
263      fun bindLocal (env, lhs, rhs) =let      fun bindLocal (env, lhs, rhs) =let
264          val n=SrcV.useCount lhs          val n=SrcV.useCount lhs
265          fun AL _=let          fun AL _=let
# Line 213  Line 276 
276                    val xs=List.map (fn n=>  Dst.Var.new(name^Int.toString(n), Dst.VK_Local,Ty.TensorTy [n]) ) tys                    val xs=List.map (fn n=>  Dst.Var.new(name^Int.toString(n), Dst.VK_Local,Ty.TensorTy [n]) ) tys
277                    val rhs=Dst.E_Mux(A, nSize,nOrig,Tys,List.map (fn v=>Dst.E_Var v) xs)                    val rhs=Dst.E_Mux(A, nSize,nOrig,Tys,List.map (fn v=>Dst.E_Var v) xs)
278                    val stmts=ListPair.map  (fn(x,e)=>Dst.S_Assign([x],e)) (xs,exps)                    val stmts=ListPair.map  (fn(x,e)=>Dst.S_Assign([x],e)) (xs,exps)
279                      val env'=addLocals(env,xs)
280                      val env''=renameExp(env',lhs,rhs)
281                      val _= dumpEnv env
282                      val _=getLocal env
283                      val _=print "\n\t new env"
284                      val _= dumpEnv env'
285                    in                    in
286                      (renameExp(addLocals(env,xs),lhs,rhs),stmts)                      (env',stmts)
287                    end                    end
288              |(_,_)=> AL 1              |(_,_)=> AL 1
289              (*end case*))              (*end case*))
# Line 357  Line 426 
426                        end                        end
427                  (* end case *))                  (* end case *))
428    
429            val _=toS.ASSIGNtoString(lhs,rhs)
430    
431            in            in
432              case rhs              case rhs
433                  of Src.STATE x  => bindSimple (env, lhs, Dst.E_State(getStateVar x))                  of Src.STATE x  => bindSimple (env, lhs, Dst.E_State(getStateVar x))
# Line 387  Line 458 
458    
459                | Src.OP(rator,args) =>let                | Src.OP(rator,args) =>let
460                  val args'=List.map (useVar env) args                  val args'=List.map (useVar env) args
461                  fun getFNC(env,stms)=let  
                 val t1=peelEnv(env)  
                 val (ty2,opr2)= List.foldr (fn(e1,e2) => TreeToOpr.stmtToOpr (e2,e1)) t1 stms  
                 in  
                 setEnv(env, ty2,opr2)  
                 end  
462                  fun foundVec(rator,oSize,argsS,argsV)= let                  fun foundVec(rator,oSize,argsS,argsV)= let
463                      val (isFill,nSize,Pieces)=Target.getVecTy oSize                      val (isFill,nSize,Pieces)=Target.getVecTy oSize
464                      val (env, t) = doLHS()                      val (env, t) = doLHS()
465                      val (expOpt,storeVecStatement) = LowOpToTreeOp.vecToTree(t,rator,nSize,oSize,Pieces,argsS,argsV,isFill)                      val (expOpt,storeVecStatement) = LowOpToTreeOp.vecToTree(t,rator,nSize,oSize,Pieces,argsS,argsV,isFill)
466                         val n1=SrcV.useCount lhs
467    
468                      val (env,stmts)=(case (expOpt,storeVecStatement)                      val (env,stmts)=(case (expOpt,storeVecStatement)
469                          of (SOME exp,_)=>   bind (env, lhs, exp)                          of (SOME exp,_)=>let
470                          | (NONE,SOME stmt)=> (env,[stmt])                              val _ = testp ["\n ****  Exp \n",Dst.toString exp,"\n******\n"]
471                                in
472                                    bind (env, lhs, exp)
473                                end
474                            | (NONE,SOME stmt)=> let
475                                val _ =testp(["\n **\nStmt- RESULT ", Dst.toStringS stmt,"\n******\n"])
476                                in
477                                    (env,[stmt])
478                                end
479                          (*end case*))                          (*end case*))
                     val _ =testp(["\n **\nStmt- RESULT "]@List.map Dst.toStringS stmts)  
480                      in                      in
481                         (getFNC(env, stmts),stmts)                         (env,stmts)
482                     end                     end
483                  in (case (rator,args')                  in (case (rator,args')
484                       of (SrcOp.addVec n,_)        =>  foundVec(DstOp.addVec,n,[],args')                       of (SrcOp.addVec n,_)        =>  foundVec(DstOp.addVec,n,[],args')
# Line 433  Line 508 
508    
509                | Src.APPLY(f, args) =>                | Src.APPLY(f, args) =>
510                    bind (env, lhs, Dst.E_Apply(f, List.map (useVar env) args))                    bind (env, lhs, Dst.E_Apply(f, List.map (useVar env) args))
511    
512                  | Src.CONS(ty as Ty.TensorTy[oSize], args) => let
513                        (*(env,[Dst.S_Cons(x,ty,args')])-Without using Mux *)
514    
515                    val _=print "\n ****************** \n found cons \n"
516                     val _= dumpEnv env
517                    val args'=List.map (useVar env) args
518                        (*don't know how to tell if lhs of var is a local var, so we have to use assignExp first *)
519    
520    
521                    val (envv, t) = doLHS()
522    
523                    val (isFill,nSize,Pieces)=Target.getVecTy oSize
524    
525    
526                    val (envvv,rst) =(case DstV.kind t
527                        of TreeIL.VK_Local=> let
528                            val exp=   LowOpToTreeOp.consVecToTree(nSize,oSize,Pieces,args',isFill)
529                            val _ =print (String.concat ["\n\t Found local Vector Cons \n",Dst.toString exp,"\n******\n"])
530                            in
531                                bind (envv, lhs, exp)
532                            end
533                        | _ => bindCons (envv, lhs,t, ty ,args')
534                    (*end case*))
535    
536                     val _= dumpEnv envvv
537                    val _=print( "\n end cons \n  ****************** \n")
538    
539    
540                    in
541                        (envvv,rst)
542                    end
543    
544                | Src.CONS(ty, args) => let                | Src.CONS(ty, args) => let
545                    val exp = Dst.E_Cons(ty, List.map (useVar env) args)                    val exp = Dst.E_Cons(ty, List.map (useVar env) args)
546                    in                    in
# Line 440  Line 548 
548                        then bind (env, lhs, exp)                        then bind (env, lhs, exp)
549                        else assignExp (env, exp)                        else assignExp (env, exp)
550                    end                    end
551    
552               | Src.EINAPP _=> raise Fail "EINAPP in Low-IL to Tree-IL"               | Src.EINAPP _=> raise Fail "EINAPP in Low-IL to Tree-IL"
553              (* end case *)              (* end case *)
554            end            end
# Line 531  Line 640 
640                    | Src.ASSIGN{stm, succ, ...} => let                    | Src.ASSIGN{stm, succ, ...} => let
641                        val (env, stms') = doAssign (env, stm)                        val (env, stms') = doAssign (env, stm)
642                        in                        in
643                              doNode ((*getFNC(env, stms')*) env , ifStk, stms' @ stms, !succ)                              doNode (getFNC(env, stms')  , ifStk, stms' @ stms, !succ)
644                        end                        end
645                    | Src.MASSIGN{stm=(ys, rator, xs), succ, ...} => let                    | Src.MASSIGN{stm=(ys, rator, xs), succ, ...} => let
646    
# Line 563  Line 672 
672                    | Src.NEW{strand, args, succ, ...} => raise Fail "NEW unimplemented"                    | Src.NEW{strand, args, succ, ...} => raise Fail "NEW unimplemented"
673                    | Src.SAVE{lhs, rhs, succ, ...} => let                    | Src.SAVE{lhs, rhs, succ, ...} => let
674                          (*How to get var form stateVar?*)                          (*How to get var form stateVar?*)
675                          val _=print "\n *********** \n FOUND SAVE \n"                          val _=print ("\n *********** \n FOUND SAVE \n")
676    
677                            fun cat c = print (peek env c)
678                            val n1=SrcV.useCount rhs
679                            fun decCount ( Src.V{useCnt, ...}) = let
680                                val n = !useCnt - 1
681                                in
682                                    useCnt := n;  (0 >= n)
683                                    end
684    
685                        val stm=(case  (getStateVar lhs,useVar env rhs)                        val stm=(case  (getStateVar lhs,useVar env rhs)
686                           of (x,Dst.E_Mux(A,nSize, oSize,pieces,args))                           of (x,Dst.E_Mux(A,nSize, oSize,pieces,args))
687                                  =>Dst.S_StoreVec( Dst.E_State x,A,nSize, oSize,pieces,args)                              =>(decCount rhs ;Dst.S_StoreVec( Dst.E_State x,A,nSize, oSize,pieces,args))
688    
689                        | (x,Dst.E_Var rhs')=>(print (String.concat["\t rhs: ",Dst.toString (Dst.E_Var rhs'),"--"]);Dst.S_Save([x], Dst.E_Var rhs'))                              (*table need low-il*)
690                            | (x,Dst.E_Var rhs')=>(print (String.concat["\t rhs: ",Dst.toString (Dst.E_Var rhs'),"--"]);cat rhs;
691                                Dst.S_Save([x], Dst.E_Var rhs'))
692    
693                          | (x,rhs')=>(print (String.concat["\t rhs: ",Dst.toString  rhs',"--end "]);Dst.S_Save([x], rhs'))                          | (x,rhs')=>(print (String.concat["\t rhs: ",Dst.toString  rhs',"--end "]);Dst.S_Save([x], rhs'))
694                                  (*end case*))                                  (*end case*))
695    
696                            val n2=SrcV.useCount rhs
697                            val _=testp ["Counts ",Int.toString(n1), " to " ,Int.toString(n2),"\n"]
698    
699    
700                            val _=testp (["Src.Save\n  lhs, rhs \n \t",toS.SAVEtoString(lhs,rhs),"\n new statement\n New stmt \n \t --",Dst.toStringS stm,"\n rest of statements   \n\t"]@List.map  Dst.toStringS stms)
701    
702    
                         val _=testp (["Src.Save\n",toS.SAVEtoString(lhs,rhs),"\n",Dst.toStringS stm,"\n rest \n\t"]@List.map  Dst.toStringS stms)  
703                          val stmts=stm::stms                          val stmts=stm::stms
704                        in                        in
705                          doNode (getFNC(env, stmts), ifStk, stmts, !succ)                          doNode (getFNC(env, stmts), ifStk, stmts, !succ)
# Line 725  Line 850 
850            val (typs,opr)= peelEnv(env)            val (typs,opr)= peelEnv(env)
851            val typsList=TySet.listItems(typs);            val typsList=TySet.listItems(typs);
852            val oprList=OprSet.listItems(opr);            val oprList=OprSet.listItems(opr);
853            val _=testp[(Fnc.setToString(typsList,oprList,"--FinalPostStrands--"))]            val _=testp[(Fnc.setListToString(typsList,oprList,"--FinalPostStrands--"))]
854    
855            in  Dst.Program{            in  Dst.Program{
856                    props = props,                    props = props,

Legend:
Removed from v.2691  
changed lines
  Added in v.2692

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