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

SCM Repository

[diderot] Diff of /branches/vis12-cl/src/compiler/IL/ssa-sig.sml
ViewVC logotype

Diff of /branches/vis12-cl/src/compiler/IL/ssa-sig.sml

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

revision 1444, Mon Jul 11 12:11:53 2011 UTC revision 1640, Wed Nov 16 02:19:51 2011 UTC
# Line 40  Line 40 
40      structure Ty : SSA_TYPES      structure Ty : SSA_TYPES
41      structure Op : OPERATORS where type ty = Ty.ty      structure Op : OPERATORS where type ty = Ty.ty
42    
43      (***** strand state variables *****)
44    
45        datatype state_var = SV of {
46            id : Stamp.stamp,               (* variable's unique ID *)
47            name : string,                  (* variable's name *)
48            ty : Ty.ty,                     (* variable's type *)
49            output : bool,                  (* true for output variables *)
50            props : PropList.holder
51          }
52    
53    (***** CFG *****)    (***** CFG *****)
54    
55      datatype cfg = CFG of {      datatype cfg = CFG of {
# Line 79  Line 89 
89              stm : assign,              stm : assign,
90              succ : node ref              succ : node ref
91            }            }
92          | MASSIGN of {                    (* multi-assignment *)
93                pred : node ref,
94                stm : massign,
95                succ : node ref
96              }
97        | NEW of {                        (* create new strand instance *)        | NEW of {                        (* create new strand instance *)
98              pred : node ref,              pred : node ref,
99              strand : Atom.atom,              strand : Atom.atom,
100              args : var list,              args : var list,
101              succ : node ref              succ : node ref
102            }            }
103          | SAVE of {                       (* save state variable *)
104                pred: node ref,
105                lhs : state_var,
106                rhs : var,
107                succ : node ref
108              }
109        | EXIT of {                       (* includes die and stabilize *)        | EXIT of {                       (* includes die and stabilize *)
110              pred : node ref,              pred : node ref,
111              kind : ExitKind.kind,       (* kind of exit node *)              kind : ExitKind.kind,       (* kind of exit node *)
# Line 92  Line 113 
113            }            }
114    
115      and rhs      and rhs
116        = VAR of var        = STATE of state_var              (* read strand state variable *)
117          | VAR of var
118        | LIT of Literal.literal        | LIT of Literal.literal
119        | OP of Op.rator * var list        | OP of Op.rator * var list
120        | APPLY of ILBasis.name * var list (* basis function application *)        | APPLY of ILBasis.name * var list (* basis function application *)
# Line 110  Line 132 
132      and var_bind      and var_bind
133        = VB_NONE        = VB_NONE
134        | VB_RHS of rhs                   (* defined by an assignment (includes globals and state variables) *)        | VB_RHS of rhs                   (* defined by an assignment (includes globals and state variables) *)
135          | VB_MULTIOP of int * Op.rator * var list
136                                            (* n'th result of operator in multi-assignment *)
137        | VB_PHI of var list              (* defined by a phi node *)        | VB_PHI of var list              (* defined by a phi node *)
138        | VB_PARAM                        (* parameter to a strand *)        | VB_PARAM                        (* parameter to a strand *)
139    
140      withtype assign = (var * rhs)      withtype assign = (var * rhs)
141             and massign = (var list * Op.rator * var list)
142           and phi = (var * var list)           and phi = (var * var list)
143    
144        datatype assignment = ASSGN of assign | MASSGN of massign
145    
146    
147    (***** Program representation *****)    (***** Program representation *****)
148    
149      datatype program = Program of {      datatype program = Program of {
150            props : StrandUtil.program_prop list,
151          globalInit : cfg,          globalInit : cfg,
152          initially : initially,          initially : initially,
153          strands : strand list          strands : strand list
# Line 135  Line 163 
163      and strand = Strand of {      and strand = Strand of {
164          name : Atom.atom,          name : Atom.atom,
165          params : var list,          params : var list,
166          state : (bool * var) list,      (* output variables are marked with true *)          state : state_var list,
167          stateInit : cfg,          stateInit : cfg,
168          methods : method list          methods : method list
169        }        }
170    
171      and method = Method of {      and method = Method of {
172          name : MethodName.name,          name : StrandUtil.method_name,
         stateIn : var list,     (* names of state variables on method entry *)  
173          body : cfg              (* method body *)          body : cfg              (* method body *)
174        }        }
175    
176      (* operations on strand-state variables *)
177        structure StateVar : sig
178            val new : bool * string * Ty.ty -> state_var
179            val name : state_var -> string
180            val ty : state_var -> Ty.ty
181            val isOutput : state_var -> bool
182            val same : state_var * state_var -> bool
183            val compare : state_var * state_var -> order
184            val hash : state_var -> word
185            val toString : state_var -> string
186          (* properties *)
187            val newProp : (state_var -> 'a) -> {
188                    getFn : state_var -> 'a,
189                    peekFn : state_var -> 'a option,
190                    setFn : state_var * 'a -> unit,
191                    clrFn : state_var -> unit
192                  }
193            val newFlag : unit -> {
194                    getFn : state_var -> bool,
195                    setFn : state_var * bool -> unit
196                  }
197          (* collections *)
198            structure Map : ORD_MAP where type Key.ord_key = state_var
199            structure Set : ORD_SET where type Key.ord_key = state_var
200            structure Tbl : MONO_HASH_TABLE where type Key.hash_key = state_var
201          end
202    
203    (* operations on CFGs *)    (* operations on CFGs *)
204      structure CFG : sig      structure CFG : sig
205        (* the empty CFG *)        (* the empty CFG *)
# Line 153  Line 207 
207        (* is a CFG empty? *)        (* is a CFG empty? *)
208          val isEmpty : cfg -> bool          val isEmpty : cfg -> bool
209        (* create a basic block from a list of assignments *)        (* create a basic block from a list of assignments *)
210          val mkBlock : assign list -> cfg          val mkBlock : assignment list -> cfg
211        (* entry/exit nodes of a CFG *)        (* entry/exit nodes of a CFG *)
212          val entry : cfg -> node          val entry : cfg -> node
213          val exit : cfg -> node          val exit : cfg -> node
# Line 180  Line 234 
234          val replaceNodeWithCFG : (node * cfg) -> unit          val replaceNodeWithCFG : (node * cfg) -> unit
235        (* concatenate two CFGs *)        (* concatenate two CFGs *)
236          val concat : cfg * cfg -> cfg          val concat : cfg * cfg -> cfg
237          (* prepend a node to a CFG *)
238            val prependNode : node * cfg -> cfg
239        (* append a node to a CFG *)        (* append a node to a CFG *)
240          val appendNode : cfg * node -> cfg          val appendNode : cfg * node -> cfg
241        (* update the exit of a CFG by modifying the live variable list *)        (* update the exit of a CFG by modifying the live variable list *)
# Line 220  Line 276 
276          val mkCOND : {cond : var, trueBranch : node, falseBranch : node} -> node          val mkCOND : {cond : var, trueBranch : node, falseBranch : node} -> node
277          val mkCOM : string list -> node          val mkCOM : string list -> node
278          val mkASSIGN : assign -> node          val mkASSIGN : assign -> node
279            val mkMASSIGN : massign -> node
280          val mkNEW : {strand : Atom.atom, args : var list} -> node          val mkNEW : {strand : Atom.atom, args : var list} -> node
281            val mkSAVE : (state_var * var) -> node
282          val mkEXIT : ExitKind.kind * var list -> node          val mkEXIT : ExitKind.kind * var list -> node
283          val mkFRAGMENT : var list -> node          val mkFRAGMENT : var list -> node
284          val mkSINIT : var list -> node          val mkSINIT : unit -> node
285          val mkRETURN : var list -> node          val mkRETURN : var list -> node
286          val mkACTIVE : var list -> node          val mkACTIVE : unit -> node
287          val mkSTABILIZE : var list -> node          val mkSTABILIZE : unit -> node
288          val mkDIE : unit -> node          val mkDIE : unit -> node
289        (* properties *)        (* properties *)
290          val newProp : (node -> 'a) -> {          val newProp : (node -> 'a) -> {
# Line 287  Line 345 
345    
346    (* return a string representation of an assignment *)    (* return a string representation of an assignment *)
347      val assignToString : assign -> string      val assignToString : assign -> string
348        val massignToString : massign -> string
349    
350    end    end

Legend:
Removed from v.1444  
changed lines
  Added in v.1640

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