Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/codegen/collect-info.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/codegen/collect-info.sml

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

revision 3919, Mon May 30 06:53:48 2016 UTC revision 3931, Sun Jun 5 14:13:21 2016 UTC
# Line 17  Line 17 
17          VLerp          VLerp
18          VScale          VScale
19          VSum          VSum
         EigenVecs2x2  
         EigenVecs3x3  
         EigenVals2x2  
         EigenVals3x3  
20   *)   *)
21  structure CollectInfo : sig  structure CollectInfo : sig
22    
23      type t      type t
24    
25        datatype operation
26          = RClamp | RLerp
27          | VClamp of int * int
28          | VMapClamp of int * int
29          | VLerp of int * int
30          | VScale of int * int
31          | VSum of int * int
32          | VLoad of int * int
33          | VCons of int * int
34          | VPack of TreeTypes.vec_layout
35    
36      val collect : TreeIR.program -> t      val collect : TreeIR.program -> t
37    
38      val foldOverTypes : (TreeTypes.t * bool * 'a -> 'a) -> 'a -> t -> 'a      val foldOverTypes : (TreeTypes.t * bool * 'a -> 'a) -> 'a -> t -> 'a
39      val applyToTypes : (TreeTypes.t * bool -> unit) -> t -> unit      val foldOverOps   : (operation * 'a -> 'a) -> 'a -> t -> 'a
40    
41    end = struct    end = struct
42    
43      structure IR = TreeIR      structure IR = TreeIR
44      structure Ty = TreeTypes      structure Ty = TreeTypes
45        structure Op = TreeOps
46    
47        datatype operation
48          = RClamp | RLerp
49          | VSum of int * int
50          | VClamp of int * int
51          | VMapClamp of int * int
52          | VLerp of int * int
53          | VScale of int * int
54          | VLoad of int * int
55          | VCons of int * int
56          | VPack of Ty.vec_layout
57    
58        structure OpTbl = HashTableFn (
59          struct
60            type hash_key = operation
61            fun hashVal rator = (case rator
62                   of RClamp => 0w13
63                    | RLerp => 0w17
64                    | VSum(w, _) => 0w23 + 0w7 * Word.fromInt w
65                    | VClamp(w, _) => 0w27 + 0w7 * Word.fromInt w
66                    | VMapClamp(w, _) => 0w31 + 0w7 * Word.fromInt w
67                    | VLerp(w, _) => 0w37 + 0w7 * Word.fromInt w
68                    | VScale(w, _) => 0w41 + 0w7 * Word.fromInt w
69                    | VLoad(w, _) => 0w43 + 0w7 * Word.fromInt w
70                    | VCons(w, _) => 0w47 + 0w7 * Word.fromInt w
71                    | VPack{wid, ...} => 0w51 + 0w7 * Word.fromInt wid
72                  (* end case *))
73            fun sameKey (op1, op2) = (case (op1, op2)
74                   of (RClamp, RClamp) => true
75                    | (RLerp, RLerp) => true
76                    | (VSum(w1, _), VSum(w2, _)) => (w1 = w2)
77                    | (VClamp(w1, _), VClamp(w2, _)) => (w1 = w2)
78                    | (VMapClamp(w1, _), VMapClamp(w2, _)) => (w1 = w2)
79                    | (VLerp(w1, _), VLerp(w2, _)) => (w1 = w2)
80                    | (VScale(w1, _), VScale(w2, _)) => (w1 = w2)
81                    | (VLoad(w1, _), VLoad(w2, _)) => (w1 = w2)
82                    | (VCons(w1, _), VCons(w2, _)) => (w1 = w2)
83                    | (VPack{wid=w1, ...}, VPack{wid=w2, ...}) => (w1 = w2)
84                    | _ => false
85                  (* end case *))
86          end)
87    
88      datatype t = Info of {      datatype t = Info of {
89          tys : bool TreeTypes.Tbl.hash_table     (* mapping for types in program; the bool is true *)          tys : bool TreeTypes.Tbl.hash_table,    (* mapping for types in program; the bool is true *)
90                                                  (* for types that are printed. *)                                                  (* for types that are printed. *)
91            ops : unit OpTbl.hash_table             (* mapping for selected operations in the program *)
92        }        }
93    
94      fun addType (Info{tys, ...}) = let      fun addType (Info{tys, ...}) = let
# Line 66  Line 116 
116              addTy              addTy
117            end            end
118    
119        fun insertOp (Info{ops, ...}) = let
120              val find = OpTbl.find ops
121              val ins = OpTbl.insert ops
122              in
123                fn rator => (case find rator
124                     of NONE => ins (rator, ())
125                      | SOME() => ()
126                    (* end case *))
127              end
128    
129        fun addOp info = let
130              val insert = insertOp info
131              fun add' rator = (case rator
132                     of Op.RClamp => insert RClamp
133                      | Op.RLerp => insert RLerp
134                      | Op.VSum(w, pw) => insert (VSum(w, pw))
135                      | Op.VClamp(w, pw) => insert (VClamp(w, pw))
136                      | Op.VMapClamp(w, pw) => insert (VMapClamp(w, pw))
137                      | Op.VLerp(w, pw) => insert (VLerp(w, pw))
138                      | _ => ()
139                    (* end case *))
140              in
141                add'
142              end
143    
144      fun collect prog = let      fun collect prog = let
145            val IR.Program{            val IR.Program{
146                  consts, inputs, constInit, globals, globalInit,                  consts, inputs, constInit, globals, globalInit,
# Line 73  Line 148 
148                } = prog                } = prog
149            val IR.Strand{params, state, stateInit, initM, updateM, stabilizeM, ...} = strand            val IR.Strand{params, state, stateInit, initM, updateM, stabilizeM, ...} = strand
150            val info = Info{            val info = Info{
151                    tys = TreeTypes.Tbl.mkTable (64, Fail "tys")                    tys = TreeTypes.Tbl.mkTable (64, Fail "tys"),
152                      ops = OpTbl.mkTable (64, Fail "ops")
153                  }                  }
154            val addType = addType info            val addType = addType info
155              val addOp = addOp info
156              val insertOp = insertOp info
157            fun doGlobalV x = addType(TreeGlobalVar.ty x, false)            fun doGlobalV x = addType(TreeGlobalVar.ty x, false)
158            fun doStateV x = addType(TreeStateVar.ty x, false)            fun doStateV x = addType(TreeStateVar.ty x, false)
159            fun doV x = addType(TreeVar.ty x, false)            fun doV x = addType(TreeVar.ty x, false)
160            fun doExp e = (case e            fun doExp e = (case e
161                   of IR.E_State(SOME e, sv) => doExp e                   of IR.E_State(SOME e, sv) => doExp e
162                    | IR.E_Op(rator, args) => (                    | IR.E_Op(rator, args) => (
163                        (* TODO: check rator *)                        addOp rator;
164                        List.app doExp args)                        List.app doExp args)
165                    | IR.E_Vec(w, pw, es) => (addType(Ty.VecTy(w, pw), false); List.app doExp es)                    | IR.E_Vec(w, pw, es) => (
166                          addType(Ty.VecTy(w, pw), false);
167                          insertOp (VCons(w, pw));
168                          List.app doExp es)
169                    | IR.E_Cons(es, ty) => (addType(ty, false); List.app doExp es)                    | IR.E_Cons(es, ty) => (addType(ty, false); List.app doExp es)
170                    | IR.E_Seq(es, ty) => (addType(ty, false); List.app doExp es)                    | IR.E_Seq(es, ty) => (addType(ty, false); List.app doExp es)
171                    | IR.E_Pack(_, es) => List.app doExp es                    | IR.E_Pack(layout, es) => (
172                    | IR.E_VLoad(layout, e, i) => (addType(Ty.nthVec(layout, i), false); doExp e)                        List.app (fn ty => addType(ty, false)) (Ty.piecesOf layout);
173                          insertOp (VPack layout);
174                          List.app doExp es)
175                      | IR.E_VLoad(layout, e, i) => let
176                          val ty as Ty.VecTy(w, pw) = Ty.nthVec(layout, i)
177                          in
178                            addType(ty, false);
179                            insertOp (VLoad(w, pw));
180                            doExp e
181                          end
182                    | _ => ()                    | _ => ()
183                  (* end case *))                  (* end case *))
184            fun doStm stm = (case stm            fun doStm stm = (case stm
# Line 127  Line 217 
217              info              info
218            end            end
219    
220      fun foldOverTypes f init (Info{tys}) = TreeTypes.Tbl.foldi f init tys      fun foldOverTypes f init (Info{tys, ...}) = TreeTypes.Tbl.foldi f init tys
221        fun foldOverOps f init (Info{ops, ...}) =
222      fun applyToTypes f (Info{tys}) = TreeTypes.Tbl.appi f tys            OpTbl.foldi (fn (k, _, acc) => f(k, acc)) init ops
223    
224    end    end

Legend:
Removed from v.3919  
changed lines
  Added in v.3931

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