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

# SCM Repository

[diderot] View of /branches/vis15/src/compiler/high-opt/normalize.sml
 [diderot] / branches / vis15 / src / compiler / high-opt / normalize.sml

# View of /branches/vis15/src/compiler/high-opt/normalize.sml

Revision 3548 - (download) (annotate)
Tue Jan 5 20:38:39 2016 UTC (4 years ago) by jhr
File size: 3569 byte(s)
`working on merge`
```(* normalize.sml
*
* This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
*
* COPYRIGHT (c) 2015 The University of Chicago
* All rights reserved.
*)

structure Normalize : sig

val transform : HighIR.program -> HighIR.program

end = struct

structure IR = HighIR
structure Op = HighOps
structure V = IR.Var
structure ST = Stats

(********** Counters for statistics **********)
val cntUnused               = ST.newCounter "high-opt:unused"

structure UnusedElim = UnusedElimFn (
structure IR = IR
val cntUnused = cntUnused)

fun useCount (IR.V{useCnt, ...}) = !useCnt

(* adjust a variable's use count *)
fun incUse (IR.V{useCnt, ...}) = (useCnt := !useCnt + 1)
fun decUse (IR.V{useCnt, ...}) = (useCnt := !useCnt - 1)
fun use x = (incUse x; x)

fun isEin x = (case V.binding x
of IR.VB_RHS(rhs as IR.EINAPP(e, arg)) => SOME rhs
| IR.VB_RHS(IR.VAR x') => isEin x'
| _ => NONE
(* end case *))

(* doNormalize : EIN -> EIN
* Orders EIN, normalizes it, then cleans the summation
*)
fun doNormalize e = let
val ordered = Reorder.transform e
in
case NormalizeEin.transform ordered
of NONE => ordered
| SOME e => EinSums.clean e
(* end case *)
end

fun nameCnt e = String.concat[V.toString e, "(", Int.toString(useCount e), ")"]
fun nameCnts e = String.concatWithMap "" nameCnt e

(* rewriteEin : EIN.Params*int*int*EIN*HighIR Vars* rhs list* EIN  *HighIR Var
*	-> int*EIN*int*rhs list
* Orders EIN, normalizes it, then cleans the summation orig-original EIN
*)
fun rewriteEin (params, place, changed, newE, newArgs, done, newEinApp, orig, lhs) = (
case List.nth(params, place)
of Ein.TEN(false, _) => (changed, orig, place+1, done@[newEinApp])
| _ => let
val rtnArgs = done @ newArgs
val (c, subst) = Apply.apply(orig, place, newE)
in
if c
then (true, subst, place + length newArgs, rtnArgs)
else (
incUse lhs; List.app incUse newArgs; decUse newEinApp;
(true, subst, place + length newArgs, rtnArgs))
end
(* end case *))

(* doRHS: HighIR.var * rhs -> (var * rhs) list option
* Looks at each argument to the original EINAPP.
* If it is another EIN APP calls rewriteEin to do application
* "place"-The Param-id for the EIN operator.
* Keeps track of the place of the argument in substitution.
*)
fun doRHS (lhs, IR.EINAPP(ein, args)) = let
fun rewrite (false, _, _, [], _) = NONE
| rewrite (true, orig, _, [], args') =
SOME[(lhs, IR.EINAPP(doNormalize orig, args'))]
| rewrite (changed, orig, place, e::es, args') = (case isEin e
of NONE => rewrite(changed, orig, place+1, es, args'@[e])
| SOME(IR.EINAPP(newE, newA)) => let
val Ein.EIN{params, index, body} = orig
val (changed, e', place', done') =
rewriteEin (params, place, changed, newE, newA, args', e, orig, lhs)
in
rewrite(changed, e', place', es, done')
end
| _ => raise Fail "isEin did not work"
(* end case *))
in
rewrite (false, ein, 0, args, [])
end
| doRHS _ = NONE

structure Rewrite = RewriteFn (
struct
structure IR = IR
val doAssign = doRHS

fun doMAssign _ = NONE
val elimUnusedVars = UnusedElim.reduce
end)

val transform = Rewrite.transform

end
```

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