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

SCM Repository

[diderot] Diff of /branches/vis12/src/compiler/high-il/border-control.sml
ViewVC logotype

Diff of /branches/vis12/src/compiler/high-il/border-control.sml

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

revision 2971, Fri Mar 6 03:35:49 2015 UTC revision 2972, Fri Mar 6 14:57:49 2015 UTC
# Line 4  Line 4 
4   * All rights reserved.   * All rights reserved.
5   *   *
6   * This pass inserts Inside tests to the HighIL representation to   * This pass inserts Inside tests to the HighIL representation to
7     *
8     * TODO:
9     *      merge inside tests for situations like F(x)+F(x).
10   *)   *)
11    
12  structure BorderControl : sig  structure BorderControl : sig
# Line 14  Line 17 
17    
18      structure IL = HighIL      structure IL = HighIL
19      structure Op = HighOps      structure Op = HighOps
20        structure Ty = HighILTypes
21      structure DT = DomTree      structure DT = DomTree
22    
23    (* an environment that tracks available inside tests *)    (* an environment that tracks available inside tests *)
# Line 23  Line 27 
27                 of EQUAL => IL.Var.compare(x, y)                 of EQUAL => IL.Var.compare(x, y)
28                  | order => order                  | order => order
29                (* end case *))                (* end case *))
30        end        end)
31    
32      fun getInsideTest cond = (case IL.Var.binding cond      fun getInsideTest cond = (case IL.Var.binding cond
33             of IL.VB_RHS(IL.OP(Op.Inside _, [pos, fld])) => SOME(pos, fld)             of IL.VB_RHS(IL.OP(Op.Inside _, [pos, fld])) => SOME(pos, fld)
# Line 35  Line 39 
39      fun hasBorderCtl f =(case IL.Var.binding f      fun hasBorderCtl f =(case IL.Var.binding f
40             of IL.VB_RHS(IL.OP(Op.Field _, [img, kern])) => let             of IL.VB_RHS(IL.OP(Op.Field _, [img, kern])) => let
41                  fun get img = (case IL.Var.binding img                  fun get img = (case IL.Var.binding img
42                          of IL.VB_RHS(Op.LoadImage _, _) => false                          of IL.VB_RHS(IL.OP(Op.LoadImage _, _)) => false
43                           | IL.VB_RHS(IL.OP(Op.BorderCtlValue _, _)) => true                           | IL.VB_RHS(IL.OP(Op.BorderCtlValue _, _)) => true
44                           | IL.VB_RHS(IL.OP(Op.BorderCtlClamp _, _)) => true                           | IL.VB_RHS(IL.OP(Op.BorderCtlClamp _, _)) => true
45                           | IL.VB_RHS(IL.OP(Op.BorderCtlMirror _, _)) => true                           | IL.VB_RHS(IL.OP(Op.BorderCtlMirror _, _)) => true
46                           | IL.VB_RHS(IL.OP(Op.BorderCtlWrap _, _)) => true                           | IL.VB_RHS(IL.OP(Op.BorderCtlWrap _, _)) => true
47                             | IL.VB_RHS(IL.VAR img) => get img
48                             | _ => raise Fail("expected image operator for " ^ IL.Var.toString img)
49                        (* end case *))                        (* end case *))
50                  in                  in
51                    get img                    get img
52                  end                  end
53              | IL.VB_RHS(IL.Var f') => getImage f'              | IL.VB_RHS(IL.VAR f') => hasBorderCtl f'
54              | _ => raise Fail("expected Field operator for " ^ IL.Var.toString f)              | _ => raise Fail("expected Field operator for " ^ IL.Var.toString f)
55            (* end case *))            (* end case *))
56    
57      fun transformCFG (liveIn, renameIn, cfg) = let    (* for a node "x = Probe(f, pos)", replace it with
58       *
59       *    if Inside(pos, f)
60       *      then x1 = Probe(f, pos)
61       *      else x2 = ProbeWithCtl(f, pos)
62       *    x = phi(x1, x2)
63       *)
64        fun rewriteProbe origNd = let
65              val IL.ASSIGN{stm=(y, IL.OP(Op.Probe arg, [f, pos])), ...} = IL.Node.kind origNd
66              val Ty.TensorTy[d] = IL.Var.ty pos
67              val y1 = IL.Var.copy y
68              val y2 = IL.Var.copy y
69              val cond = IL.Var.new("isInside", Ty.BoolTy)
70              val probeNd = IL.Node.mkASSIGN(y1, IL.OP(Op.Probe arg, [f, pos]))
71              val probeWithCtlNd = IL.Node.mkASSIGN(y2, IL.OP(Op.ProbeWithCtl arg, [f, pos]))
72              val insideTstNd = IL.Node.mkASSIGN(cond, IL.OP(Op.Inside d, [pos, f]))
73              val condNd = IL.Node.mkCOND{cond = cond, trueBranch = probeNd, falseBranch = probeWithCtlNd}
74              val joinNd = IL.Node.mkJOIN[(y, [SOME y1, SOME y2])]
75              in
76              (* update use counts *)
77                HighILCensus.inc f; HighILCensus.inc f;
78                HighILCensus.inc pos; HighILCensus.inc pos;
79                HighILCensus.inc y1; HighILCensus.inc y2;
80              (* hook up edges *)
81                IL.Node.addEdge(insideTstNd, condNd);
82                IL.Node.addEdge(probeNd, joinNd);
83                IL.Node.addEdge(probeWithCtlNd, joinNd);
84              (* replace the original node with the new CFG *)
85                IL.CFG.replaceNodeWithCFG(origNd, IL.CFG{entry=insideTstNd, exit=joinNd})
86              end
87    
88        fun transformCFG cfg = let
89            (* a list of nodes that need to be rewritten *)
90              val workList = ref[]
91          (* walk the dominator tree computing value numbers *)          (* walk the dominator tree computing value numbers *)
92            fun walk (env, nd) = let            fun walk (env, nd) = let
93                  fun kids env = List.app (fn nd => walk (env, nd)) (DT.children nd)                  fun kids env = List.app (fn nd => walk (env, nd)) (DT.children nd)
# Line 60  Line 99 
99                                    (* add the this test to the walk of the true branch *)                                    (* add the this test to the walk of the true branch *)
100                                      walk (Env.add (env, inTst), trueBr);                                      walk (Env.add (env, inTst), trueBr);
101                                      walk (env, falseBr))                                      walk (env, falseBr))
102                                  | kids env                                  | _ => kids env
103                                (* end case *))                                (* end case *))
104                            | NONE => kids()                            | NONE => kids env
105                          (* end case *))                          (* end case *))
106                      | IL.ASSIGN{stm=(y, IL.OP(Op.Probe _, [f, pos]), ...} =>                      | IL.ASSIGN{stm=(y, IL.OP(Op.Probe _, [f, pos])), ...} =>
107                          if Env.member(env, (pos, f))                          if Env.member(env, (pos, f))
108                            then kids() (* no need for an inside test! *)                            then kids env (* no need for an inside test! *)
109                          else if hasBorderCtl f                          else if hasBorderCtl f
110                            then ??                            then (workList := nd :: !workList; kids env)
111                            else kids()                            else kids env
112                      | _ => kids()                      | _ => kids env
113                    (* end case *))                    (* end case *)
114                  end                  end
115            in            in
116              D.computeTree cfg;              DT.computeTree cfg;
117            (* compute border control info *)            (* compute border control info *)
118              walk (Env.empty, IL.CFG.entry cfg);              walk (Env.empty, IL.CFG.entry cfg);
119              D.clear cfg;              DT.clear cfg;
120            (* add inside tests to protect border control *)            (* add inside tests to protect border control *)
121              rewriteCFG cfg before              List.app rewriteProbe (!workList)
122                (List.app clearVar liveIn; List.app (clearVar o #1) renameIn)            end
123    
124        fun transform prog = let
125              val IL.Program{props, globals, inputInit, globalInit, initially, strands} = prog
126              val IL.Initially{isArray, rangeInit, iters, create} = initially
127            (* transform a strand *)
128              fun transformStrand (IL.Strand{name, params, state, stateInit, methods}) = let
129                    fun transformMeth (IL.Method{name, body}) = transformCFG body
130                    in
131                      transformCFG stateInit;
132                      List.app transformMeth methods
133                    end
134              in
135                (* NOTE: we don't process the inputInit code, because it is trivial *)
136                transformCFG globalInit;
137              (* transform the strand initialization code *)
138                transformCFG rangeInit;
139                transformCFG (#1 create);
140              (* transform the strands *)
141                List.app transformStrand strands;
142                prog
143            end            end
144    
145    end    end

Legend:
Removed from v.2971  
changed lines
  Added in v.2972

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