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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3931 - (view) (download)

1 : jhr 3866 (* collect-info.sml
2 :     *
3 :     * Collect information about the types and operations used in a program. We need this
4 :     * information to figure out what utility code to generate.
5 :     *
6 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
7 :     *
8 :     * COPYRIGHT (c) 2016 The University of Chicago
9 :     * All rights reserved.
10 :     *)
11 :    
12 : jhr 3870 (* operators to record:
13 :     RClamp
14 :     RLerp
15 :     VClamp
16 :     VMapClamp
17 :     VLerp
18 :     VScale
19 :     VSum
20 :     *)
21 : jhr 3866 structure CollectInfo : sig
22 :    
23 :     type t
24 :    
25 : jhr 3920 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 : jhr 3931 | VPack of TreeTypes.vec_layout
35 : jhr 3920
36 : jhr 3866 val collect : TreeIR.program -> t
37 :    
38 : jhr 3868 val foldOverTypes : (TreeTypes.t * bool * 'a -> 'a) -> 'a -> t -> 'a
39 : jhr 3920 val foldOverOps : (operation * 'a -> 'a) -> 'a -> t -> 'a
40 : jhr 3866
41 :     end = struct
42 :    
43 :     structure IR = TreeIR
44 : jhr 3919 structure Ty = TreeTypes
45 : jhr 3920 structure Op = TreeOps
46 : jhr 3866
47 : jhr 3920 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 : jhr 3931 | VPack of Ty.vec_layout
57 : jhr 3920
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 : jhr 3931 | VPack{wid, ...} => 0w51 + 0w7 * Word.fromInt wid
72 : jhr 3920 (* 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 : jhr 3931 | (VPack{wid=w1, ...}, VPack{wid=w2, ...}) => (w1 = w2)
84 : jhr 3920 | _ => false
85 :     (* end case *))
86 :     end)
87 :    
88 : jhr 3866 datatype t = Info of {
89 : jhr 3920 tys : bool TreeTypes.Tbl.hash_table, (* mapping for types in program; the bool is true *)
90 : jhr 3866 (* for types that are printed. *)
91 : jhr 3920 ops : unit OpTbl.hash_table (* mapping for selected operations in the program *)
92 : jhr 3866 }
93 :    
94 :     fun addType (Info{tys, ...}) = let
95 :     val find = TreeTypes.Tbl.find tys
96 :     val ins = TreeTypes.Tbl.insert tys
97 : jhr 3868 fun addTy (ty, inPrint) = let
98 :     fun insert ty = (case find ty
99 : jhr 3866 of NONE => ins (ty, inPrint)
100 :     | SOME b => if inPrint andalso (not b) then ins (ty, true) else ()
101 :     (* end case *))
102 : jhr 3868 fun add ty = (case ty
103 :     of TreeTypes.BoolTy => ()
104 :     | TreeTypes.IntTy => ()
105 :     | TreeTypes.StringTy => ()
106 :     | TreeTypes.VecTy(1, 1) => ()
107 :     | TreeTypes.StrandTy _ => ()
108 :     | TreeTypes.TupleTy tys => (insert ty; List.app add tys)
109 :     | TreeTypes.SeqTy(ty', _) => (insert ty; add ty')
110 :     | _ => insert ty
111 :     (* end case *))
112 :     in
113 :     add ty
114 :     end
115 : jhr 3866 in
116 :     addTy
117 :     end
118 :    
119 : jhr 3921 fun insertOp (Info{ops, ...}) = let
120 : jhr 3920 val find = OpTbl.find ops
121 :     val ins = OpTbl.insert ops
122 : jhr 3921 in
123 :     fn rator => (case find rator
124 : jhr 3920 of NONE => ins (rator, ())
125 :     | SOME() => ()
126 : jhr 3921 (* end case *))
127 :     end
128 :    
129 :     fun addOp info = let
130 :     val insert = insertOp info
131 : jhr 3920 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 : jhr 3866 fun collect prog = let
145 :     val IR.Program{
146 :     consts, inputs, constInit, globals, globalInit,
147 :     strand, create=IR.Create{code, ...}, update, ...
148 :     } = prog
149 :     val IR.Strand{params, state, stateInit, initM, updateM, stabilizeM, ...} = strand
150 :     val info = Info{
151 : jhr 3920 tys = TreeTypes.Tbl.mkTable (64, Fail "tys"),
152 :     ops = OpTbl.mkTable (64, Fail "ops")
153 : jhr 3866 }
154 :     val addType = addType info
155 : jhr 3920 val addOp = addOp info
156 : jhr 3921 val insertOp = insertOp info
157 : jhr 3866 fun doGlobalV x = addType(TreeGlobalVar.ty x, false)
158 :     fun doStateV x = addType(TreeStateVar.ty x, false)
159 :     fun doV x = addType(TreeVar.ty x, false)
160 :     fun doExp e = (case e
161 :     of IR.E_State(SOME e, sv) => doExp e
162 :     | IR.E_Op(rator, args) => (
163 : jhr 3920 addOp rator;
164 : jhr 3866 List.app doExp args)
165 : jhr 3920 | IR.E_Vec(w, pw, es) => (
166 :     addType(Ty.VecTy(w, pw), false);
167 : jhr 3921 insertOp (VCons(w, pw));
168 : jhr 3920 List.app doExp es)
169 : jhr 3866 | 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)
171 : jhr 3931 | IR.E_Pack(layout, es) => (
172 :     List.app (fn ty => addType(ty, false)) (Ty.piecesOf layout);
173 :     insertOp (VPack layout);
174 :     List.app doExp es)
175 : jhr 3921 | 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 : jhr 3866 | _ => ()
183 :     (* end case *))
184 :     fun doStm stm = (case stm
185 :     of IR.S_Assign(isDecl, x, e) => (
186 :     if isDecl then doV x else ();
187 :     doExp e)
188 :     | IR.S_MAssign(_, e) => doExp e
189 :     | IR.S_GAssign(_, e) => doExp e
190 :     | IR.S_IfThen(e, b) => (doExp e; doBlk b)
191 :     | IR.S_IfThenElse(e, b1, b2) => (doExp e; doBlk b1; doBlk b2)
192 :     | IR.S_Foreach(x, e, b) => (doV x; doExp e; doBlk b)
193 :     | IR.S_Input(_, _, _, SOME e) => doExp e
194 :     | IR.S_New(_, es) => List.app doExp es
195 :     | IR.S_Save(_, e) => doExp e
196 :     | IR.S_Print(tys, es) => (
197 :     List.app (fn ty => addType(ty, true)) tys;
198 :     List.app doExp es)
199 :     | _ => ()
200 :     (* end case *))
201 :     and doBlk (IR.Block{locals, body}) = (
202 :     List.app doV (!locals);
203 :     List.app doStm body)
204 :     in
205 :     List.app doGlobalV consts;
206 :     List.app (doGlobalV o Inputs.varOf) inputs;
207 :     List.app doGlobalV globals;
208 :     List.app doStateV state;
209 :     doBlk constInit;
210 :     doBlk globalInit;
211 :     doBlk stateInit;
212 :     Option.app doBlk initM;
213 :     doBlk updateM;
214 :     Option.app doBlk stabilizeM;
215 :     doBlk code;
216 :     Option.app doBlk update;
217 :     info
218 :     end
219 :    
220 : jhr 3920 fun foldOverTypes f init (Info{tys, ...}) = TreeTypes.Tbl.foldi f init tys
221 :     fun foldOverOps f init (Info{ops, ...}) =
222 :     OpTbl.foldi (fn (k, _, acc) => f(k, acc)) init ops
223 : jhr 3866
224 :     end

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