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

SCM Repository

[diderot] Diff of /branches/vis12/src/compiler/mid-il/mid-contract.sml
ViewVC logotype

Diff of /branches/vis12/src/compiler/mid-il/mid-contract.sml

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

revision 2199, Sun Feb 24 15:15:14 2013 UTC revision 2200, Sun Feb 24 15:16:01 2013 UTC
# Line 4  Line 4 
4   * All rights reserved.   * All rights reserved.
5   *   *
6   * Contraction phase for MidIL.   * Contraction phase for MidIL.
7     *
8     * FIXME: we should use the RewriteFn for this, but it doesn't have MASSIGN support.
9   *)   *)
10    
11  structure MidContract : sig  structure MidContract : sig
# Line 14  Line 16 
16    
17      structure IL = MidIL      structure IL = MidIL
18      structure Op = MidOps      structure Op = MidOps
19        structure Ty = MidILTypes
20      structure V = IL.Var      structure V = IL.Var
21      structure ST = Stats      structure ST = Stats
22    
23    (********** Counters for statistics **********)    (********** Counters for statistics **********)
24        val cntAddNeg               = ST.newCounter "mid-opt:add-neg"
25        val cntSubNeg               = ST.newCounter "mid-opt:sub-neg"
26        val cntSubSame              = ST.newCounter "mid-opt:sub-same"
27        val cntNegNeg               = ST.newCounter "mid-opt:neg-neg"
28      val cntEigenVals            = ST.newCounter "mid-opt:eigen-vals"      val cntEigenVals            = ST.newCounter "mid-opt:eigen-vals"
29      val cntUnused               = ST.newCounter "mid-opt:unused"      val cntUnused               = ST.newCounter "mid-opt:unused"
30      val firstCounter            = cntEigenVals      val firstCounter            = cntAddNeg
31      val lastCounter             = cntUnused      val lastCounter             = cntUnused
32    
33      structure UnusedElim = UnusedElimFn (      structure UnusedElim = UnusedElimFn (
# Line 32  Line 39 
39    (* adjust a variable's use count *)    (* adjust a variable's use count *)
40      fun incUse (IL.V{useCnt, ...}) = (useCnt := !useCnt + 1)      fun incUse (IL.V{useCnt, ...}) = (useCnt := !useCnt + 1)
41      fun decUse (IL.V{useCnt, ...}) = (useCnt := !useCnt - 1)      fun decUse (IL.V{useCnt, ...}) = (useCnt := !useCnt - 1)
42        fun use x = (incUse x; x)
43    
44        fun getRHS x = (case V.binding x
45               of IL.VB_RHS(IL.OP arg) => SOME arg
46                | IL.VB_RHS(IL.VAR x') => getRHS x'
47                | _ => NONE
48              (* end case *))
49    
50        fun doAssign (lhs, IL.OP rhs) = (case rhs
51               of (Op.Add ty, [a, b]) => (case getRHS b
52                     of SOME(Op.Neg _, [c]) => (
53                        (* rewrite to "a-c" *)
54                          ST.tick cntAddNeg;
55                          decUse b;
56                          SOME[(lhs, IL.OP(Op.Sub ty, [a, use c]))])
57                      | _ => NONE
58                     (* end case *))
59                | (Op.Sub ty, [a, b]) => if IL.Var.same(a, b)
60                    then ( (* rewrite to 0 *)
61                      ST.tick cntSubSame;
62                      decUse a; decUse b;
63                      case ty
64                       of Ty.IntTy => SOME[(lhs, IL.LIT(Literal.Int 0))]
65                        | Ty.TensorTy[] => SOME[(lhs, IL.LIT(Literal.Float(FloatLit.zero false)))]
66                        | _ => (incUse a; incUse b; NONE) (* FIXME: should handle arbitrary tensors *)
67                      (* end case *))
68                    else (case getRHS b
69                       of SOME(Op.Neg _, [c]) => (
70                          (* rewrite to "a+c" *)
71                            ST.tick cntSubNeg;
72                            decUse b;
73                            SOME[(lhs, IL.OP(Op.Add ty, [a, use c]))])
74                        | _ => NONE
75                       (* end case *))
76                | (Op.Neg ty, [a]) => (case getRHS a
77                     of SOME(Op.Neg _, [b]) => (
78                        (* rewrite to "b" *)
79                          ST.tick cntNegNeg;
80                          decUse a;
81                          SOME[(lhs, IL.VAR(use b))])
82                      | _ => NONE
83                     (* end case *))
84                | _ => NONE
85              (* end case *))
86          | doAssign _ = NONE
87    
88    (* simplify expressions *)      fun doMAssign (ys, rator, xs) = (case (ys, rator)
     fun simplify nd = (case IL.Node.kind nd  
            of IL.MASSIGN{stm=(ys, rator, xs), ...} => (case (ys, rator)  
89                   of ([vals, vecs], Op.EigenVecs2x2) =>                   of ([vals, vecs], Op.EigenVecs2x2) =>
90                        if (useCount vecs = 0)                        if (useCount vecs = 0)
91                          then let                    then (
                           val newNd = IL.Node.mkASSIGN(vals, IL.OP(Op.EigenVals2x2, xs))  
                           in  
92                              ST.tick cntEigenVals;                              ST.tick cntEigenVals;
93                              IL.CFG.replaceNode (nd, newNd)                      SOME[(vals, IL.OP(Op.EigenVals2x2, xs))])
94                            end                    else NONE
                         else ()  
95                    | ([vals, vecs], Op.EigenVecs3x3) =>                    | ([vals, vecs], Op.EigenVecs3x3) =>
96                        if (useCount vecs = 0)                        if (useCount vecs = 0)
97                          then let                    then (
                           val newNd = IL.Node.mkASSIGN(vals, IL.OP(Op.EigenVals3x3, xs))  
                           in  
98                              ST.tick cntEigenVals;                              ST.tick cntEigenVals;
99                              IL.CFG.replaceNode (nd, newNd)                      SOME[(vals, IL.OP(Op.EigenVals3x3, xs))])
100                            end                    else NONE
101                          else ()              | _ => NONE
                   | _ => ()  
                 (* end case *))  
             | _ => ()  
102            (* end case *))            (* end case *))
103    
104      fun loopToFixPt f = let      structure Rewrite = RewriteFn (
105            fun loop n = let        struct
106                  val () = f ()          structure IL = IL
107                  val n' = Stats.sum{from=firstCounter, to=lastCounter}          val doAssign = doAssign
108                  in          val doMAssign = doMAssign
109                    if (n = n') then () else loop n'          val elimUnusedVars = UnusedElim.reduce
110                  end        end)
           in  
             loop (Stats.sum{from=firstCounter, to=lastCounter})  
           end  
111    
112      fun transform (prog as IL.Program{props, globalInit, initially, strands}) = let      val transform = Rewrite.transform
           fun doCFG cfg = (  
                 loopToFixPt (fn () => IL.CFG.apply simplify cfg);  
                 loopToFixPt (fn () => ignore(UnusedElim.reduce cfg)))  
           fun doMethod (IL.Method{body, ...}) = doCFG body  
           fun doStrand (IL.Strand{stateInit, methods, ...}) = (  
                 doCFG stateInit;  
                 List.app doMethod methods)  
           fun optPass () = (  
                 doCFG globalInit;  
                 List.app doStrand strands)  
           in  
             loopToFixPt optPass;  
 (* FIXME: after optimization, we should filter out any globals that are now unused *)  
             IL.Program{  
                 props = props,  
                 globalInit = globalInit,  
                 initially = initially,  (* FIXME: we should optimize this code *)  
                 strands = strands  
               }  
           end  
113    
114    end    end

Legend:
Removed from v.2199  
changed lines
  Added in v.2200

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