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 2690, Fri Aug 29 15:41:22 2014 UTC revision 2691, Fri Sep 5 01:59:12 2014 UTC
# Line 30  Line 30 
30    
31      structure Src = LowIL      structure Src = LowIL
32      structure SrcOp = LowOps      structure SrcOp = LowOps
33      structure V = LowIL.Var      structure SrcV = LowIL.Var
34      structure StV = LowIL.StateVar      structure SrcSV = LowIL.StateVar
     structure Dst = TreeIL  
     structure DstOp = TreeOps  
     structure LowOpToTreeOp  = LowOpToTreeOp  
     structure gT=getTypes  
35      structure VA = VarAnalysis      structure VA = VarAnalysis
36      structure Ty = LowILTypes      structure Ty = LowILTypes
37      structure Nd = LowIL.Node      structure Nd = LowIL.Node
38      structure CFG = LowIL.CFG      structure CFG = LowIL.CFG
39      structure TySet=TreeFunc.TySet      structure LowOpToTreeOp  = LowOpToTreeOp
40      structure OprSet=TreeFunc.OprSet      structure Dst = TreeIL
41      structure VTree = TreeIL.Var      structure DstOp = TreeOps
42       structure VLow = LowIL.Var      structure TreeToOpr=TreeToOpr
43        structure Fnc=TreeFunc
44        structure TySet= Fnc.TySet
45        structure OprSet= Fnc.OprSet
46    
47    
48    (* create new tree IL variables *)    (* create new tree IL variables *)
# Line 63  Line 62 
62          | _ =>1          | _ =>1
63      (*end case*))      (*end case*))
64    
65      fun newGlobal x = newVar (genName("G_" ^ V.name x), Dst.VK_Global, V.ty x)      fun newGlobal x = newVar (genName("G_" ^ SrcV.name x), Dst.VK_Global, SrcV.ty x)
66      fun newParam x = newVar (genName("p_" ^ V.name x), Dst.VK_Local, V.ty x)      fun newParam x = newVar (genName("p_" ^ SrcV.name x), Dst.VK_Local, SrcV.ty x)
67      fun newLocal x = newVar (genName("l_" ^ V.name x), Dst.VK_Local, V.ty x)      fun newLocal x = newVar (genName("l_" ^ SrcV.name x), Dst.VK_Local, SrcV.ty x)
68      fun newIter x = newVar (genName("i_" ^ V.name x), Dst.VK_Local, V.ty x)      fun newIter x = newVar (genName("i_" ^ SrcV.name x), Dst.VK_Local, SrcV.ty x)
69      fun newTmp (x,n) = newVar (genName("l_" ^ V.name x^Int.toString n), Dst.VK_Local, V.ty x)      fun newTmp (x,n) = newVar (genName("l_" ^ SrcV.name x^Int.toString n), Dst.VK_Local, SrcV.ty x)
70    
71      end      end
72    
73    (* associate Tree IL state variables with Low IL variables using properties *)    (* associate Tree IL state variables with Low IL variables using properties *)
74      local      local
75        fun mkStateVar x = Dst.SV{        fun mkStateVar x = Dst.SV{
76                name = StV.name x,                name = SrcSV.name x,
77                id = Stamp.new(),                id = Stamp.new(),
78                ty = StV.ty x,                ty = SrcSV.ty x,
79                varying = VA.isVarying x,                varying = VA.isVarying x,
80                output = StV.isOutput x                output = SrcSV.isOutput x
81              }              }
82      in      in
83      val {getFn = getStateVar, ...} = StV.newProp mkStateVar      val {getFn = getStateVar, ...} = SrcSV.newProp mkStateVar
84      end      end
85    
86      fun mkBlock stms = Dst.Block{locals=[], body=stms}      fun mkBlock stms = Dst.Block{locals=[], body=stms}
# Line 92  Line 91 
91     * of locals that have been defined.     * of locals that have been defined.
92     *)     *)
93      local      local
94        structure VT = V.Tbl        structure VT = SrcV.Tbl
95        fun decCount ( Src.V{useCnt, ...}) = let        fun decCount ( Src.V{useCnt, ...}) = let
96              val n = !useCnt - 1              val n = !useCnt - 1
97              in              in
# Line 130  Line 129 
129    
130    
131        fun peelEnv(E{tbl, types, functs ,locals})=(types,functs)        fun peelEnv(E{tbl, types, functs ,locals})=(types,functs)
       fun setEnv(E{tbl, types,functs,locals},types1,functs1)=  
                   E{tbl=tbl, types=types1, functs= functs1 ,locals=locals}  
   
132         fun peelEnvLoc(E{tbl, types, functs ,locals})=locals         fun peelEnvLoc(E{tbl, types, functs ,locals})=locals
133          fun setEnv(E{tbl, types,functs,locals},types1,functs1)= E{tbl=tbl, types=types1, functs= functs1 ,locals=locals}
134    
135    
136  fun bindToString binding = (case binding  fun bindToString binding = (case binding
137         of GLOB y => "GLOB " ^ Dst.Var.name y         of GLOB y => "GLOB " ^ Dst.Var.name y
# Line 157  Line 155 
155      fun useVar (env as E{tbl, ...}) x = (case VT.find tbl x      fun useVar (env as E{tbl, ...}) x = (case VT.find tbl x
156             of SOME(GLOB x') => Dst.E_Var x'             of SOME(GLOB x') => Dst.E_Var x'
157              | SOME(TREE e) => (              | SOME(TREE e) => (
158  (*print(concat["useVar ", V.toString x, " ==> TREE\n"]);*)  (*print(concat["useVar ", SrcV.toString x, " ==> TREE\n"]);*)
159                  ignore(VT.remove tbl x);                  ignore(VT.remove tbl x);
160                  e)                  e)
161              | SOME(DEF e) => (              | SOME(DEF e) => (
162  (*print(concat["useVar ", V.toString x, " ==> ", bindToString(DEF e), "; use count = ", Int.toString(V.useCount x), "\n"]);*)  (*print(concat["useVar ", SrcV.toString x, " ==> ", bindToString(DEF e), "; use count = ", Int.toString(SrcV.useCount x), "\n"]);*)
163                (* if this is the last use of x, then remove it from the table *)                (* if this is the last use of x, then remove it from the table *)
164                  if (decCount x) then ignore(VT.remove tbl x) else ();                  if (decCount x) then ignore(VT.remove tbl x) else ();
165                  e)                  e)
166              | NONE => (              | NONE => (
167  dumpEnv env;  dumpEnv env;
168  raise Fail(concat ["useVar(", V.toString x, ")"])  raise Fail(concat ["useVar(", SrcV.toString x, ")"])
169  )  )
170            (* end case *))            (* end case *))
171    
# Line 175  Line 173 
173      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}
174      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) = E{tbl=tbl,types=types, functs=functs,locals=x@locals}
175       fun testp t=print(String.concat t)       fun testp t=print(String.concat t)
176      fun global (E{tbl, ...}, x, x') =( testp[("\n using global function "^V.name x^":\n")];      fun global (E{tbl, ...}, x, x') =( testp[("\n using global function "^SrcV.name x^":\n")];
177                      VT.insert tbl (x, GLOB x'))                      VT.insert tbl (x, GLOB x'))
178    
179    (* insert a pending expression into the table.  Note that x should only be used once! *)    (* insert a pending expression into the table.  Note that x should only be used once! *)
# Line 192  Line 190 
190          env)          env)
191    
192    
                   (*  
193      fun peekGlobal (E{tbl, ...}, x) = (case VT.find tbl x      fun peekGlobal (E{tbl, ...}, x) = (case VT.find tbl x
194                    of SOME(GLOB x') =>SOME x'                    of SOME(GLOB x') =>SOME x'
195                    | _ =>NONE          | SOME e         => NONE
196            (* end case *))          | NONE           => NONE
                   *)  
   
   
   
     fun peekGlobal (E{tbl, ...}, x) = (case VT.find tbl x  
         of SOME(GLOB x') => (testp ["\n  global: ",V.name x,":\n"] ;SOME x')  
         | SOME e => (testp["\n Not  global:",V.name x,":",bindToString e,"\n"];NONE)  
         | NONE => (testp["\n Not  global:",V.name x,":NONE","\n"];NONE)  
197          (* end case *))          (* end case *))
198    
199    
200      fun bindLocal (env, lhs, rhs) =let      fun bindLocal (env, lhs, rhs) =let
201          val n=V.useCount lhs          val n=SrcV.useCount lhs
202          fun AL _=let          fun AL _=let
203              val t = newLocal lhs              val t = newLocal lhs
204              in              in
# Line 220  Line 209 
209              of (0,_) => AL 1              of (0,_) => AL 1
210              | (1,_)  => (insert(env, lhs, rhs), [])              | (1,_)  => (insert(env, lhs, rhs), [])
211              | (_,Dst.E_Mux(A, nSize,nOrig,Tys as Ty.vectorLength tys,exps))=> let              | (_,Dst.E_Mux(A, nSize,nOrig,Tys as Ty.vectorLength tys,exps))=> let
212                    val name=V.name lhs                    val name=SrcV.name lhs
213                    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
214                    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)
215                    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)
   
216                    in                    in
217                      (renameExp(addLocals(env,xs),lhs,rhs),stmts)                      (renameExp(addLocals(env,xs),lhs,rhs),stmts)
218                    end                    end
# Line 232  Line 220 
220              (*end case*))              (*end case*))
221          end          end
222    
     fun bindGlobal(env,lhs,rhs,x)=let  
223    
224          in (env, [Dst.S_Assign([x], rhs)])      fun bind (env, lhs, rhs) =(case peekGlobal (env, lhs)
225          end          of SOME x =>(env, [Dst.S_Assign([x], rhs)])
226            | NONE =>  bindLocal (env, lhs, rhs)
     fun bind (env, lhs, rhs) =let  
   
      in (case peekGlobal (env, lhs)  
         of SOME x => bindGlobal(env,lhs,rhs,x)  
         | NONE =>( bindLocal (env, lhs, rhs)) (**)  
227          (* end case *))          (* end case *))
       end  
228    
229    (* set the definition of a variable, where the RHS is either a literal constant or a variable *)    (* set the definition of a variable, where the RHS is either a literal constant or a variable *)
230      fun bindSimple (env as E{tbl, ...}, lhs, rhs) =let      fun bindSimple (env as E{tbl, ...}, lhs, rhs) =(case peekGlobal (env, lhs)
   
         in(  
           case peekGlobal (env, lhs)  
231             of SOME x => (env, [Dst.S_Assign([x], rhs)])             of SOME x => (env, [Dst.S_Assign([x], rhs)])
232              | NONE => (VT.insert tbl (lhs, DEF rhs); (env, []))              | NONE => (VT.insert tbl (lhs, DEF rhs); (env, []))
233            (* end case *))            (* end case *))
234          end  
235    
236    (* at the end of a block, we need to assign any pending expressions to locals.  The    (* at the end of a block, we need to assign any pending expressions to locals.  The
237     * blkStms list and the resulting statement list are in reverse order.     * blkStms list and the resulting statement list are in reverse order.
# Line 317  Line 295 
295             case rator             case rator
296               of  SrcOp.LoadVoxels(_, 1) => true               of  SrcOp.LoadVoxels(_, 1) => true
297                |  SrcOp.LoadVoxels _ => false                |  SrcOp.LoadVoxels _ => false
   
                   (*not removed add, sub, neg, scal, mul*)  
   
298                |  SrcOp.EigenVecs2x2 => false                |  SrcOp.EigenVecs2x2 => false
299                |  SrcOp.EigenVecs3x3 => false                |  SrcOp.EigenVecs3x3 => false
300                |  SrcOp.EigenVals2x2 => false                |  SrcOp.EigenVals2x2 => false
301                |  SrcOp.EigenVals3x3 => false                |  SrcOp.EigenVals3x3 => false
   
302  (*              | SrcOp.Zero _ => Target.inlineMatrixExp*)  (*              | SrcOp.Zero _ => Target.inlineMatrixExp*)
303    
304               (*Added here *)               (*Added here *)
             (*when false calls assignExp *)  
             (*sumvec- commenting out, we don't generate function*)  
              | SrcOp.sumVec n    => false  
   
305               | SrcOp.imgAddr _      => false               | SrcOp.imgAddr _      => false
306               | SrcOp.imgLoad _      => false               | SrcOp.imgLoad _      => false
307               | _ => true (*when true calls binding *)               | _ => true (*when true calls binding *)
# Line 355  Line 325 
325     *)     *)
326    
327    
     fun rhsToString e=(case e  
         of Src.STATE x => "State"  
         | Src.VAR x => "var"  
         | Src.LIT lit =>"lit"  
         | Src.OP(rator, args) =>"op"  
         | Src.APPLY(f, args) =>"apply"  
         | Src.CONS(ty, args) => "cons"  
         | Src.EINAPP _=> "einapp"  
     (*end case*))  
   
   
   
328    
329      fun doAssign (env, (lhs, rhs)) = let      fun doAssign (env, (lhs, rhs)) = let
330    
   
331            fun doLHS () = (case peekGlobal(env, lhs)            fun doLHS () = (case peekGlobal(env, lhs)
332              of SOME lhs' => (env, lhs')              of SOME lhs' => (env, lhs')
333              | NONE => let              | NONE => let
# Line 428  Line 385 
385                    end*)                    end*)
386    
387    
   
388                | Src.OP(rator,args) =>let                | Src.OP(rator,args) =>let
   
389                  val args'=List.map (useVar env) args                  val args'=List.map (useVar env) args
390                    fun getFNC(env,stms)=let
391                   fun useCount (LowIL.V{useCnt, ...}) = !useCnt                  val t1=peelEnv(env)
392                  fun foundVec(rator,n,argsS, argsV)= let                  val (ty2,opr2)= List.foldr (fn(e1,e2) => TreeToOpr.stmtToOpr (e2,e1)) t1 stms
                     val (isFill,newSize,Pieces)=Target.getVecTy n  
                     val (env, t) = doLHS()  
   
   
                     val cnt=useCount lhs  
                     val (expOpt,storeVecStatement) = LowOpToTreeOp.vecToTree(t,cnt,rator,newSize,n,Pieces,argsS,argsV,isFill)  
   
                     val isBind=true  
   
   
   
                     in (case (expOpt,storeVecStatement)  
                         of (SOME x,_)=>let  
                              val _=testp ["\n **\nExp- RESULT ",Dst.toString x]  
                             in  
                                 if isBind then  bind (env, lhs, x)  
                                 else assignExp (env, x)  
                             end  
                         | (NONE,SOME x)=> let  
                             val _ =testp ["\n **\nStmt- RESULT ",Dst.toStringS x]  
393                              in                              in
394                                  (env,[x])                  setEnv(env, ty2,opr2)
395                              end                              end
396                    fun foundVec(rator,oSize,argsS,argsV)= let
397                        val (isFill,nSize,Pieces)=Target.getVecTy oSize
398                        val (env, t) = doLHS()
399                        val (expOpt,storeVecStatement) = LowOpToTreeOp.vecToTree(t,rator,nSize,oSize,Pieces,argsS,argsV,isFill)
400                        val (env,stmts)=(case (expOpt,storeVecStatement)
401                            of (SOME exp,_)=>   bind (env, lhs, exp)
402                            | (NONE,SOME stmt)=> (env,[stmt])
403                          (*end case*))                          (*end case*))
404                        val _ =testp(["\n **\nStmt- RESULT "]@List.map Dst.toStringS stmts)
405                        in
406                           (getFNC(env, stmts),stmts)
407                     end                     end
   
                 val _= testp ["\n **************************** \n Analyzing ", SrcOp.toString rator]  
                                         (* removed sumVec*)  
   
   
408                  in (case (rator,args')                  in (case (rator,args')
409                       of (SrcOp.addVec n,_)        =>  foundVec(DstOp.addVec,n,[],args')                       of (SrcOp.addVec n,_)        =>  foundVec(DstOp.addVec,n,[],args')
410                       | (SrcOp.subVec n,_)         =>  foundVec(DstOp.subVec,n,[],args')                       | (SrcOp.subVec n,_)         =>  foundVec(DstOp.subVec,n,[],args')
# Line 474  Line 413 
413                       | (SrcOp.dotVec n ,_)     =>  foundVec(DstOp.dotVec ,n,[],args')                       | (SrcOp.dotVec n ,_)     =>  foundVec(DstOp.dotVec ,n,[],args')
414                       | (SrcOp.sumVec n ,_)     =>  foundVec(DstOp.sumVec ,n,[],args')                       | (SrcOp.sumVec n ,_)     =>  foundVec(DstOp.sumVec ,n,[],args')
415                       | (SrcOp.Floor n ,_)         =>  foundVec(DstOp.Floor ,n,[],args')                       | (SrcOp.Floor n ,_)         =>  foundVec(DstOp.Floor ,n,[],args')
   
                         (* removed sumVec*)  
416                       | (SrcOp.Kernel _,_)         => (env, [])                       | (SrcOp.Kernel _,_)         => (env, [])
417                       | (SrcOp.LoadImage info,[a]) => let                       | (SrcOp.LoadImage info,[a]) => let
418                              (*Moved to outside*)                              (*Moved to outside*)
# Line 532  Line 469 
469    
470    
471    
   
472      fun trCFG (env, prefix, finish, cfg) = let      fun trCFG (env, prefix, finish, cfg) = let
473    
474    
475            (*look at stmts and collect oprSet and tySet*)
476          fun getFNC(env,stms)=let          fun getFNC(env,stms)=let
   
477              val t1=peelEnv(env)              val t1=peelEnv(env)
478              val (ty2,opr2)= List.foldr (fn(e1,e2) => gT.stmtToOpr (e2,e1)) t1 stms              val (ty2,opr2)= List.foldr (fn(e1,e2) => TreeToOpr.stmtToOpr (e2,e1)) t1 stms
479              in              in
480                  setEnv(env, ty2,opr2)                  setEnv(env, ty2,opr2)
481              end              end
# Line 594  Line 530 
530                        doNode (env, ifStk, Dst.S_Comment text :: stms, !succ)                        doNode (env, ifStk, Dst.S_Comment text :: stms, !succ)
531                    | Src.ASSIGN{stm, succ, ...} => let                    | Src.ASSIGN{stm, succ, ...} => let
532                        val (env, stms') = doAssign (env, stm)                        val (env, stms') = doAssign (env, stm)
   
533                        in                        in
534                              doNode (getFNC(env, stms'), ifStk, stms' @ stms, !succ)                              doNode ((*getFNC(env, stms')*) env , ifStk, stms' @ stms, !succ)
535                        end                        end
536                    | Src.MASSIGN{stm=(ys, rator, xs), succ, ...} => let                    | Src.MASSIGN{stm=(ys, rator, xs), succ, ...} => let
537    
# Line 628  Line 563 
563                    | Src.NEW{strand, args, succ, ...} => raise Fail "NEW unimplemented"                    | Src.NEW{strand, args, succ, ...} => raise Fail "NEW unimplemented"
564                    | Src.SAVE{lhs, rhs, succ, ...} => let                    | Src.SAVE{lhs, rhs, succ, ...} => let
565                          (*How to get var form stateVar?*)                          (*How to get var form stateVar?*)
566                         (*Dst.S_Save([getStateVar lhs], useVar env rhs)*)                          val _=print "\n *********** \n FOUND SAVE \n"
   
567                        val stm=(case  (getStateVar lhs,useVar env rhs)                        val stm=(case  (getStateVar lhs,useVar env rhs)
568                           of (x,Dst.E_Mux(A,nSize, oSize,pieces,args))                           of (x,Dst.E_Mux(A,nSize, oSize,pieces,args))
569                                  =>Dst.S_StoreVec( Dst.E_State x,A,nSize, oSize,pieces,args)                                  =>Dst.S_StoreVec( Dst.E_State x,A,nSize, oSize,pieces,args)
570                          | (x,rhs')=>Dst.S_Save([x], rhs')  
571                          | (x,Dst.E_Var rhs')=>(print (String.concat["\t rhs: ",Dst.toString (Dst.E_Var rhs'),"--"]);Dst.S_Save([x], Dst.E_Var rhs'))
572    
573                            | (x,rhs')=>(print (String.concat["\t rhs: ",Dst.toString  rhs',"--end "]);Dst.S_Save([x], rhs'))
574                          (*end case*))                          (*end case*))
575    
576    
# Line 788  Line 725 
725            val (typs,opr)= peelEnv(env)            val (typs,opr)= peelEnv(env)
726            val typsList=TySet.listItems(typs);            val typsList=TySet.listItems(typs);
727            val oprList=OprSet.listItems(opr);            val oprList=OprSet.listItems(opr);
728            val _=testp[(TreeFunc.setToString(typsList,oprList,"--FinalPostStrands--"))]            val _=testp[(Fnc.setToString(typsList,oprList,"--FinalPostStrands--"))]
729    
730            in  Dst.Program{            in  Dst.Program{
731                    props = props,                    props = props,

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

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