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

SCM Repository

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

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

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

trunk/src/compiler/IL/ssa-sig.sml revision 1301, Thu Jun 9 23:58:40 2011 UTC branches/lamont/src/compiler/IL/ssa-sig.sml revision 2298, Fri Mar 15 22:18:22 2013 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 69  Line 79 
79              trueBranch : node ref,              trueBranch : node ref,
80              falseBranch : node ref              falseBranch : node ref
81            }            }
82          | FOREACH of {
83                pred : node ref,
84                cond : var,
85                phis : phi list ref,
86                stmBranch : node ref,
87                varStrandName : string ref,
88                shouldReplace : bool ref,
89                stmBranchDone : bool ref,
90                succ : node ref
91              }
92        | COM of  {                       (* comment *)        | COM of  {                       (* comment *)
93              pred : node ref,              pred : node ref,
94              text : string list,              text : string list,
# Line 79  Line 99 
99              stm : assign,              stm : assign,
100              succ : node ref              succ : node ref
101            }            }
102          | MASSIGN of {                    (* multi-assignment *)
103                pred : node ref,
104                stm : massign,
105                succ : node ref
106              }
107        | NEW of {                        (* create new strand instance *)        | NEW of {                        (* create new strand instance *)
108              pred : node ref,              pred : node ref,
109              strand : Atom.atom,              strand : Atom.atom,
110              args : var list,              args : var list,
111              succ : node ref              succ : node ref
112            }            }
113          | SAVE of {                       (* save state variable *)
114                pred: node ref,
115                lhs : state_var,
116                rhs : var,
117                succ : node ref
118              }
119        | EXIT of {                       (* includes die and stabilize *)        | EXIT of {                       (* includes die and stabilize *)
120              pred : node ref,              pred : node ref,
121              kind : ExitKind.kind,       (* kind of exit node *)              kind : ExitKind.kind,       (* kind of exit node *)
122              live : var list             (* live variables *)              live : var list             (* live variables *)
123            }            }
124    
125        and strand_set
126          = SS_All
127          | SS_Stable
128          | SS_Active
129    
130      and rhs      and rhs
131        = VAR of var        = STATE of state_var              (* read strand state variable *)
132          | VAR of var
133        | LIT of Literal.literal        | LIT of Literal.literal
134          | SELECTOR of var * Atom.atom
135          | STRAND_SET of strand_set list
136        | OP of Op.rator * var list        | OP of Op.rator * var list
137        | APPLY of ILBasis.name * var list (* basis function application *)        | APPLY of MathFuns.name * var list (* basis function application *)
138        | CONS of Ty.ty * var list        (* tensor/sequence-value construction *)        | CONS of Ty.ty * var list        (* tensor/sequence-value construction *)
139    
140      and var = V of {      and var = V of {
# Line 110  Line 149 
149      and var_bind      and var_bind
150        = VB_NONE        = VB_NONE
151        | 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) *)
152          | VB_MULTIOP of int * Op.rator * var list
153                                            (* n'th result of operator in multi-assignment *)
154        | VB_PHI of var list              (* defined by a phi node *)        | VB_PHI of var list              (* defined by a phi node *)
155        | VB_PARAM                        (* parameter to a strand *)        | VB_PARAM                        (* parameter to a strand *)
156    
157      withtype assign = (var * rhs)      withtype assign = (var * rhs)
158             and massign = (var list * Op.rator * var list)
159           and phi = (var * var list)           and phi = (var * var list)
160    
161        datatype assignment = ASSGN of assign | MASSGN of massign
162    
163    
164    (***** Program representation *****)    (***** Program representation *****)
165    
166      datatype program = Program of {      datatype program = Program of {
167            props : StrandUtil.program_prop list,
168          globalInit : cfg,          globalInit : cfg,
169            globalBlock : cfg,
170          initially : initially,          initially : initially,
171          strands : strand list          strands : strand list
172        }        }
# Line 135  Line 181 
181      and strand = Strand of {      and strand = Strand of {
182          name : Atom.atom,          name : Atom.atom,
183          params : var list,          params : var list,
184          state : (bool * var) list,      (* output variables are marked with true *)          state : state_var list,
185          stateInit : cfg,          stateInit : cfg,
186          methods : method list          methods : method list
187        }        }
188    
189      and method = Method of {      and method = Method of {
190          name : Atom.atom,          name : StrandUtil.method_name,
         stateIn : var list,     (* names of state variables on method entry *)  
191          body : cfg              (* method body *)          body : cfg              (* method body *)
192        }        }
193    
194      (* operations on strand-state variables *)
195        structure StateVar : sig
196            val new : bool * string * Ty.ty -> state_var
197            val name : state_var -> string
198            val ty : state_var -> Ty.ty
199            val isOutput : state_var -> bool
200            val same : state_var * state_var -> bool
201            val compare : state_var * state_var -> order
202            val hash : state_var -> word
203            val toString : state_var -> string
204          (* properties *)
205            val newProp : (state_var -> 'a) -> {
206                    getFn : state_var -> 'a,
207                    peekFn : state_var -> 'a option,
208                    setFn : state_var * 'a -> unit,
209                    clrFn : state_var -> unit
210                  }
211            val newFlag : unit -> {
212                    getFn : state_var -> bool,
213                    setFn : state_var * bool -> unit
214                  }
215          (* collections *)
216            structure Map : ORD_MAP where type Key.ord_key = state_var
217            structure Set : ORD_SET where type Key.ord_key = state_var
218            structure Tbl : MONO_HASH_TABLE where type Key.hash_key = state_var
219          end
220    
221    (* operations on CFGs *)    (* operations on CFGs *)
222      structure CFG : sig      structure CFG : sig
223        (* the empty CFG *)        (* the empty CFG *)
# Line 153  Line 225 
225        (* is a CFG empty? *)        (* is a CFG empty? *)
226          val isEmpty : cfg -> bool          val isEmpty : cfg -> bool
227        (* create a basic block from a list of assignments *)        (* create a basic block from a list of assignments *)
228          val mkBlock : assign list -> cfg          val mkBlock : assignment list -> cfg
229        (* entry/exit nodes of a CFG *)        (* entry/exit nodes of a CFG *)
230          val entry : cfg -> node          val entry : cfg -> node
231          val exit : cfg -> node          val exit : cfg -> node
# Line 180  Line 252 
252          val replaceNodeWithCFG : (node * cfg) -> unit          val replaceNodeWithCFG : (node * cfg) -> unit
253        (* concatenate two CFGs *)        (* concatenate two CFGs *)
254          val concat : cfg * cfg -> cfg          val concat : cfg * cfg -> cfg
255          (* prepend a node to a CFG *)
256            val prependNode : node * cfg -> cfg
257        (* append a node to a CFG *)        (* append a node to a CFG *)
258          val appendNode : cfg * node -> cfg          val appendNode : cfg * node -> cfg
259        (* 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 207  Line 281 
281          val hasSucc : node -> bool          val hasSucc : node -> bool
282          val succs : node -> node list          val succs : node -> node list
283          val setSucc : node * node -> unit          val setSucc : node * node -> unit
284            val setStmBranch : node * node -> unit   (* set statement branch succesor for FOREACH node *)
285          val setTrueBranch : node * node -> unit  (* set trueBranch successor for COND node *)          val setTrueBranch : node * node -> unit  (* set trueBranch successor for COND node *)
286          val setFalseBranch : node * node -> unit (* set falseBranch successor for COND node *)          val setFalseBranch : node * node -> unit (* set falseBranch successor for COND node *)
287          val addEdge : node * node -> unit          val addEdge : node * node -> unit
# Line 218  Line 293 
293          val mkENTRY : unit -> node          val mkENTRY : unit -> node
294          val mkJOIN : (var * var list) list -> node          val mkJOIN : (var * var list) list -> node
295          val mkCOND : {cond : var, trueBranch : node, falseBranch : node} -> node          val mkCOND : {cond : var, trueBranch : node, falseBranch : node} -> node
296            val mkFOREACH : {cond: var, stmBranch: node, sName : string, phis:(var * var list) list} -> node
297          val mkCOM : string list -> node          val mkCOM : string list -> node
298          val mkASSIGN : assign -> node          val mkASSIGN : assign -> node
299            val mkMASSIGN : massign -> node
300          val mkNEW : {strand : Atom.atom, args : var list} -> node          val mkNEW : {strand : Atom.atom, args : var list} -> node
301            val mkSAVE : (state_var * var) -> node
302          val mkEXIT : ExitKind.kind * var list -> node          val mkEXIT : ExitKind.kind * var list -> node
303          val mkFRAGMENT : var list -> node          val mkFRAGMENT : var list -> node
304          val mkSINIT : var list -> node          val mkSINIT : unit -> node
305          val mkRETURN : var list -> node          val mkRETURN : var list -> node
306          val mkACTIVE : var list -> node          val mkACTIVE : unit -> node
307          val mkSTABILIZE : var list -> node          val mkSTABILIZE : unit -> node
308          val mkDIE : unit -> node          val mkDIE : unit -> node
309        (* properties *)        (* properties *)
310          val newProp : (node -> 'a) -> {          val newProp : (node -> 'a) -> {
# Line 273  Line 351 
351    
352    (* operations on RHS expressions *)    (* operations on RHS expressions *)
353      structure RHS : sig      structure RHS : sig
354          (*  val reductionSame : reduction * reduction -> bool *)
355    (* FIXME: why are these strand_set functions defined here? *)
356            val strandSetSame : strand_set list * strand_set list -> bool
357         (*   val reductionToString: reduction -> string *)
358            val toStringSets : strand_set list -> string list
359          val toString : rhs -> string          val toString : rhs -> string
360          val vars : rhs -> var list          val vars : rhs -> var list
361          val map : (var -> var) -> rhs -> rhs          val map : (var -> var) -> rhs -> rhs
# Line 287  Line 370 
370    
371    (* return a string representation of an assignment *)    (* return a string representation of an assignment *)
372      val assignToString : assign -> string      val assignToString : assign -> string
373        val massignToString : massign -> string
374    
375    end    end

Legend:
Removed from v.1301  
changed lines
  Added in v.2298

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