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 2687, Wed Aug 27 13:28:50 2014 UTC revision 2688, Thu Aug 28 02:21:14 2014 UTC
# Line 44  Line 44 
44      structure OprSet=TreeFunc.OprSet      structure OprSet=TreeFunc.OprSet
45      structure VTree = TreeIL.Var      structure VTree = TreeIL.Var
46       structure VLow = LowIL.Var       structure VLow = LowIL.Var
47    
48    
49    (* create new tree IL variables *)    (* create new tree IL variables *)
50      local      local
51        val newVar = Dst.Var.new        val newVar = Dst.Var.new
# Line 136  Line 138 
138  fun bindToString binding = (case binding  fun bindToString binding = (case binding
139         of GLOB y => "GLOB " ^ Dst.Var.name y         of GLOB y => "GLOB " ^ Dst.Var.name y
140          | TREE e => "TREE"          | TREE e => "TREE"
141          | DEF(Dst.E_Var y) => "DEF " ^ Dst.Var.name y          | DEF(Dst.E_Var y) => "DEFVar " ^ Dst.Var.name y
142          | DEF e => "DEF"          | DEF e => "DEF"
143        (* end case *))        (* end case *))
144  fun dumpEnv (E{tbl, ...}) = let  fun dumpEnv (E{tbl, ...}) = let
# Line 172  Line 174 
174    (* record a local variable *)    (* record a local variable *)
175      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}
176      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}
177         fun testp t=1(*print(String.concat t)*)
178      fun global (E{tbl, ...}, x, x') = VT.insert tbl (x, GLOB x')      fun global (E{tbl, ...}, x, x') =( testp[("\n using global function "^V.name x^":\n")];
179                        VT.insert tbl (x, GLOB x'))
180    
181    (* 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! *)
182      fun insert (env as E{tbl, ...}, x, exp) = (      fun insert (env as E{tbl, ...}, x, exp) = (
# Line 188  Line 191 
191          VT.insert tbl (x, DEF( x'));          VT.insert tbl (x, DEF( x'));
192          env)          env)
193    
194    
195                      (*
196        fun peekGlobal (E{tbl, ...}, x) = (case VT.find tbl x
197                      of SOME(GLOB x') =>SOME x'
198                      | _ =>NONE
199              (* end case *))
200                      *)
201    
202    
203    
204      fun peekGlobal (E{tbl, ...}, x) = (case VT.find tbl x      fun peekGlobal (E{tbl, ...}, x) = (case VT.find tbl x
205                    of SOME(GLOB x') => (print("\n peek global"^V.name x) ;SOME x')          of SOME(GLOB x') => (testp ["\n  global: ",V.name x,":\n"] ;SOME x')
206                    | _ => (print("\n Not considered global"^V.name x);NONE)          | SOME e => (testp["\n Not  global:",V.name x,":",bindToString e,"\n"];NONE)
207            | NONE => (testp["\n Not  global:",V.name x,":NONE","\n"];NONE)
208            (* end case *))            (* end case *))
209    
210    
211      fun bindLocal (env, lhs, rhs) =let      fun bindLocal (env, lhs, rhs) =let
212          val n=V.useCount lhs          val n=V.useCount lhs
         val _=print(String.concat["\n Count:",Int.toString n,"\n"])  
213          fun AL _=let          fun AL _=let
214              val t = newLocal lhs              val t = newLocal lhs
215              in              in
216                    (rename(addLocal(env, t), lhs, t), [Dst.S_Assign([t], rhs)])                    (rename(addLocal(env, t), lhs, t), [Dst.S_Assign([t], rhs)])
217              end              end
218    
219          in          in (case (n,rhs)
220              if (n > 1)              of (0,_) => AL 1
221              then (case rhs              | (1,_)  => (insert(env, lhs, rhs), [])
222                    of Dst.E_Mux(Ty.vectorLength tys,exps,cnt)=> let              | (_,Dst.E_Mux(A, nSize,nOrig,Tys as Ty.vectorLength tys,exps))=> let
223                    val name=V.name lhs                    val name=V.name lhs
224                    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
225                    val rhs=Dst.E_Mux(Ty.vectorLength  tys,List.map (fn v=>Dst.E_Var v) xs,n)                    val rhs=Dst.E_Mux(A, nSize,nOrig,Tys,List.map (fn v=>Dst.E_Var v) xs)
226                    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)
227                    val _=print(String.concat["\n New Locals\n",String.concatWith ",\n" (List.map Dst.toStringS stmts),"\n\n"])  
228                    in                    in
229                      (renameExp(addLocals(env,xs),lhs,rhs),stmts)                      (renameExp(addLocals(env,xs),lhs,rhs),stmts)
230                    end                    end
231                  |_=> AL 1              |(_,_)=> AL 1
232                  (*end case*))                  (*end case*))
             else if (n = 1) then (insert(env, lhs, rhs), []) else AL 1  
233          end          end
234    
235      fun bindGlobal(env,lhs,rhs,x)=let      fun bindGlobal(env,lhs,rhs,x)=let
236          val _=print "\n found global?"  
237          in (env, [Dst.S_Assign([x], rhs)])          in (env, [Dst.S_Assign([x], rhs)])
238          end          end
239    
240      fun bind (env, lhs, rhs) = (case peekGlobal (env, lhs)      fun bind (env, lhs, rhs) =let
241    
242         in (case peekGlobal (env, lhs)
243          of SOME x => bindGlobal(env,lhs,rhs,x)          of SOME x => bindGlobal(env,lhs,rhs,x)
244          | NONE =>( bindLocal (env, lhs, rhs)) (**)          | NONE =>( bindLocal (env, lhs, rhs)) (**)
245          (* end case *))          (* end case *))
246          end
247    
248    (* 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 *)
249      fun bindSimple (env as E{tbl, ...}, lhs, rhs) = (      fun bindSimple (env as E{tbl, ...}, lhs, rhs) =let
250    
251            in(
252            case peekGlobal (env, lhs)            case peekGlobal (env, lhs)
253             of SOME x => (env, [Dst.S_Assign([x], rhs)])             of SOME x => (env, [Dst.S_Assign([x], rhs)])
254              | NONE => (VT.insert tbl (lhs, DEF rhs); (env, []))              | NONE => (VT.insert tbl (lhs, DEF rhs); (env, []))
255            (* end case *))            (* end case *))
256            end
257    
258    (* 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
259     * blkStms list and the resulting statement list are in reverse order.     * blkStms list and the resulting statement list are in reverse order.
# Line 294  Line 312 
312              | chkTensorTy (Ty.TensorTy[_]) = true              | chkTensorTy (Ty.TensorTy[_]) = true
313              | chkTensorTy (Ty.TensorTy[_, _]) = Target.inlineMatrixExp              | chkTensorTy (Ty.TensorTy[_, _]) = Target.inlineMatrixExp
314              | chkTensorTy _ = false              | chkTensorTy _ = false
315            val _=print(String.concat["\nIn inlineRator",SrcOp.toString rator, "\n"])  
316            in            in
317             case rator             case rator
318               of  SrcOp.LoadVoxels(_, 1) => true               of  SrcOp.LoadVoxels(_, 1) => true
# Line 335  Line 353 
353    (* translate a LowIL assignment to a list of zero or more target statements in reverse    (* translate a LowIL assignment to a list of zero or more target statements in reverse
354     * order.     * order.
355     *)     *)
356    
357    
358        fun rhsToString e=(case e
359            of Src.STATE x => "State"
360            | Src.VAR x => "var"
361            | Src.LIT lit =>"lit"
362            | Src.OP(rator, args) =>"op"
363            | Src.APPLY(f, args) =>"apply"
364            | Src.CONS(ty, args) => "cons"
365            | Src.EINAPP _=> "einapp"
366        (*end case*))
367    
368    
369    
370    
371      fun doAssign (env, (lhs, rhs)) = let      fun doAssign (env, (lhs, rhs)) = let
372    
373    
374            fun doLHS () = (case peekGlobal(env, lhs)            fun doLHS () = (case peekGlobal(env, lhs)
375                  of SOME lhs' =>(print "doassign"; (env, lhs'))              of SOME lhs' => (env, lhs')
376                    | NONE => let                    | NONE => let
377                        val t = newLocal lhs                        val t = newLocal lhs
378                        in                        in
379                          (rename (addLocal(env, t), lhs, t), t)                          (rename (addLocal(env, t), lhs, t), t)
380                        end                        end
381                  (* end case *))                  (* end case *))
382    
383          (* for expressions that are going to be compiled to a call statement *)          (* for expressions that are going to be compiled to a call statement *)
384            fun assignExp (env, exp) = let            fun assignExp (env, exp) = let
385                (* operations that return matrices may not be supported inline *)                (* operations that return matrices may not be supported inline *)
# Line 404  Line 440 
440    
441    
442                      val cnt=useCount lhs                      val cnt=useCount lhs
                     val _=print(String.concat["\n Used var ",Int.toString(cnt)," times"])  
   
443                      val (expOpt,storeVecStatement,storeVecExp) = LowOpToTreeOp.vecToTree(t,cnt,rator,newSize,n,Pieces,argsS,argsV,isFill)                      val (expOpt,storeVecStatement,storeVecExp) = LowOpToTreeOp.vecToTree(t,cnt,rator,newSize,n,Pieces,argsS,argsV,isFill)
444    
445                      val isBind=true                      val isBind=true
# Line 414  Line 448 
448    
449                      in (case (expOpt,storeVecStatement,storeVecExp,isStatement)                      in (case (expOpt,storeVecStatement,storeVecExp,isStatement)
450                          of (SOME x,_,_,_)=>  let                          of (SOME x,_,_,_)=>  let
451                               val _=print(String.concat["\n **\n~~ RESULT ",Dst.toString x])                               val _=testp ["\n **\n~~ RESULT ",Dst.toString x]
452                             in                             in
453                                  (env,[Dst.S_Assign([t],x)]) (*not using mkvec*)                                  (env,[Dst.S_Assign([t],x)]) (*not using mkvec*)
454                              end                              end
455                          | (NONE,_,SOME x,false)=>let                          | (NONE,_,SOME x,false)=>let
456                               val _=print(String.concat["\n **\nExp- RESULT ",Dst.toString x])                               val _=testp ["\n **\nExp- RESULT ",Dst.toString x]
457                              in                              in
458                                  if isBind then  bind (env, lhs, x)                                  if isBind then  bind (env, lhs, x)
459                                  else assignExp (env, x)                                  else assignExp (env, x)
460                              end                              end
461                          | (NONE,SOME x,_,true)=> let                          | (NONE,SOME x,_,true)=> let
462                              val _ =print(String.concat["\n **\nStmt- RESULT ",Dst.toStringS x])                              val _ =testp ["\n **\nStmt- RESULT ",Dst.toStringS x]
463                              in                              in
464                                  (env,[x])                                  (env,[x])
465                              end                              end
# Line 448  Line 482 
482    
483                     end                     end
484    
485                  val _= print (String.concat ["\n **************************** \n Analyzing ", SrcOp.toString rator])                  val _= testp ["\n **************************** \n Analyzing ", SrcOp.toString rator]
486                                          (* removed sumVec*)                                          (* removed sumVec*)
487    
488    
# Line 473  Line 507 
507                          val Trator = LowOpToTreeOp.expandOp rator                          val Trator = LowOpToTreeOp.expandOp rator
508                          val exp = Dst.E_Op(Trator, args')                          val exp = Dst.E_Op(Trator, args')
509                          in                          in
510                              if isInlineOp rator then ( print "\n in bind";bind (env, lhs, exp))                              if isInlineOp rator then (bind (env, lhs, exp))
511                              else (print "assignExp";assignExp (env, exp))                              else (assignExp (env, exp))
512                          end                          end
513                      (*end case*))                      (*end case*))
514                   end                   end
# Line 515  Line 549 
549                  (env,Dst.Block{locals=locals ,body=body})                  (env,Dst.Block{locals=locals ,body=body})
550               end               end
551    
552    
553    
554    
555      fun trCFG (env, prefix, finish, cfg) = let      fun trCFG (env, prefix, finish, cfg) = let
556    
557    
558            fun getFNC(env,stms)=let
559    
560                val t1=peelEnv(env)
561                val (ty2,opr2)= List.foldr (fn(e1,e2) => gT.getTypesFiltered (e2,e1)) t1 stms
562                in
563                    setEnv(env, ty2,opr2)
564                end
565    
566    
567            fun join (env, [], _, Src.JOIN _) = raise Fail "JOIN with no open if"            fun join (env, [], _, Src.JOIN _) = raise Fail "JOIN with no open if"
568              | join (env, [], stms, _) = endScope (env, prefix @ List.rev stms)              | join (env, [], stms, _) = endScope (env, prefix @ List.rev stms)
569              | join (env, THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let              | join (env, THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let
# Line 551  Line 597 
597                      | (_, _) => raise Fail "no path to exit unimplemented" (* FIXME *)                      | (_, _) => raise Fail "no path to exit unimplemented" (* FIXME *)
598                    (* end case *)                    (* end case *)
599                  end                  end
600            and doNode (env, ifStk : open_if list, stms, nd) = (                  and doNode (env, ifStk : open_if list, stms, nd) =
601                  case Nd.kind nd                 (* testp ["******************* \n doNode\n ",toS.printNode (Nd.kind nd),"\n"]*)
602                    (case Nd.kind nd
603                   of Src.NULL => raise Fail "unexpected NULL"                   of Src.NULL => raise Fail "unexpected NULL"
604                    | Src.ENTRY{succ} => doNode (env, ifStk, stms, !succ)                    | Src.ENTRY{succ} => doNode (env, ifStk, stms, !succ)
605                    | k as Src.JOIN{phis, succ, ...} => join (env, ifStk, stms, k)                    | k as Src.JOIN{phis, succ, ...} => join (env, ifStk, stms, k)
# Line 567  Line 614 
614                    | Src.ASSIGN{stm, succ, ...} => let                    | Src.ASSIGN{stm, succ, ...} => let
615                        val (env, stms') = doAssign (env, stm)                        val (env, stms') = doAssign (env, stm)
616    
                         (*Printing out types*)  
                         val (typesAll,oprAll)= peelEnv(env)  
                         val t1=(typesAll,oprAll)  
                         val (ty2,opr2)= List.foldr (fn(e1,e2) => gT.getTypesFiltered (e2,e1)) t1 stms'  
                          val env'=setEnv(env, ty2,opr2)  
617                        in                        in
618                              doNode (env', ifStk, stms' @ stms, !succ)                              doNode (getFNC(env, stms'), ifStk, stms' @ stms, !succ)
619                        end                        end
620                    | Src.MASSIGN{stm=(ys, rator, xs), succ, ...} => let                    | Src.MASSIGN{stm=(ys, rator, xs), succ, ...} => let
621                        val _=print "In massign"  
622                        fun doit () = let                        fun doit () = let
623                              fun doLHSVar (y, (env, ys)) = (case peekGlobal(env, y)                              fun doLHSVar (y, (env, ys)) = (case peekGlobal(env, y)
624                                  of SOME y' => (print "In dolhsvar,some";(env, y'::ys))                                  of SOME y' => ((env, y'::ys))
625                                  | NONE => let                                  | NONE => let
626                                          val t = newLocal y                                          val t = newLocal y
627                                          val _=print "In dolhs none"  
628                                          in                                          in
629                                            (rename (addLocal(env, t), y, t), t::ys)                                            (rename (addLocal(env, t), y, t), t::ys)
630                                          end                                          end
# Line 604  Line 646 
646                        end                        end
647                    | Src.NEW{strand, args, succ, ...} => raise Fail "NEW unimplemented"                    | Src.NEW{strand, args, succ, ...} => raise Fail "NEW unimplemented"
648                    | Src.SAVE{lhs, rhs, succ, ...} => let                    | Src.SAVE{lhs, rhs, succ, ...} => let
649                        val stm = Dst.S_Save([getStateVar lhs], useVar env rhs)                          (*How to get var form stateVar?*)
650                          (*rhs is doing to be an expression which effectively has to be a mux*)                         (*Dst.S_Save([getStateVar lhs], useVar env rhs)*)
651    
652                          val stm=(case  (getStateVar lhs,useVar env rhs)
653                             of (x,Dst.E_Mux(A,nSize, oSize,pieces,args))
654                                    =>Dst.S_StoreVec( Dst.E_State x,A,nSize, oSize,pieces,args)
655                            | (x,rhs')=>Dst.S_Save([x], rhs')
656                            (*end case*))
657    
658    
659                         val _=testp (["Src.Save\n",toS.SAVEtoString(lhs,rhs),"\n",Dst.toStringS stm,"\n rest"]@List.map Dst.toStringS stms)
660                        val stmts=stm::stms
661                        in                        in
662                          doNode (env, ifStk, stm::stms, !succ)                          doNode (getFNC(env, stmts), ifStk, stmts, !succ)
663                        end                        end
664                    | k as Src.EXIT{kind, live, ...} => (case kind                    | k as Src.EXIT{kind, live, ...} => (case kind
665                         of ExitKind.FRAGMENT =>                         of ExitKind.FRAGMENT =>
# Line 697  Line 748 
748      fun splitGlobalInit globalInit = let      fun splitGlobalInit globalInit = let
749  (* FIXME: can split as soon as we see a non-Input statement! *)  (* FIXME: can split as soon as we see a non-Input statement! *)
750    
751              val _ =    print "splitGlobalInit"  
752            fun walk (nd, lastInput, live) = (case Nd.kind nd            fun walk (nd, lastInput, live) = (case Nd.kind nd
753                   of Src.ENTRY{succ} => walk (!succ, lastInput, live)                   of Src.ENTRY{succ} => walk (!succ, lastInput, live)
754                    | Src.COM{succ, ...} => walk (!succ, lastInput, live)                    | Src.COM{succ, ...} => walk (!succ, lastInput, live)
# Line 756  Line 807 
807            val (typs,opr)= peelEnv(env)            val (typs,opr)= peelEnv(env)
808            val typsList=TySet.listItems(typs);            val typsList=TySet.listItems(typs);
809            val oprList=OprSet.listItems(opr);            val oprList=OprSet.listItems(opr);
810            val _=print(gT.prnTyFinal(typsList,oprList,"--FinalPostStrands--"))            val _=testp[(gT.prnTyFinal(typsList,oprList,"--FinalPostStrands--"))]
811    
812            in  Dst.Program{            in  Dst.Program{
813                    props = props,                    props = props,

Legend:
Removed from v.2687  
changed lines
  Added in v.2688

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