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

SCM Repository

[diderot] Diff of /trunk/src/compiler/high-il/high-opt.sml
ViewVC logotype

Diff of /trunk/src/compiler/high-il/high-opt.sml

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

revision 371, Sat Oct 2 17:20:27 2010 UTC revision 372, Sun Oct 3 15:20:28 2010 UTC
# Line 29  Line 29 
29      val firstCounter            = cntConstConvolve      val firstCounter            = cntConstConvolve
30      val lastCounter             = cntUnused      val lastCounter             = cntUnused
31    
     datatype binding  
       = Unknown  
       | OP of Op.rator * IL.var list  
       | PHI of IL.var list  
   
32      fun useCount (IL.V{useCnt, ...}) = !useCnt      fun useCount (IL.V{useCnt, ...}) = !useCnt
33    
34    (* decrement a variable's use count *)    (* decrement a variable's use count *)
35      fun decUse (IL.V{useCnt, ...}) = (useCnt := !useCnt - 1)      fun decUse (IL.V{useCnt, ...}) = (useCnt := !useCnt - 1)
36    
37      val {getFn=getBinding, setFn=setBinding, clrFn=clrBinding, ...}      fun getRHS x = (case V.binding x
38            = V.newProp (fn _ => Unknown)             of IL.VB_RHS(IL.OP arg) => SOME arg
39                | _ => NONE
40              (* end case *))
41    
42    (* optimize the rhs of an assignment, returning NONE if there is no change *)    (* optimize the rhs of an assignment, returning NONE if there is no change *)
43      fun doRHS rhs = (case rhs      fun doRHS rhs = (case rhs
44             of IL.OP(Op.Convolve, [v, h]) => (case (getBinding v, getBinding h)             of IL.OP(Op.Convolve, [v, h]) => (case (getRHS v, getRHS h)
45                   of (OP(Op.LoadImage v', []), OP(Op.Kernel h', [])) => (                   of (SOME(Op.LoadImage v', []), SOME(Op.Kernel h', [])) => (
46                        ST.tick cntConstConvolve;                        ST.tick cntConstConvolve;
47                        decUse v; decUse h;                        decUse v; decUse h;
48                        SOME(IL.OP(Op.Field(F.convolve(v', h')), [])))                        SOME(IL.OP(Op.Field(F.convolve(v', h')), [])))
49                    | _ => raise Fail "non-constant Convolve"                    | _ => raise Fail "non-constant Convolve"
50                  (* end case *))                  (* end case *))
51              | IL.OP(Op.AddField, [f, g]) => (case (getBinding f, getBinding g)              | IL.OP(Op.AddField, [f, g]) => (case (getRHS f, getRHS g)
52                   of (OP(Op.Field f', []), OP(Op.Field g', [])) => (                   of (SOME(Op.Field f', []), SOME(Op.Field g', [])) => (
53                        ST.tick cntConstField;                        ST.tick cntConstField;
54                        decUse f; decUse g;                        decUse f; decUse g;
55                        SOME(IL.OP(Op.Field(F.SUM(f', g')), [])))                        SOME(IL.OP(Op.Field(F.SUM(f', g')), [])))
56                    | _ => NONE                    | _ => NONE
57                  (* end case *))                  (* end case *))
58              | IL.OP(Op.NegField, [f]) => (case (getBinding f)              | IL.OP(Op.NegField, [f]) => (case (getRHS f)
59                   of OP(Op.Field f', []) => (                   of SOME(Op.Field f', []) => (
60                        ST.tick cntConstField;                        ST.tick cntConstField;
61                        decUse f;                        decUse f;
62                        SOME(IL.OP(Op.Field(F.neg f'), [])))                        SOME(IL.OP(Op.Field(F.neg f'), [])))
63                    | _ => NONE                    | _ => NONE
64                  (* end case *))                  (* end case *))
65              | IL.OP(Op.DiffField, [f]) => (case (getBinding f)              | IL.OP(Op.DiffField, [f]) => (case (getRHS f)
66                   of OP(Op.Field f', []) => (                   of SOME(Op.Field f', []) => (
67                        ST.tick cntConstDiff;                        ST.tick cntConstDiff;
68                        decUse f;                        decUse f;
69                        SOME(IL.OP(Op.Field(F.diff f'), [])))                        SOME(IL.OP(Op.Field(F.diff f'), [])))
# Line 75  Line 72 
72              | _ => NONE              | _ => NONE
73            (* end case *))            (* end case *))
74    
     fun setBindings nodes = let  
           fun doNode (IL.JOIN{phis, ...}) =  
                 List.app (fn (y, xs) => setBinding(y, PHI xs)) (!phis)  
             | doNode (IL.BLOCK{body, ...}) =  
                 List.app (fn (y, IL.OP rhs) => setBinding(y, OP rhs) | _ => ()) (!body)  
             | doNode _ = ()  
           in  
             List.app doNode nodes  
           end  
   
75    (* simplify expressions *)    (* simplify expressions *)
76      fun simplify nodes = let      fun simplify nodes = let
77            fun doAssign (y, rhs) = (case doRHS rhs            fun doAssign (y, rhs) = (case doRHS rhs
78                   of SOME(rhs' as IL.OP t) => (setBinding(y, OP t); (y, rhs'))                   of SOME rhs' => (V.setBinding(y, IL.VB_RHS rhs'); (y, rhs'))
                   | SOME rhs' => (setBinding(y, Unknown); (y, rhs'))  
79                    | NONE => (y, rhs)                    | NONE => (y, rhs)
80                  (* end case *))                  (* end case *))
81            fun doNode (IL.ND{kind=IL.BLOCK{body, ...}, ...}) =            fun doNode (IL.ND{kind=IL.BLOCK{body, ...}, ...}) =
# Line 140  Line 126 
126              List.app doNode (List.rev nodes)              List.app doNode (List.rev nodes)
127            end            end
128    
     fun clearBindings nodes = let  
           fun doNode (IL.ND{kind, ...}) = (case kind  
                  of IL.JOIN{phis, ...} => List.app (fn (y, xs) => clrBinding y) (!phis)  
                   | IL.BLOCK{body, ...} => List.app (fn (y, _) => clrBinding y) (!body)  
                   | _ => ()  
                 (* end case *))  
           in  
             List.app doNode nodes  
           end  
   
129      fun loopToFixPt f prog = let      fun loopToFixPt f prog = let
130            fun loop (n, prog) = let            fun loop (n, prog) = let
131                  val () = f prog                  val () = f prog
# Line 175  Line 151 
151                  val nodes = IL.sortNodes body                  val nodes = IL.sortNodes body
152                  in                  in
153                    loopToFixPt simplify nodes;                    loopToFixPt simplify nodes;
154                    loopToFixPt reduce nodes;                    loopToFixPt reduce nodes
                   clearBindings nodes  
155                  end                  end
156            fun doActor (IL.Actor{stateInit, methods, ...}) = let            fun doActor (IL.Actor{stateInit, methods, ...}) = let
157                  val nodes = IL.sortNodes stateInit                  val nodes = IL.sortNodes stateInit
158                  in                  in
159                    loopToFixPt simplify nodes;                    loopToFixPt simplify nodes;
160                    loopToFixPt reduce nodes;                    loopToFixPt reduce nodes;
161                    List.app doMethod methods;                    List.app doMethod methods
                   clearBindings nodes  
162                  end                  end
163            val _ = List.app doActor actors            val _ = List.app doActor actors
         (* now we are done with the program body, so we can clean up the global initialization *)  
           val _ = clearBindings globInitNodes  
164            in            in
165              IL.Program{              IL.Program{
166                  globals = globals,                  globals = globals,

Legend:
Removed from v.371  
changed lines
  Added in v.372

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