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 2631, Fri May 23 18:13:12 2014 UTC revision 2665, Tue Jun 3 02:37:46 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 ILF=TreeFunc
9        structure TySet=ILF.TySet
10        structure OprSet=ILF.OprSet
11    
12    
     (* utility function for synthesizing eigenvector/eigenvalue signature *)  
     fun eigenSig dim = let  
         val tplTy = Ty.TupleTy[  
         Ty.SeqTy(Ty.realTy, dim),  
         Ty.SeqTy(Ty.vecTy dim, dim)]  
         in  
             tplTy  
         end  
   
   
     val intTy=Ty.intTy  
     val realTy=Ty.TensorTy[]  
     val boolTy=Ty.BoolTy  
13      fun vecTy n=Ty.TensorTy[n]      fun vecTy n=Ty.TensorTy[n]
14        val testing=0
15    
16    
17    (* GetTypes TreeIL operator. *)    (* GetTypes TreeIL operator. *)
18        val default=([],[])
19    
20        (*rator-> (types, cfns )*)
21      fun TypeofOp rator = (case rator      fun TypeofOp rator = (case rator
22             of  Op.IAdd  => intTy          of  Op.IndexTensor(a,RTy,b,c)=>([RTy],[])
23              | Op.ISub => intTy          (* Op.IndexTensor(a,RTy,b,c)=> ([RTy], [ILF.OP(Op.IndexTensor(a,RTy,b,c)))]*)
24              | Op.IMul  => intTy          | Op.addVec d               => ([vecTy d],[ILF.OP(Op.addVec d)])
25              | Op.IDiv => intTy          | Op.subVec d               => ([vecTy d],[ILF.OP(Op.subVec d)])
26              | Op.INeg  =>intTy          | Op.prodVec d              => ([vecTy d],[ILF.OP(Op.prodVec d)])
27              | Op.IndexTensor(_,resultTy,_,argTy)=> resultTy          | Op.prodScaV d             => ([vecTy d],[ILF.CONS(Ty.TensorTy[d]),ILF.OP(Op.prodScaV d)])
28              | Op.addSca => realTy          | Op.sumVec d               => ([Ty.unionTy d],   [ILF.OP(Op.sumVec d)])
29              | Op.subSca => realTy          | _ => default
             | 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;  
   
     fun typeOfExp exp=(case exp  
        of (IL.E_State(state_var))=>[]  
       | IL.E_Var(var)=> []  
       | IL.E_Lit _ =>[]  
       | IL.E_Op(Op, exp) => [TypeofOp  Op]@ (flat(List.map typeOfExp exp))  
       | IL.E_Apply (_, exp)=> flat(List.map typeOfExp exp)  
       | 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*))  
   
33    
34      (*Filter Types, Just one of each *)      (*fun peel(IL.E_Lit( offset))=offset*)
     fun m([],rest)=rest  
       | m (e1::es, rest)=(case (List.find(fn x=> Ty.same(x,e1)) rest)  
         of NONE=> m (es, rest@[e1])  
         | _ => m (es, rest)  
         (*end case*))  
35    
36        fun mkFnC(IL.E_LoadVec(fTy, oTy,_, offset))=[ILF.LD(fTy,oTy)]
37          | mkFnC(IL.E_mkVec(_,oTy,pieces,_))= [ILF.MKVEC(oTy,pieces)]
38          | mkFnC(IL.E_Cons (ty , exps))= [ILF.CONS ty]
39          | mkFnC(IL.E_LoadVecAligned (fTy, oTy,_, offset))=[ILF.LDAligned (fTy,oTy)]
40          | mkFnC(IL.E_mkVecAligned (_,oTy,pieces,_))= [ILF.MKVECAligned (oTy,pieces)]
41    
42    
43        (*Get types of Exp*)
44        fun typeOfExp(t,exp)=let
45            val (ty1,opr1)=t
46            fun add(([],[]),rest)= List.foldr (fn(e1,e2) => typeOfExp(e2,e1)) t rest
47            | add((typ,cfn),rest)= let
48    
49                val opr2=List.foldr (fn(e1,e2) =>OprSet.add(e2,e1)) opr1 cfn
50                val ty2=List.foldr (fn(e1,e2) =>TySet.add(e2,e1)) ty1 typ
51                val t2=(ty2,opr2)
52    
53      fun getTypesFilteredPnt(IL.S_Assign (_,exp))= let              in
54                    List.foldr (fn(e1,e2) => typeOfExp(e2,e1)) t2 rest
55                end
56            in  (case exp
57                of (IL.E_State(state_var))=>t
58                | IL.E_Var(var)             => t
59                | IL.E_Lit _                => t
60                | IL.E_Apply (_, exps)      => add(default,exps)
61                | IL.E_Cons (ty , exps)     => add(([ty],mkFnC exp),exps)
62                | IL.E_LoadVec(ty,_,exps,_) => add(([vecTy ty],mkFnC exp),[exps])
63                | IL.E_mkVec(_,ty,_,exps)   => add(([vecTy ty,Ty.unionTy ty],mkFnC exp), exps)
64    
65          val types=typeOfExp exp              | IL.E_Op(Op, exps)         => add(TypeofOp Op, exps)
66          val types2=m (types,[])              (*end case*))
         val str2= List.map Ty.toString types2  
         val pnstr2= print(String.concat["\n ---",TS.toStringEx exp ,"\n \t Types: ",String.concatWith "," str2])  
         in types2  
67          end          end
       | getTypesFilteredPnt _= []  
68    
69    
70      fun getTypesFiltered(IL.S_Assign (_,exp))= let      (*print Types*)
71        fun prnTy((t1,t2),prefix)=let
72    
73          val types=typeOfExp exp          val typs=TySet.listItems(t1);
74          in m (types,[])          val ops=OprSet.listItems(t2);
75          end          val str1= List.map Ty.toString typs
76      | getTypesFiltered _= []          val str2=List.map ILF.toString ops
77            val pnstr= String.concat["\n",prefix,"\n \t Types: ",String.concatWith "," str1,
78                "\n \t cFn: ",String.concatWith "\n\t" str2]
79    
80            in pnstr end
81    
82        fun prnTyFinal(typs,ops,prefix)=let
83            val str1= List.map Ty.toString typs
84            val str2=List.map ILF.toString ops
85            val pnstr= String.concat["\n",prefix,"\n \t Types: ",String.concatWith "," str1,
86                "\n \t cFn: ",String.concatWith "\n\t" str2]
87            in pnstr end
88    
89    
90    
91        fun getTypesFiltered(t,IL.S_Assign (_,exp))= let
92            val t2=typeOfExp(t,exp)
93            val _=(case testing
94                of 1=> (print(String.concat["\n ---",IL.toString exp,prnTy(t2,"Current")]);1)
95                | _=>1
96                (*end case*))
97    
98  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  
99      end      end
100          | getTypesFiltered(t, _)= t
   
101    
102    
103    

Legend:
Removed from v.2631  
changed lines
  Added in v.2665

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