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/getTypes.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/tree-il/getTypes.sml

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

revision 2632, Fri May 23 18:57:58 2014 UTC revision 2637, Wed May 28 05:20:45 2014 UTC
# Line 5  Line 5 
5      structure Op = TreeOps      structure Op = TreeOps
6      structure Ty = TreeILTypes      structure Ty = TreeILTypes
7      structure IL=TreeIL      structure IL=TreeIL
8      structure TS=tString      structure setTyfn=TreeFunc
9    
10    
11      (* utility function for synthesizing eigenvector/eigenvalue signature *)      structure  TySet=setTyfn.TySet
12      fun eigenSig dim = let      structure  OprSet=setTyfn.OprSet
         val tplTy = Ty.TupleTy[  
         Ty.SeqTy(Ty.realTy, dim),  
         Ty.SeqTy(Ty.vecTy dim, dim)]  
         in  
             tplTy  
         end  
13    
   
     val intTy=Ty.intTy  
14      val realTy=Ty.TensorTy[]      val realTy=Ty.TensorTy[]
     val boolTy=Ty.BoolTy  
15      fun vecTy n=Ty.TensorTy[n]      fun vecTy n=Ty.TensorTy[n]
16        val testing=0
17    
18    
19    (* GetTypes TreeIL operator. *)    (* GetTypes TreeIL operator. *)
20        val default=(NONE,NONE)
21        fun m(e1,e2)=(SOME e1, SOME e2)
22      fun TypeofOp rator = (case rator      fun TypeofOp rator = (case rator
23             of  Op.IAdd  => intTy          of  Op.IndexTensor(a,RTy,b,c)=> (SOME RTy,NONE)
24              | Op.ISub => intTy          (* Op.IndexTensor(a,RTy,b,c)=> m(RTy,setTyfn.OP(Op.IndexTensor(a,RTy,b,c)))*)
25              | Op.IMul  => intTy          | Op.addVec d               => m(vecTy d,setTyfn.OP(Op.addVec d))
26              | Op.IDiv => intTy          | Op.subVec d               => m(vecTy d,setTyfn.OP(Op.subVec d))
27              | Op.INeg  =>intTy          | Op.prodVec d              => m(vecTy d,setTyfn.OP(Op.prodVec d))
28              | Op.IndexTensor(_,resultTy,_,argTy)=> resultTy          | Op.prodScaV d             => m(vecTy d,setTyfn.OP(Op.prodScaV d))
29              | Op.addSca => realTy          | _ => default
             | Op.subSca => realTy  
             | Op.prodSca => realTy  
             | Op.divSca => realTy  
             | Op.addVec d=> vecTy d  
             | Op.subVec d => vecTy d  
             | Op.prodVec d => vecTy d  
             | Op.prodScaV d =>vecTy d  
             | Op.sumVec _=> realTy  
             | Op.Abs ty => ty  
             | Op.LT _ => boolTy  
             | Op.LTE _ => boolTy  
             | Op.EQ _ => boolTy  
             | Op.NEQ _ => boolTy  
             | Op.GT _ => boolTy  
             | Op.GTE _ => boolTy  
             | Op.Not => boolTy  
             | Op.Max => realTy  
             | Op.Min => realTy  
             | Op.Clamp ty => ty  
             | Op.Lerp ty => ty  
             | Op.Norm(ty as Ty.TensorTy _) =>realTy  
             | Op.Normalize d => vecTy d  
             | Op.EigenVecs2x2 => eigenSig 2  
             | Op.EigenVecs3x3 => eigenSig 3  
             | Op.EigenVals2x2 => Ty.SeqTy(Ty.realTy, 2)  
             | Op.EigenVals3x3 => Ty.SeqTy(Ty.realTy, 3)  
             | Op.Zero ty => ty  
             | Op.Select(ty as Ty.TupleTy tys, i) => List.nth(tys, i-1)  
             | Op.Index(ty as Ty.TensorTy[d], _) => realTy  
             | Op.Index(ty as Ty.SeqTy(elemTy, _), _) => elemTy  
             | Op.Subscript(ty as Ty.TensorTy dd) => realTy  
             | Op.Subscript(ty as Ty.SeqTy(elemTy, d)) => elemTy  
             | Op.Ceiling d => vecTy d  
             | Op.Floor d => vecTy d  
             | Op.Round d => vecTy d  
             | Op.Trunc d => vecTy d  
             | Op.IntToReal => realTy  
             | Op.RealToInt 1 => intTy  
             | Op.RealToInt d => Ty.SeqTy(Ty.IntTy, d)  
             | Op.Transform info => let  
                 val dim = ImageInfo.dim info  
                 in  Ty.TensorTy[dim,dim]  
                 end  
             | Op.Translate info  => let  
                 val dim = ImageInfo.dim info  
                 in Ty.TensorTy[dim,dim]  
                 end  
             | Op.Kernel _ => Ty.KernelTy  
             | Op.ImageAddress info => Ty.AddrTy info  
             | Op.LoadVoxels(_, n) =>  vecTy n  
             | Op.LoadImage info =>  Ty.ImageTy info  
             | Op.Inside _ => boolTy  
             | Op.Print _ => Ty.TupleTy[]  
             | Op.imgAddr _=> intTy  
             | Op.imgLoad (_,_,j) => vecTy j  
             | _ => raise Fail("getTypes: In tree-IL Does not have: invalid operator " ^ Op.toString rator)  
30            (* end case *))            (* end case *))
31    
32    
     fun flat [] = []  
       | flat (l::ls) = l @ flat ls;  
33    
34      fun typeOfExp exp=(case exp      fun peel(IL.E_Lit( offset))=offset
35         of (IL.E_State(state_var))=>[]      fun mkFnC(IL.E_LoadVec(fTy, oTy,_, offset))=setTyfn.LD(fTy,oTy,peel offset)
36        | IL.E_Var(var)=> []        | mkFnC(IL.E_mkVec(_,oTy,_,_))= setTyfn.MKVEC oTy
37        | IL.E_Lit _ =>[]        | mkFnC(IL.E_Cons (ty , exps))= setTyfn.CONS ty
38        | IL.E_Op(Op, exp) => [TypeofOp  Op]@ (flat(List.map typeOfExp exp))        | mkFnC(IL.E_FillVec(fTy, oTy,_, offset))= setTyfn.FVEC(fTy,oTy)
39        | IL.E_Apply (_, exp)=> flat(List.map typeOfExp exp)        | mkFnC(IL.E_SliceVec(fTy, oTy,_, offset))=setTyfn.SVEC(fTy)
       | IL.E_Cons (ty , exp)=> [ty]@(flat(List.map typeOfExp exp))  
       | IL.E_LoadVec(fullTy, _, exp, _)=>[vecTy fullTy]@(typeOfExp exp)  
       | IL.E_mkVec(_,ty,_,exp)=>  [vecTy ty]@(flat(List.map typeOfExp exp))  
         (*end case*))  
40    
41    
42      (*Filter Types, Just one of each *)      (*Get types of Exp*)
43      fun m([],rest)=rest      fun typeOfExp(t,exp)=let
44        | m (e1::es, rest)=(case (List.find(fn x=> Ty.same(x,e1)) rest)  
45          of NONE=> m (es, rest@[e1])          fun add((NONE,NONE),rest)=List.foldr (fn(e1,e2) => typeOfExp(e2,e1)) t rest
46          | _ => m (es, rest)            | add((SOME typ,NONE),rest)= let
47          (*end case*))              val (ty1,opr1)=t
48                val t2=(TySet.add(ty1,typ),opr1)
49                in
50                    List.foldr (fn(e1,e2) => typeOfExp(e2,e1)) t2 rest
51                end
52            | add((SOME typ,SOME cfn),rest)= let
53                val (ty1,opr1)=t
54                val t2=(TySet.add(ty1,typ),OprSet.add(opr1, cfn))
55    
56                in
57                    List.foldr (fn(e1,e2) => typeOfExp(e2,e1)) t2 rest
58                end
59            in  (case exp
60                of (IL.E_State(state_var))=>t
61                | IL.E_Var(var)             => t
62                | IL.E_Lit _                => t
63                | IL.E_Apply (_, exps)      => add(default,exps)
64                | IL.E_Cons (ty , exps)     => add(m(ty,mkFnC exp),exps)
65                | IL.E_LoadVec(ty,_,exps,_)  => add(m(vecTy ty,mkFnC exp),[exps])
66                | IL.E_mkVec(_,ty,_,exps)   => add(m(vecTy ty,mkFnC exp), exps)
67                | IL.E_Op(Op, exps)         => add(TypeofOp Op, exps)
68                | IL.E_FillVec(ty,_,exps,_)  => add(m(vecTy ty,mkFnC exp),[exps])
69                | IL.E_SliceVec(ty,_,exps,_) => add(m(vecTy ty,mkFnC exp),[exps])
70    
     fun getTypesFilteredPnt(IL.S_Assign (_,exp))= let  
71    
72          val types=typeOfExp exp              (*end case*))
         val types2=m (types,[])  
         val str2= List.map Ty.toString types2  
         val pnstr2= print(String.concat["\n ---",TS.toStringEx exp ,"\n \t Types: ",String.concatWith "," str2])  
         in types2  
73          end          end
       | getTypesFilteredPnt _= []  
74    
75    
76      fun getTypesFiltered(IL.S_Assign (_,exp))= let      (*print Types*)
77        fun prnTy((t1,t2),prefix)=let
78    
79          val types=typeOfExp exp          val typs=TySet.listItems(t1);
80          in m (types,[])          val ops=OprSet.listItems(t2);
81          end          val str1= List.map Ty.toString typs
82      | getTypesFiltered _= []          val str2=List.map setTyfn.toString ops
83            val pnstr= String.concat["\n",prefix,"\n \t Types: ",String.concatWith "," str1,
84                "\n \t cFn: ",String.concatWith "\n\t" str2]
85    
86            in pnstr end
87    
88        fun prnTyFinal(typs,ops,prefix)=let
89            val str1= List.map Ty.toString typs
90            val str2=List.map setTyfn.toString ops
91            val pnstr= String.concat["\n",prefix,"\n \t Types: ",String.concatWith "," str1,
92                "\n \t cFn: ",String.concatWith "\n\t" str2]
93            in pnstr end
94    
95    
96    
97        fun getTypesFiltered(t,IL.S_Assign (_,exp))= let
98            val t2=typeOfExp(t,exp)
99            val _=(case testing
100                of 1=> (print(String.concat["\n ---",IL.toString exp,prnTy(t2,"Current")]);1)
101                | _=>1
102                (*end case*))
103    
104  fun gotFiltered []= (print(String.concat["\n \t No Types"]);1)          in t2
    |gotFiltered types= let  
     val types2=m (types,[])  
     val str2= List.map Ty.toString types2  
     val pnstr2= print(String.concat["\n \t Final Types: ",String.concatWith "," str2,"\n\n "])  
     in 1  
105      end      end
106          | getTypesFiltered(t, _)= t
   
107    
108    
109    

Legend:
Removed from v.2632  
changed lines
  Added in v.2637

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