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 3920, Wed Jun 1 10:36:32 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    
35      val collect : TreeIR.program -> t      val collect : TreeIR.program -> t
36    
37      val foldOverTypes : (TreeTypes.t * bool * 'a -> 'a) -> 'a -> t -> 'a      val foldOverTypes : (TreeTypes.t * bool * 'a -> 'a) -> 'a -> t -> 'a
38      val applyToTypes : (TreeTypes.t * bool -> unit) -> t -> unit      val foldOverOps   : (operation * 'a -> 'a) -> 'a -> t -> 'a
39    
40    end = struct    end = struct
41    
42      structure IR = TreeIR      structure IR = TreeIR
43      structure Ty = TreeTypes      structure Ty = TreeTypes
44        structure Op = TreeOps
45    
46        datatype operation
47          = RClamp | RLerp
48          | VSum of int * int
49          | VClamp of int * int
50          | VMapClamp of int * int
51          | VLerp of int * int
52          | VScale of int * int
53          | VLoad of int * int
54          | VCons of int * int
55    
56        structure OpTbl = HashTableFn (
57          struct
58            type hash_key = operation
59            fun hashVal rator = (case rator
60                   of RClamp => 0w13
61                    | RLerp => 0w17
62                    | VSum(w, _) => 0w23 + 0w7 * Word.fromInt w
63                    | VClamp(w, _) => 0w27 + 0w7 * Word.fromInt w
64                    | VMapClamp(w, _) => 0w31 + 0w7 * Word.fromInt w
65                    | VLerp(w, _) => 0w37 + 0w7 * Word.fromInt w
66                    | VScale(w, _) => 0w41 + 0w7 * Word.fromInt w
67                    | VLoad(w, _) => 0w43 + 0w7 * Word.fromInt w
68                    | VCons(w, _) => 0w47 + 0w7 * Word.fromInt w
69                  (* end case *))
70            fun sameKey (op1, op2) = (case (op1, op2)
71                   of (RClamp, RClamp) => true
72                    | (RLerp, RLerp) => true
73                    | (VSum(w1, _), VSum(w2, _)) => (w1 = w2)
74                    | (VClamp(w1, _), VClamp(w2, _)) => (w1 = w2)
75                    | (VMapClamp(w1, _), VMapClamp(w2, _)) => (w1 = w2)
76                    | (VLerp(w1, _), VLerp(w2, _)) => (w1 = w2)
77                    | (VScale(w1, _), VScale(w2, _)) => (w1 = w2)
78                    | (VLoad(w1, _), VLoad(w2, _)) => (w1 = w2)
79                    | (VCons(w1, _), VCons(w2, _)) => (w1 = w2)
80                    | _ => false
81                  (* end case *))
82          end)
83    
84      datatype t = Info of {      datatype t = Info of {
85          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 *)
86                                                  (* for types that are printed. *)                                                  (* for types that are printed. *)
87            ops : unit OpTbl.hash_table             (* mapping for selected operations in the program *)
88        }        }
89    
90      fun addType (Info{tys, ...}) = let      fun addType (Info{tys, ...}) = let
# Line 66  Line 112 
112              addTy              addTy
113            end            end
114    
115        fun addOp (Info{ops, ...}) = let
116              val find = OpTbl.find ops
117              val ins = OpTbl.insert ops
118              fun insert rator = (case find rator
119                     of NONE => ins (rator, ())
120                      | SOME() => ()
121                    (* end case *))
122              fun add' rator = (case rator
123                     of Op.RClamp => insert RClamp
124                      | Op.RLerp => insert RLerp
125                      | Op.VSum(w, pw) => insert (VSum(w, pw))
126                      | Op.VClamp(w, pw) => insert (VClamp(w, pw))
127                      | Op.VMapClamp(w, pw) => insert (VMapClamp(w, pw))
128                      | Op.VLerp(w, pw) => insert (VLerp(w, pw))
129                      | _ => ()
130                    (* end case *))
131              in
132                add'
133              end
134    
135      fun collect prog = let      fun collect prog = let
136            val IR.Program{            val IR.Program{
137                  consts, inputs, constInit, globals, globalInit,                  consts, inputs, constInit, globals, globalInit,
# Line 73  Line 139 
139                } = prog                } = prog
140            val IR.Strand{params, state, stateInit, initM, updateM, stabilizeM, ...} = strand            val IR.Strand{params, state, stateInit, initM, updateM, stabilizeM, ...} = strand
141            val info = Info{            val info = Info{
142                    tys = TreeTypes.Tbl.mkTable (64, Fail "tys")                    tys = TreeTypes.Tbl.mkTable (64, Fail "tys"),
143                      ops = OpTbl.mkTable (64, Fail "ops")
144                  }                  }
145            val addType = addType info            val addType = addType info
146              val addOp = addOp info
147            fun doGlobalV x = addType(TreeGlobalVar.ty x, false)            fun doGlobalV x = addType(TreeGlobalVar.ty x, false)
148            fun doStateV x = addType(TreeStateVar.ty x, false)            fun doStateV x = addType(TreeStateVar.ty x, false)
149            fun doV x = addType(TreeVar.ty x, false)            fun doV x = addType(TreeVar.ty x, false)
150            fun doExp e = (case e            fun doExp e = (case e
151                   of IR.E_State(SOME e, sv) => doExp e                   of IR.E_State(SOME e, sv) => doExp e
152                    | IR.E_Op(rator, args) => (                    | IR.E_Op(rator, args) => (
153                        (* TODO: check rator *)                        addOp rator;
154                        List.app doExp args)                        List.app doExp args)
155                    | IR.E_Vec(w, pw, es) => (addType(Ty.VecTy(w, pw), false); List.app doExp es)                    | IR.E_Vec(w, pw, es) => (
156                          addType(Ty.VecTy(w, pw), false);
157    (* FIXME: record VCons *)
158                          List.app doExp es)
159                    | IR.E_Cons(es, ty) => (addType(ty, false); List.app doExp es)                    | IR.E_Cons(es, ty) => (addType(ty, false); List.app doExp es)
160                    | IR.E_Seq(es, ty) => (addType(ty, false); List.app doExp es)                    | IR.E_Seq(es, ty) => (addType(ty, false); List.app doExp es)
161                    | IR.E_Pack(_, es) => List.app doExp es                    | IR.E_Pack(_, es) => List.app doExp es
162                    | IR.E_VLoad(layout, e, i) => (addType(Ty.nthVec(layout, i), false); doExp e)                    | IR.E_VLoad(layout, e, i) => (
163                          addType(Ty.nthVec(layout, i), false);
164    (* FIXME: record VCons *)
165                          doExp e)
166                    | _ => ()                    | _ => ()
167                  (* end case *))                  (* end case *))
168            fun doStm stm = (case stm            fun doStm stm = (case stm
# Line 127  Line 201 
201              info              info
202            end            end
203    
204      fun foldOverTypes f init (Info{tys}) = TreeTypes.Tbl.foldi f init tys      fun foldOverTypes f init (Info{tys, ...}) = TreeTypes.Tbl.foldi f init tys
205        fun foldOverOps f init (Info{ops, ...}) =
206      fun applyToTypes f (Info{tys}) = TreeTypes.Tbl.appi f tys            OpTbl.foldi (fn (k, _, acc) => f(k, acc)) init ops
207    
208    end    end

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

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