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 3196, Fri May 29 18:42:37 2015 UTC revision 3197, Tue Jun 2 17:11:42 2015 UTC
# Line 135  Line 135 
135        fun setEnv (E{tbl, types,functs,locals}, types1, functs1) =        fun setEnv (E{tbl, types,functs,locals}, types1, functs1) =
136              E{tbl=tbl, types=types1, functs= functs1 ,locals=locals}              E{tbl=tbl, types=types1, functs= functs1 ,locals=locals}
137    
138    
139       (*addOprFromExp: env* TreeIL.Exp-> env       (*addOprFromExp: env* TreeIL.Exp-> env
140        * get new opr and type set and store it into the environment        * get new opr and type set and store it into the environment
141        *)        *)
# Line 201  Line 202 
202    
203      (* record a local variable *)      (* record a local variable *)
204      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}
205      fun addLocals (E{tbl, types,functs,locals}, x) = E{tbl=tbl,types=types, functs=functs,locals=x@locals}  
206        fun pntVar es=List.map (fn e=> print((DstV.name e)^","))es
207        fun addLocals (E{tbl, types,functs,locals}, x) =
208                        (E{tbl=tbl,types=types, functs=functs,locals=x@locals})
209      fun global (E{tbl, ...}, x, x') = (VT.insert tbl (x, GLOB x'))      fun global (E{tbl, ...}, x, x') = (VT.insert tbl (x, GLOB x'))
210    
211    (* 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 439  Line 443 
443              case rhs              case rhs
444                  of Src.STATE x  =>let                  of Src.STATE x  =>let
445                      (* Hmm, what to do with State nodes.                      (* Hmm, what to do with State nodes.
446                      * They get represented like globals but their other operations register their kind as local                      * They get represented like globals
447                        * but their other operations register their kind as local
448                      * Leads to trouble in their representation                      * Leads to trouble in their representation
449                      *  Fix me, once we change representation of state and local vars                      *  Fix me, once we change representation of state and local vars
450                      * currently we load 1 piece when it is a local var.                      * currently we load 1 piece when it is a local var.
# Line 451  Line 456 
456                      val (env, vt) = doLHS()                      val (env, vt) = doLHS()
457                      val t=Dst.E_State(getStateVar x)                      val t=Dst.E_State(getStateVar x)
458                      val exp=(case (DstV.kind vt, DstV.ty vt)                      val exp=(case (DstV.kind vt, DstV.ty vt)
459                          of (Dst.VK_Local,DstTy.TensorTy [oSize])=>let                          of (Dst.VK_Local,DstTy.TensorTy [6])=>let
460                                val (isFill,nSize,pieces)=Target.getVecTy 6
461                                val op1= Dst.E_LoadArr(false ,4,6, t , Dst.E_Lit(Literal.Int 0))
462                                val op2= Dst.E_LoadArr(false ,2,6, t , Dst.E_Lit(Literal.Int 4))
463                                val splitTy=DstTy.vectorLength pieces
464                                in    Dst.E_Mux(false,false,6,splitTy,[op1,op2])
465                                end
466                            | (Dst.VK_Local,DstTy.TensorTy [oSize])=>let
467                                  val (isFill,nSize,pieces)=Target.getVecTy oSize                                  val (isFill,nSize,pieces)=Target.getVecTy oSize
468                                  val op1= Dst.E_LoadArr(false ,nSize,oSize, t , Dst.E_Lit(Literal.Int 0))                                  val op1= Dst.E_LoadArr(false ,nSize,oSize, t , Dst.E_Lit(Literal.Int 0))
469                                    val splitTy=DstTy.vectorLength pieces                                    val splitTy=DstTy.vectorLength pieces
# Line 461  Line 473 
473                          (*end case *))                          (*end case *))
474    
475                      val (env,stmt)= bindSimple (env, lhs,exp)                      val (env,stmt)= bindSimple (env, lhs,exp)
476                      val _ =(String.concat["\n**** State-",Dst.toString exp,"\n =>",Dst.toString exp])                      val _ =print (String.concat["\n**** State-",Dst.toString exp,"\n =>",Dst.toString exp])
477                      (*adds loadArr function to env*)                      (*adds loadArr function to env*)
478                      val env'=addOprFromExp(env, exp)                      val env'=addOprFromExp(env, exp)
479    
# Line 589  Line 601 
601                          bind (env, lhs, exp)                          bind (env, lhs, exp)
602                      end                      end
603    
604                  |Src.OP(SrcOp.LdVec 3,[arg]) => let                  | Src.OP(rator,args) => let
605    
606                        val args'=List.map (useVar env) args
607                        fun g e= print(String.concat e)
608                        fun f(str,e)=g [str,String.concatWith",\n"(List.map (Dst.toStringS) e)]
609                        val _ =g[ "\n ***********************************\n New Op \n \t\t",
610                            SrcV.name lhs,"-",SrcOp.toString rator]
611    
612                        val num = List.tabulate(length(args), (fn n =>n ))
613                        val _ =ListPair.map( fn(n, a)=>
614                        print(String.concat["\n Args",Int.toString(n), "-Exp: ",Dst.toString a])) (num,args')
615    
616                        fun foundVec(n,srcrator,dstrator)= let
617                            val (env0, lhst) = doLHS()
618                            val m=ListPair.map  (fn(srcv,dstv)=>(srcv,dstv)) (args,args')
619                            val (stmt0,stmtn,vs,needtobind) = LowOpToTreeOp.vecToTree((srcrator,m),(lhst,n,dstrator,Target.getVecTy n))
620    
621                      val exp= Dst.E_LoadArr(false ,4,3,(useVar env) arg, Dst.E_Lit(Literal.Int 0))  
622                            (*add local variables and bindings to envt*)
623                            fun iter([],env1)=env1
624                              | iter((lhs,Dst.E_Var v0,v)::es,env1)= let
625                                    val exp=Dst.E_Var v0
626                                    val _ =g["\n**\t Bind: ",(SrcV.name lhs),"=>", Dst.toString exp]
627                                    val env2=rename(env1,lhs,v0)
628                                    val env3 = global(env2,lhs,v)
629                      in                      in
630                          bind(env,lhs,exp)                                      iter(es,env2)
631                      end                      end
632    
633                  | Src.OP(rator,args) => let  
634                      val args'=List.map (useVar env) args                          val (env1,stmts)=(case stmt0
635                       val _ =testp[ "\n ***** New Op \n \t\t",SrcV.name lhs,"-",SrcOp.toString rator,Int.toString(length(args))                              of Dst.S_Assign(_,exp)=> bind (env0, lhs, exp)
636                              , " Args(\n\t",String.concatWith"\n\t\t," (List.map (fn e=> Dst.toString e) args'),")"]                              | stmt=> (env0,[stmt0])
                     (*foundVec:SrcOp.op* DstOP.ops*int*DstVar list *DstVar list  
                      * Found a vector operation.  
                     * Rewrites to correctly-sized vector operations  
                     *)  
                     fun foundVec(origrator,rator,oSize,argsS,argsV)= let  
                         val (isFill,nSize,pieces)=Target.getVecTy oSize  
                         val (env, t) = doLHS()  
                         val stmt = LowOpToTreeOp.vecToTree(env,t,origrator,rator,nSize,oSize,pieces,argsS,argsV,isFill)  
                         val (envv,stmts)=(case stmt  
                             of Dst.S_Assign(_,exp)=> bind (env, lhs, exp)  
                             | stmt=> (env,[stmt])  
637                              (*end case*))                              (*end case*))
638                          val _ = testp["\n \n\t",Dst.toStringS stmt]  
639                            val env3 = iter (needtobind, env1)
640                            val env3 = addLocals(env3,vs)
641    
642    
643                            val _ = f("\n\n ****\t stmtn:",stmtn)
644                            val _ = f("\n \n*****\t Stmt0:", [stmt0])
645                            val _ = f("\n\n ****\tStmts:", stmts)
646                            val _ = g["\n\n *** \t vars:",String.concatWith","(List.map DstV.name vs)]
647                          in                          in
648                              (envv,stmts)                              (env3,stmts@(stmtn))
649                          end                          end
650    
651                  in case (rator,args')                  in case (rator,args')
652                       of (SrcOp.addVec n,_)                      =>  foundVec(rator,DstOp.addVec,n,[],args')                       of (SrcOp.addVec n,_)                           =>  foundVec(n,NONE,SOME DstOp.addVec)
653                       | (SrcOp.subVec n,_)                       =>  foundVec(rator,DstOp.subVec,n,[],args')                       | (SrcOp.subVec n,_)                            =>  foundVec(n,NONE,SOME DstOp.subVec)
654                       | (SrcOp.prodScaV n,e1::es)                =>  foundVec(rator,DstOp.prodScaV ,n, [e1], es)                       | (SrcOp.prodVec n,_)                           =>  foundVec(n,NONE,SOME DstOp.prodVec)
655                       | (SrcOp.prodVec n,_)                      =>  foundVec(rator,DstOp.prodVec,n,[],args')                       | (SrcOp.Floor n,_)                             =>  foundVec(n,NONE,SOME DstOp.Floor)
656                       | (SrcOp.sumVec n ,_)                      =>  foundVec(rator,DstOp.addVec ,n,[],args')                       | (SrcOp.Clamp(Ty.TensorTy[n]),_)               =>  foundVec(n,NONE,SOME DstOp.clampVec)
657                       | (SrcOp.Floor n ,_)                       =>  foundVec(rator,DstOp.Floor ,n,[],args')                       | (SrcOp.Normalize n,_)                         =>  foundVec(n,NONE,SOME DstOp.Normalize)
658                       | (SrcOp.ProjectLast(_,n,_,_),_)            =>  foundVec(rator,DstOp.addVec ,n,[],args')                       | (SrcOp.ProjectLast(_,n,_,_),_)                =>  foundVec(n,SOME rator,NONE)
659                       | (SrcOp.ProjectFirst(_,n,_,_),_)            =>  foundVec(rator,DstOp.addVec ,n,[],args')                       | (SrcOp.ProjectFirst(_,n,_,_),_)               =>  foundVec(n,SOME rator,NONE)
660                       | (SrcOp.Clamp (Ty.TensorTy[n]) ,_)        =>  foundVec(rator,DstOp.clampVec ,n,[],args')                       | (SrcOp.sumVec n,_)                            =>  foundVec(n,SOME rator,NONE)
661                       | (SrcOp.Lerp (Ty.TensorTy[n]) ,[a,b,c])   =>  foundVec(rator,DstOp.lerpVec ,n,[c],[a,b])                       | (SrcOp.prodScaV n,_)                          =>  foundVec(n,SOME rator,SOME DstOp.prodScaV)
662                       | (SrcOp.Normalize n,_)                    =>  foundVec(rator,DstOp.Normalize ,n,[],args')                       | (SrcOp.Lerp(Ty.TensorTy[n]),_)                =>  foundVec(n,SOME rator,SOME DstOp.lerpVec)
663                       | (SrcOp.addSca ,[a,Dst.E_Lit (Literal.Int 0)]) => assignExp (env,a)                       | (SrcOp.addSca ,[a,Dst.E_Lit (Literal.Int 0)]) => assignExp (env,a)
664                       | (SrcOp.addSca ,[Dst.E_Lit (Literal.Int 0),a]) => assignExp (env,a)                       | (SrcOp.addSca ,[Dst.E_Lit (Literal.Int 0),a]) => assignExp (env,a)
665                       | (SrcOp.subSca ,[a,Dst.E_Lit (Literal.Int 0)]) => assignExp  (env,a)                       | (SrcOp.subSca ,[a,Dst.E_Lit (Literal.Int 0)]) => assignExp  (env,a)
666                       | _                          => let                       | _                          => let
667                          val Trator = LowOpToTreeOp.expandOp rator                          val Trator = LowOpToTreeOp.expandOp rator
668    
669                          val exp = Dst.E_Op(Trator, args')                          val exp = Dst.E_Op(Trator, args')
670                          in                          in
671                              if isInlineOp rator then (bind (env, lhs, exp))                              if isInlineOp rator then (bind (env, lhs, exp))
# Line 857  Line 890 
890                      *)                      *)
891                      val x=getStateVar lhs                      val x=getStateVar lhs
892                      val rhs2=useVar env rhs                      val rhs2=useVar env rhs
893                      val _ =(String.concat["\n *********** \n FOUND SAVE \n\t  StateVar: ",Dst.stateVarToString x,                      val _ =print(String.concat["\n *********** \n FOUND SAVE \n\t  StateVar: ",Dst.stateVarToString x,
894                                      ":  Rest rhs: ",Dst.toString  rhs2,"--end "])                                      ":  Rest rhs: ",Dst.toString  rhs2,"--end "])
895                      fun size n=foldl (fn (a,b) => b*a) 1 n                      fun size n=foldl (fn (a,b) => b*a) 1 n
896                      val stm=(case  rhs2                      val stm=(case  rhs2
# Line 886  Line 919 
919                              (*end case*))                              (*end case*))
920                          |  _ => Dst.S_Save([x], rhs2)                          |  _ => Dst.S_Save([x], rhs2)
921                          (*end case*))                          (*end case*))
922                          val _ = (String.concat [" \nSrc.Save: ",LowToS.SAVEtoString(lhs,rhs),"\n New stmt --",                          val _ = print(String.concat [" \nSrc.Save: ",LowToS.SAVEtoString(lhs,rhs),"\n New stmt --",
923                                  Dst.toStringS stm,"\nend save **************\n"])                                  Dst.toStringS stm,"\nend save **************\n"])
924                          val stmts=stm::stms                          val stmts=stm::stms
925                        in                        in
# Line 930  Line 963 
963    
964      fun trInitially (env, Src.Initially{isArray, rangeInit, iters, create=(createInit, strand, args)}) =      fun trInitially (env, Src.Initially{isArray, rangeInit, iters, create=(createInit, strand, args)}) =
965            let            let
966            val (env2,iterPrefix) = peelBlockOrig(env,trCFG (env, [], fn _ => [], rangeInit))            val (env,iterPrefix) = peelBlockOrig(env,trCFG (env, [], fn _ => [], rangeInit))
967            (*  val (env2,iterPrefix) = peelBlockOrig(env,trCFG (env, [], fn _ => [], rangeInit))*)
968           (*val (iterPrefix) = mkBlockOrig(trCFG (env, [], fn _ => [], rangeInit))*)           (*val (iterPrefix) = mkBlockOrig(trCFG (env, [], fn _ => [], rangeInit))*)
969    
970            fun cvtIter ((param, lo, hi), (env, iters)) = let            fun cvtIter ((param, lo, hi), (env, iters)) = let
# Line 1044  Line 1078 
1078            val typsList = TySet.listItems(typs);            val typsList = TySet.listItems(typs);
1079            val oprList = OprSet.listItems(opr);            val oprList = OprSet.listItems(opr);
1080            val _ = testp[(Fnc.setListToString(typsList,oprList,"--FinalPostStrands--"))]            val _ = testp[(Fnc.setListToString(typsList,oprList,"--FinalPostStrands--"))]
1081    
1082            in            in
1083              Dst.Program{              Dst.Program{
1084                  props = props,                  props = props,

Legend:
Removed from v.3196  
changed lines
  Added in v.3197

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