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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/high-il/normalize.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/high-il/normalize.sml

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

revision 2399, Sun Jul 7 02:22:44 2013 UTC revision 2400, Sun Jul 7 13:29:54 2013 UTC
# Line 15  Line 15 
15      structure V = IL.Var      structure V = IL.Var
16      structure Ty = HighILTypes      structure Ty = HighILTypes
17      structure ST = Stats      structure ST = Stats
18        structure NE = NormalizeEin
19    
20    (********** Counters for statistics **********)    (********** Counters for statistics **********)
21      val cntInsideScale          = ST.newCounter "high-opt:inside-scale"      val cntInsideScale          = ST.newCounter "high-opt:inside-scale"
# Line 53  Line 54 
54      fun getRHS x = (case V.binding x      fun getRHS x = (case V.binding x
55             of IL.VB_RHS(IL.OP arg) => SOME arg             of IL.VB_RHS(IL.OP arg) => SOME arg
56              | IL.VB_RHS(IL.VAR x') => getRHS x'              | IL.VB_RHS(IL.VAR x') => getRHS x'
57                | IL.VB_RHS(IL.EINAPP arg)=> SOME arg
58              | _ => NONE              | _ => NONE
59            (* end case *))            (* end case *))
60    
# Line 65  Line 67 
67            (* end case *))            (* end case *))
68    
69    (* 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 *)
70      fun doRHS (lhs, IL.OP rhs) = (case rhs        fun doRHS (lhs, IL.EINAPP (ein, args))=
71               SOME[(lhs, IL.EINAPP(NE.normalize(ein), args))]
72    
73          | doRHS (lhs, IL.OP rhs) = (case rhs
74             of (Op.Inside dim, [pos, f]) => (case getRHS f             of (Op.Inside dim, [pos, f]) => (case getRHS f
75                   of SOME(Op.Field _, _) => NONE (* direct inside test does not need rewrite *)                   of SOME(Op.Field _, _) => NONE (* direct inside test does not need rewrite *)
                   | SOME(Op.AddField, [f', g']) => raise Fail "inside(f+g)"  
                   | SOME(Op.SubField, [f', g']) => raise Fail "inside(f-g)"  
                   | SOME(Op.ScaleField, [_, f']) => (  
                       ST.tick cntInsideScale;  
                       decUse f;  
                       SOME[(lhs, IL.OP(Op.Inside dim, [pos, use f']))])  
76                    | SOME(Op.OffsetField, [f', _]) => (                    | SOME(Op.OffsetField, [f', _]) => (
77                        ST.tick cntInsideOffset;                        ST.tick cntInsideOffset;
78                        decUse f;                        decUse f;
79                        SOME[(lhs, IL.OP(Op.Inside dim, [pos, use f']))])                        SOME[(lhs, IL.OP(Op.Inside dim, [pos, use f']))])
                   | SOME(Op.NegField, [f']) => (  
                       ST.tick cntInsideNeg;  
                       decUse f;  
                       SOME[(lhs, IL.OP(Op.Inside dim, [pos, use f']))])  
                   | SOME(Op.CurlField _, [f']) => (  
                       ST.tick cntInsideCurl;  
                       decUse f;  
                       SOME[(lhs, IL.OP(Op.Inside dim, [pos, use f']))])  
                   | SOME(Op.DiffField, [f']) => (  
                       ST.tick cntInsideDiff;  
                       decUse f;  
                       SOME[(lhs, IL.OP(Op.Inside dim, [pos, use f']))])  
80                    | _ => raise Fail(concat[                    | _ => raise Fail(concat[
81                          "inside: bogus field binding ", V.toString f, " = ", IL.vbToString(V.binding f)                          "inside: bogus field binding ", V.toString f, " = ", IL.vbToString(V.binding f)
82                        ])                        ])
83                  (* end case *))                  (* end case *))
             | (Op.Probe(domTy, rngTy), [f, pos]) => (case getRHS f  
                  of SOME(Op.Field _, _) => NONE (* direct probe does not need rewrite *)  
                   | SOME(Op.AddField, [f', g']) => let  
                     (* rewrite to (f@pos) + (g@pos) *)  
                       val lhs1 = IL.Var.copy lhs  
                       val lhs2 = IL.Var.copy lhs  
                       in  
                         ST.tick cntProbeAdd;  
                         decUse f;  
                         incUse lhs1; incUse f'; incUse lhs2; incUse g'; incUse pos;  
                         SOME[  
                             (lhs1, IL.OP(Op.Probe(domTy, rngTy), [f', pos])),  
                             (lhs2, IL.OP(Op.Probe(domTy, rngTy), [g', pos])),  
                             (lhs, IL.OP(Op.Add rngTy, [lhs1, lhs2]))  
                           ]  
                       end  
                   | SOME(Op.SubField, [f', g']) => let  
                     (* rewrite to (f@pos) - (g@pos) *)  
                       val lhs1 = IL.Var.copy lhs  
                       val lhs2 = IL.Var.copy lhs  
                       in  
                         ST.tick cntProbeSub;  
                         decUse f;  
                         incUse lhs1; incUse f'; incUse lhs2; incUse g'; incUse pos;  
                         SOME[  
                             (lhs1, IL.OP(Op.Probe(domTy, rngTy), [f', pos])),  
                             (lhs2, IL.OP(Op.Probe(domTy, rngTy), [g', pos])),  
                             (lhs, IL.OP(Op.Sub rngTy, [lhs1, lhs2]))  
                           ]  
                       end  
                   | SOME(Op.ScaleField, [s, f']) => let  
                     (* rewrite to s*(f'@pos) *)  
                       val lhs' = IL.Var.copy lhs  
                       val scaleOp = (case rngTy  
                              of Ty.TensorTy[] => Op.Mul rngTy  
                               | _ => Op.Scale rngTy  
                             (* end case *))  
                       in  
                         ST.tick cntProbeScale;  
                         decUse f;  
                         SOME[  
                             (lhs', IL.OP(Op.Probe(domTy, rngTy), [use f', pos])),  
                             (lhs, IL.OP(scaleOp, [use s, use lhs']))  
                           ]  
                       end  
                   | SOME(Op.OffsetField, [f', s]) => let  
                     (* rewrite to (f'@pos) + s *)  
                       val lhs' = IL.Var.copy lhs  
                       in  
                         ST.tick cntProbeOffset;  
                         decUse f;  
                         SOME[  
                             (lhs', IL.OP(Op.Probe(domTy, rngTy), [use f', pos])),  
                             (lhs, IL.OP(Op.Add rngTy, [use lhs', use s]))  
                           ]  
                       end  
                   | SOME(Op.NegField, [f']) => let  
                     (* rewrite to -(f'@pos) *)  
                       val lhs' = IL.Var.copy lhs  
                       in  
                         ST.tick cntProbeNeg;  
                         decUse f;  
                         incUse lhs'; incUse f';  
                         SOME[  
                             (lhs', IL.OP(Op.Probe(domTy, rngTy), [f', pos])),  
                             (lhs, IL.OP(Op.Neg rngTy, [lhs']))  
                           ]  
                       end  
                   | SOME(Op.CurlField 2, [f']) => (case getRHS f'  
                        of SOME(Op.Field dim, [v, h]) => let  
                           (* rewrite to (D f')@pos[1,0] - (D f')@pos[0,1] *)  
                             val (kernel, k) = getKernelRHS h  
                             val h' = IL.Var.copy h  
                             val f'' = IL.Var.copy f'  
                             val mat22 = Ty.TensorTy[2,2]  
                             val m = IL.Var.new("m", mat22)  
                             val zero = IL.Var.new("zero", Ty.intTy)  
                             val one = IL.Var.new("one", Ty.intTy)  
                             val m10 = IL.Var.new("m_10", Ty.realTy)  
                             val m01 = IL.Var.new("m_01", Ty.realTy)  
                             in  
                               ST.tick cntProbeCurl;  
                               decUse f;  
                               SOME[  
                                   (h', IL.OP(Op.Kernel(kernel, k+1), [])),  
                                   (f'', IL.OP(Op.Field dim, [use v, use h'])),  
                                   (m, IL.OP(Op.Probe(domTy, mat22), [use f'', pos])),  
                                   (zero, IL.LIT(Literal.Int 0)),  
                                   (one, IL.LIT(Literal.Int 1)),  
                                   (m10, IL.OP(Op.TensorSub mat22, [use m, use one, use zero])),  
                                   (m01, IL.OP(Op.TensorSub mat22, [use m, use zero, use one])),  
                                   (lhs, IL.OP(Op.Sub Ty.realTy, [use m10, use m01]))  
                                 ]  
                             end  
                         | _ => raise Fail(concat[  
                               "bogus field binding ", V.toString f', " = ", IL.vbToString(V.binding f')  
                             ])  
                       (* end case *))  
                   | SOME(Op.CurlField 3, [f']) => (case getRHS f'  
                        of SOME(Op.Field dim, [v, h]) => let  
                           (* rewrite to  
                            *  [ (D f')@pos[2,1] - (D f')@pos[1,2] ]  
                            *  [ (D f')@pos[0,2] - (D f')@pos[2,0] ]  
                            *  [ (D f')@pos[1,0] - (D f')@pos[0,1] ]  
                            *)  
                             val (kernel, k) = getKernelRHS h  
                             val h' = IL.Var.copy h  
                             val f'' = IL.Var.copy f'  
                             val mat33 = Ty.TensorTy[3,3]  
                             val m = IL.Var.new("m", mat33)  
                             val zero = IL.Var.new("zero", Ty.intTy)  
                             val one = IL.Var.new("one", Ty.intTy)  
                             val two = IL.Var.new("two", Ty.intTy)  
                             val m21 = IL.Var.new("m_21", Ty.realTy)  
                             val m12 = IL.Var.new("m_12", Ty.realTy)  
                             val m02 = IL.Var.new("m_02", Ty.realTy)  
                             val m20 = IL.Var.new("m_20", Ty.realTy)  
                             val m10 = IL.Var.new("m_10", Ty.realTy)  
                             val m01 = IL.Var.new("m_01", Ty.realTy)  
                             val lhs0 = IL.Var.new("lhs0", Ty.realTy)  
                             val lhs1 = IL.Var.new("lhs1", Ty.realTy)  
                             val lhs2 = IL.Var.new("lhs2", Ty.realTy)  
                             in  
                               ST.tick cntProbeCurl;  
                               decUse f;  
                               SOME[  
                                   (h', IL.OP(Op.Kernel(kernel, k+1), [])),  
                                   (f'', IL.OP(Op.Field dim, [use v, use h'])),  
                                   (m, IL.OP(Op.Probe(domTy, mat33), [use f'', pos])),  
                                   (zero, IL.LIT(Literal.Int 0)),  
                                   (one, IL.LIT(Literal.Int 1)),  
                                   (two, IL.LIT(Literal.Int 2)),  
                                   (m21, IL.OP(Op.TensorSub mat33, [use m, use two, use one])),  
                                   (m12, IL.OP(Op.TensorSub mat33, [use m, use one, use two])),  
                                   (lhs0, IL.OP(Op.Sub Ty.realTy, [use m21, use m12])),  
                                   (m02, IL.OP(Op.TensorSub mat33, [use m, use zero, use two])),  
                                   (m20, IL.OP(Op.TensorSub mat33, [use m, use two, use zero])),  
                                   (lhs1, IL.OP(Op.Sub Ty.realTy, [use m02, use m20])),  
                                   (m10, IL.OP(Op.TensorSub mat33, [use m, use one, use zero])),  
                                   (m01, IL.OP(Op.TensorSub mat33, [use m, use zero, use one])),  
                                   (lhs2, IL.OP(Op.Sub Ty.realTy, [use m10, use m01])),  
                                   (lhs, IL.CONS(Ty.TensorTy[3], [lhs0, lhs1, lhs2]))  
                                 ]  
                             end  
                         | _ => raise Fail(concat[  
                               "curl: bogus field binding ", V.toString f', " = ", IL.vbToString(V.binding f')  
                             ])  
                       (* end case *))  
                   | SOME(Op.DiffField, _) => NONE (* need further rewriting *)  
                   | _ => raise Fail(concat[  
                         "probe: bogus field binding ", V.toString f, " = ", IL.vbToString(V.binding f)  
                       ])  
                 (* end case *))  
             | (Op.DiffField, [f]) => (case (getRHS f)  
                  of SOME(Op.Field dim, [v, h]) => let  
                       val (kernel, k) = getKernelRHS h  
                       val h' = IL.Var.copy h  
                       in  
                         ST.tick cntDiffField;  
                         decUse f;  
                         incUse h'; incUse v;  
                         SOME[  
                             (h', IL.OP(Op.Kernel(kernel, k+1), [])),  
                             (lhs, IL.OP(Op.Field dim, [v, h']))  
                           ]  
                       end  
                   | SOME(Op.AddField, [f, g]) => raise Fail "Diff(f+g)"  
                   | SOME(Op.SubField, [f, g]) => raise Fail "Diff(f-g)"  
                   | SOME(Op.ScaleField, [s, f']) => let  
                     (* rewrite to s*(D f) *)  
                       val lhs' = IL.Var.copy lhs  
                       in  
                         ST.tick cntDiffScale;  
                         decUse f;  
                         SOME[  
                             (lhs', IL.OP(Op.DiffField, [use f'])),  
                             (lhs, IL.OP(Op.ScaleField, [use s, use lhs']))  
                           ]  
                       end  
                   | SOME(Op.OffsetField, [f', s]) => (  
                     (* rewrite to (D f) *)  
                       ST.tick cntDiffOffset;  
                       decUse f;  
                       SOME[(lhs, IL.OP(Op.DiffField, [use f']))])  
                   | SOME(Op.NegField, [f']) => let  
                     (* rewrite to -(D f') *)  
                       val lhs' = IL.Var.copy lhs  
                       in  
                         ST.tick cntDiffNeg;  
                         decUse f;  
                         incUse lhs'; incUse f';  
                         SOME[  
                             (lhs', IL.OP(Op.DiffField, [f'])),  
                             (lhs, IL.OP(Op.NegField, [lhs']))  
                           ]  
                       end  
                   | _ => NONE  
                 (* end case *))  
             | (Op.CurlField dim, [f]) => (case (getRHS f)  
                  of SOME(Op.AddField, [f, g]) => raise Fail "curl(f+g)"  
                   | SOME(Op.SubField, [f, g]) => raise Fail "curl(f-g)"  
                   | SOME(Op.ScaleField, [s, f']) => let  
                     (* rewrite to s*curl(f) *)  
                     val f'' = IL.Var.copy f'  
                     in  
                       ST.tick cntCurlScale;  
                       decUse f;  
                       SOME[  
                           (f'', IL.OP(Op.CurlField dim, [use f'])),  
                           (lhs, IL.OP(Op.ScaleField, [use s, use f'']))  
                         ]  
                     end  
                   | SOME(Op.NegField, [f']) => let  
                     (* rewrite to -curl(f) *)  
                     val f'' = IL.Var.copy f'  
                     in  
                       ST.tick cntCurlNeg;  
                       decUse f;  
                       SOME[  
                           (f'', IL.OP(Op.CurlField dim, [use f'])),  
                           (lhs, IL.OP(Op.NegField, [use f'']))  
                         ]  
                     end  
                 (* FIXME: the following is just the constant 0 field, but we don't have  
                  * a representation of constant fields  
                  *)  
                   | SOME(Op.DiffField, _) => raise Fail "curl of del"  
                   | _ => NONE  
                 (* end case *))  
84              | _ => NONE              | _ => NONE
85            (* end case *))            (* end case *))
86        | doRHS _ = NONE        | doRHS _ = NONE
87    
88    
89    (* (*deleted addfield, subfield, scalefield, negfield, curlfield, and difffield*)
90    -deleted probe field of Field, addfield, subfield, scalefield OffsetField, negfield, curl, diffield
91    -deleted diffield of field, addfield, subfield, scalefield, offsetfield
92    negfield
93    -deleted curlfield, ...
94    *)
95    
96    
97      structure Rewrite = RewriteFn (      structure Rewrite = RewriteFn (
98        struct        struct
99          structure IL = IL          structure IL = IL

Legend:
Removed from v.2399  
changed lines
  Added in v.2400

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