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 2844, Tue Dec 9 18:05:29 2014 UTC revision 2845, Fri Dec 12 06:46:23 2014 UTC
# Line 47  Line 47 
47      structure Fnc=TreeFunc      structure Fnc=TreeFunc
48      structure TySet= Fnc.TySet      structure TySet= Fnc.TySet
49      structure OprSet= Fnc.OprSet      structure OprSet= Fnc.OprSet
50        structure LowToS=LowToString
51    
52    (* create new tree IL variables *)    (* create new tree IL variables *)
53      local      local
# Line 388  Line 389 
389                        end                        end
390                  (* end case *))                  (* end case *))
391    
392          val _=toS.ASSIGNtoString(lhs,rhs)          val _=LowToS.ASSIGNtoString(lhs,rhs)
393    
394          (* opToString:LowIL.Ops* LowIL.Var list-> int          (* opToString:LowIL.Ops* LowIL.Var list-> int
395          *Just used to print information about the op          *Just used to print information about the op
# Line 431  Line 432 
432                  | Src.VAR x     => bindSimple (env, lhs, useVar env x)                  | Src.VAR x     => bindSimple (env, lhs, useVar env x)
433                  | Src.LIT lit   => bindSimple (env, lhs, Dst.E_Lit lit)                  | Src.LIT lit   => bindSimple (env, lhs, Dst.E_Lit lit)
434    
435                  (*| Src.OP( SrcOp.Prepend ty, [item, seq]) => let                  (*need to put input operations back in!  copied from vis branch.*)
436                    (*
437                    | IL.OP(Op.Input(InP.INP{ty=Ty.DynSeqTy _, name, desc, init}), []) => let
438                        fun mkStm gv = (case init
439                            of NONE => T.S_InputNrrd(gv, name, desc, NONE)
440                            | SOME(InP.DynSeq nrrd) => T.S_InputNrrd(gv, name, desc, SOME nrrd)
441                            | _ => raise Fail "bogus initialization for dynamic sequence"
442                            (* end case *))
443                        in
444                            (recordInput (env, lhs, mkStm), [])
445                        end
446                    | IL.OP(Op.Input(InP.INP{ty=Ty.ImageTy _, name, desc, init}), []) => let
447                        fun mkStm gv = (case init
448                            of SOME(InP.Proxy(nrrd, _)) => T.S_InputNrrd(gv, name, desc, SOME nrrd)
449                            | SOME(InP.Image _) => T.S_InputNrrd(gv, name, desc, NONE)
450                            | _ => raise Fail "bogus initialization for image"
451                            (* end case *))
452                        in
453                            (recordInput (env, lhs, mkStm), [])
454                        end
455                    | IL.OP(Op.Input(InP.INP{ty, name, desc, init=NONE}), []) => let
456                        fun mkStm gv = T.S_Input(gv, name, desc, NONE)
457                        in
458                            (recordInput (env, lhs, mkStm), [])
459                        end
460                    | IL.OP(Op.InputWithDefault(InP.INP{ty, name, desc, init=NONE}), [dflt]) => let
461                            val dflt = useVar env dflt
462                            fun mkStm gv = T.S_Input(gv, name, desc, SOME dflt)
463                        in
464                            (recordInput (env, lhs, mkStm), [])
465                        end
466                    *)(*
467                        | Src.OP( SrcOp.Prepend ty, [item, seq]) => let
468                    val (env, t) = doLHS()                    val (env, t) = doLHS()
469                    val (env, item', stms) = bindVar (env, item)                    val (env, item', stms) = bindVar (env, item)
470                    val exp = Dst.E_Op( DstOp.Prepend ty, [item', useVar env seq])                    val exp = Dst.E_Op( DstOp.Prepend ty, [item', useVar env seq])
# Line 547  Line 580 
580    
581                  | Src.OP(rator,args) =>let                  | Src.OP(rator,args) =>let
582                      val args'=List.map (useVar env) args                      val args'=List.map (useVar env) args
583                       val _ =testp[ "\n ***** New Op \n \t",SrcOp.toString rator,                       val _ =testp[ "\n ***** New Op \n \t\t",SrcV.name lhs,"-",SrcOp.toString rator,Int.toString(length(args))
584                              " Args(",String.concatWith"," (List.map (fn e=> Dst.toString e) args'),")"]                              , " Args(\n\t",String.concatWith"\n\t\t," (List.map (fn e=> Dst.toString e) args'),")"]
585                      (*foundVec:SrcOp.op* DstOP.ops*int*DstVar list *DstVar list                      (*foundVec:SrcOp.op* DstOP.ops*int*DstVar list *DstVar list
586                       * Found a vector operation.                       * Found a vector operation.
587                      * Rewrites to correctly-sized vector operations                      * Rewrites to correctly-sized vector operations
# Line 595  Line 628 
628                      * If lhs is a local var then we assume lhs will be represented with vectors                      * If lhs is a local var then we assume lhs will be represented with vectors
629                      *      and  we use Mux and E_ConsVec on pieces, much like a vector op                      *      and  we use Mux and E_ConsVec on pieces, much like a vector op
630                      * Otherwise, assume it's an array and use S_Cons                      * Otherwise, assume it's an array and use S_Cons
631                      * testp["\n ****** here **\n  ",toS.rhsToString  (Src.CONS(ty , args)),                      * testp["\n ****** here **\n  ",LowToS.rhsToString  (Src.CONS(ty , args)),
632                          "\n\t* lhs " ,SrcV.name lhs,"type",Ty.toString(SrcV.ty lhs),                          "\n\t* lhs " ,SrcV.name lhs,"type",Ty.toString(SrcV.ty lhs),
633                          "\nt",DstV.name t,"-kind:",Dst.kindToString (DstV.kind t),"\n"]                          "\nt",DstV.name t,"-kind:",Dst.kindToString (DstV.kind t),"\n"]
634                      *)                      *)
# Line 612  Line 645 
645                          | _ =>(env2,[Dst.S_Cons(t,oSize,args')])                          | _ =>(env2,[Dst.S_Cons(t,oSize,args')])
646                          (*end case*))                          (*end case*))
647                      end                      end
648                    (*| Src.CONS(ty as Ty.TensorTy [_,2], args)=>let
649                        val args'=List.map (useVar env) args
650                        val _=case args'
651    
652                    val _=(case )
653                        val (env2, t) = doLHS()
654                        in
655                            (env2,[Dst.S_Cons(t,4,args')])
656                        end*)
657                  | Src.CONS(ty as Ty.TensorTy [_,j], args) =>let                  | Src.CONS(ty as Ty.TensorTy [_,j], args) =>let
658                      (* Cons is a matrix  with vector arguments                      (* Cons is a matrix  with vector arguments
659                      * Each Vector Arg could be a global, local or state variable                      * Each Vector Arg could be a global, local or state variable
# Line 654  Line 695 
695                      * Hooray! We can assume everything is an array and S_Copy everything                      * Hooray! We can assume everything is an array and S_Copy everything
696                      *)                      *)
697                      val args' =  List.map (useVar env) args                      val args' =  List.map (useVar env) args
698                      val _ =testp["******************************\n CONS_Matrix  \n ", Dst.toStrings args']                      val _ =print(String.concat["******************************\n CONS_Matrix  \n ",
699                                "Number of args",Int.toString (length args),"---\n",Dst.toStrings args'])
700                      val (env2, t) = doLHS()                      val (env2, t) = doLHS()
701                      val shift=j*i (*New row index shift *)                      val shift=j*i (*New row index shift *)
702                      fun f ([], _ ) = []                      fun f ([], _ ) = []
703                          | f (e1::es,count)= [Dst.S_Copy(Dst.E_Var t, e1, count,shift)]@ f(es,count+shift)                          | f (e1::es,count)= [Dst.S_Copy(Dst.E_Var t, e1, count,shift)]@ f(es,count+shift)
704                      val stmts=f (args',0)                      val stmts=f (args',0)
705                      val _ =testp["\n returning statements \n"^Dst.toStringSs stmts,"\n  end ******************************\n"]                      val _ =print(String.concat["\n returning statements \n"^Dst.toStringSs stmts,"\n  end ******************************\n"])
706                      in                      in
707                          (env2, List.rev stmts)                          (env2, List.rev stmts)
708                      end                      end
# Line 743  Line 785 
785                    (* end case *)                    (* end case *)
786                  end                  end
787                  and doNode (env, ifStk : open_if list, stms, nd) =                  and doNode (env, ifStk : open_if list, stms, nd) =
788                 (* testp ["******************* \n doNode\n ",toS.printNode (Nd.kind nd),"\n"]*)                 (* testp ["******************* \n doNode\n ",LowToS.printNode (Nd.kind nd),"\n"]*)
789                  (case Nd.kind nd                  (case Nd.kind nd
790                   of Src.NULL => raise Fail "unexpected NULL"                   of Src.NULL => raise Fail "unexpected NULL"
791                    | Src.ENTRY{succ} => doNode (env, ifStk, stms, !succ)                    | Src.ENTRY{succ} => doNode (env, ifStk, stms, !succ)
# Line 821  Line 863 
863                              (*end case*))                              (*end case*))
864                          |  _ => Dst.S_Save([x], rhs2)                          |  _ => Dst.S_Save([x], rhs2)
865                          (*end case*))                          (*end case*))
866                          val _ = testp [" \nSrc.Save: ",toS.SAVEtoString(lhs,rhs),"\n New stmt --",                          val _ = testp [" \nSrc.Save: ",LowToS.SAVEtoString(lhs,rhs),"\n New stmt --",
867                                  Dst.toStringS stm,"\nend save **************\n"]                                  Dst.toStringS stm,"\nend save **************\n"]
868                          val stmts=stm::stms                          val stmts=stm::stms
869                        in                        in

Legend:
Removed from v.2844  
changed lines
  Added in v.2845

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