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

SCM Repository

[diderot] Diff of /branches/pure-cfg/src/compiler/tree-il/var-analysis.sml
ViewVC logotype

Diff of /branches/pure-cfg/src/compiler/tree-il/var-analysis.sml

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

revision 1156, Sun May 8 21:20:52 2011 UTC revision 1157, Mon May 9 15:47:35 2011 UTC
# Line 101  Line 101 
101            fun doNode depth nd = (case IL.Node.kind nd            fun doNode depth nd = (case IL.Node.kind nd
102                   of IL.EXIT{kind, live, ...} => (case kind                   of IL.EXIT{kind, live, ...} => (case kind
103                         of ExitKind.FRAGMENT => List.app (setMaxUse depth) live                         of ExitKind.FRAGMENT => List.app (setMaxUse depth) live
104                            | ExitKind.SINIT => List.app (setMaxUse depth) live
105                          | ExitKind.RETURN => List.app (setMaxUse depth) live                          | ExitKind.RETURN => List.app (setMaxUse depth) live
106                          | _ => () (* we don't count ACTIVE, etc. as uses *)                          | _ => () (* we don't count ACTIVE, etc. as uses *)
107                        (* end case *))                        (* end case *))
# Line 109  Line 110 
110                        List.app (fn x => setBindDepth(x, depth)) (IL.Node.defs nd))                        List.app (fn x => setBindDepth(x, depth)) (IL.Node.defs nd))
111                  (* end case *))                  (* end case *))
112            fun doCFG (depth, cfg) = IL.CFG.apply (doNode depth) cfg            fun doCFG (depth, cfg) = IL.CFG.apply (doNode depth) cfg
113            fun doMethod state (IL.Method{stateIn, body, ...}) = let            fun assignDepthsForMethod state (IL.Method{stateIn, body, ...}) = let
114                  val stateInVec = Vector.fromList stateIn                  val stateInVec = Vector.fromList stateIn
115                (* check to see which state variables are invariant on the path from                (* check to see which state variables are invariant on the path from
116                 * the method entry to this point.                 * the method entry to this point.
# Line 137  Line 138 
138                  (* need to propagate maxUse from stateIn variables to state variables *)                  (* need to propagate maxUse from stateIn variables to state variables *)
139                    ListPair.appEq propInfo (state, stateIn)                    ListPair.appEq propInfo (state, stateIn)
140                  end                  end
141              fun copyDepthsForMethod state (IL.Method{stateIn, ...}) =
142                    ListPair.appEq (fn ((_, x), x') => setUseDepth(x', getUseDepth x)) (state, stateIn)
143            (* assign use depths for a strand.  The state variables are a bit tricky.  We first
144             * propagate information from the stateInit and methods up to the state-variable
145             * list.  Then we copy the accumulated use-depth information back down to the
146             * corresponding variables in the stateInit and methods.
147             *)
148            fun doStrand (IL.Strand{params, state, stateInit, methods, ...}) = (            fun doStrand (IL.Strand{params, state, stateInit, methods, ...}) = (
149                  List.app (fn x => setBindDepth(x, paramScope)) params;                  List.app (fn x => setBindDepth(x, paramScope)) params;
150                  (* output state variables are marked as methodStateScope *)
151                    List.app (fn (true, x) => setUseDepth(x, methodStateScope) | _ => ()) state;
152                  (* assign depths for the stateInit code *)
153                  doCFG (strandScope, stateInit);                  doCFG (strandScope, stateInit);
154                  List.app (doMethod state) methods)                (* propagate maxUse from exit variables of stateInit to the state-variable list *)
155                    ListPair.appEq
156                      (fn ((_, x), x') => setMaxUse (getUseDepth x') x)
157                        (state, IL.CFG.liveAtExit stateInit);
158                    List.app (assignDepthsForMethod state) methods;
159                  (* now we propagate use info back down *)
160                    ListPair.appEq
161                      (fn ((_, x), x') => setUseDepth(x', getUseDepth x))
162                        (state, IL.CFG.liveAtExit stateInit);
163                    List.app (copyDepthsForMethod state) methods)
164            in            in
165              doCFG (globalScope, globalInit);              doCFG (globalScope, globalInit);
166            (* do initially code *)            (* do initially code *)
# Line 213  Line 233 
233                        else if isOut orelse (getUseDepth x > strandScope)                        else if isOut orelse (getUseDepth x > strandScope)
234                          then (setVarScope(x, StrandConstState); true)                          then (setVarScope(x, StrandConstState); true)
235                          else (                          else (
                           LowILCensus.dec x;  (* we are removing the implicit use *)  
236                            setVarScope(x, Local);                            setVarScope(x, Local);
237                            false)                            false)
238                  in                  in
# Line 242  Line 261 
261                  in                  in
262                    (xs, ys, IL.CFG.mkBlock stms)                    (xs, ys, IL.CFG.mkBlock stms)
263                  end                  end
264          (* extend the stateInit CFG with the shadow-variable initialization *)          (* prepend the stateInit CFG with the shadow-variable initialization *)
265            val stateInit = if IL.CFG.isEmpty initShadowVars            val stateInit = if IL.CFG.isEmpty initShadowVars
266                  then stateInit                  then stateInit
267                  else let                  else let
# Line 254  Line 273 
273                      IL.Node.replaceOutEdge {oldSrc = initEntry, src = exit, dst = fstNd};                      IL.Node.replaceOutEdge {oldSrc = initEntry, src = exit, dst = fstNd};
274                      stateInit                      stateInit
275                    end                    end
276          (* rewrite the exit node of the stateInit to only return the strand state variables *)          (* rewrite the exit node of the stateInit to return only the strand state variables. *)
277            val stateInit = let            val stateInit = let
278                  fun isStrandState x = (case varScope x                  fun filterSV ((_, sv), x, xs) = (case varScope sv
279                         of StrandConstState => true                         of StrandConstState => x::xs
280                          | StrandState => true                          | StrandState => x::xs
281                          | _ => false                          | _ => xs
282                        (* end case *))                        (* end case *))
283                  fun f live = (List.map #2 shadowVars) @ List.filter isStrandState live                  fun f live = (List.map #2 shadowVars)
284                            @ ListPair.foldrEq filterSV [] (state, live)
285                  in                  in
286                    IL.CFG.updateExit (stateInit, f)                    IL.CFG.updateExit (stateInit, f)
287                  end                  end
# Line 363  Line 383 
383                            | IL.EXIT{kind=ExitKind.DIE, ...} => ()                            | IL.EXIT{kind=ExitKind.DIE, ...} => ()
384                            | IL.EXIT{kind, live, ...} =>                            | IL.EXIT{kind, live, ...} =>
385                                if outStateNeedsFiltering                                if outStateNeedsFiltering
386                                  then let (* filter out StradConstState and Local vars *)                                  then let (* filter out StrandConstState and Local vars *)
387                                    fun chkVar ((_, x), x', xs) = if (varScope x <> StrandState)                                    fun chkVar ((_, x), x', xs) = if (varScope x <> StrandState)
388                                          then xs                                          then xs
389                                          else x' :: xs                                          else x' :: xs

Legend:
Removed from v.1156  
changed lines
  Added in v.1157

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