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

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/translate/translate.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/translate/translate.sml

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

revision 3504, Thu Dec 17 23:56:09 2015 UTC revision 3505, Fri Dec 18 02:47:03 2015 UTC
# Line 376  Line 376 
376                      (* For any local variable y that is both live on exit of the block b and                      (* For any local variable y that is both live on exit of the block b and
377                       * assigned to in b, we will need a phi node for y.                       * assigned to in b, we will need a phi node for y.
378                       *)                       *)
379                        val phiVars = VSet.intersect(AnalizeSimple.assignedVars b, AnalizeSimple.liveOut b)                        val phiVars = VSet.listItems(
380                                VSet.intersection(AnalyzeSimple.assignedVars b, AnalyzeSimple.liveOut b))
381                        val join as JOIN{env, nd=foreachNd, ...} = newForeach (env, x', xs', phiVars)                        val join as JOIN{env, nd=foreachNd, ...} = newForeach (env, x', xs', phiVars)
382                        val (body, _) = cvtBlock (state, env, (1, join)::joinStk, b)                        val (body, _) = cvtBlock (state, env, (1, join)::joinStk, b)
383                        val env = commitJoin (joinStk, join)                        val env = commitJoin (joinStk, join)
# Line 413  Line 414 
414                        in                        in
415                          cvt (env, IR.CFG.appendNode (cfg, nd), stms)                          cvt (env, IR.CFG.appendNode (cfg, nd), stms)
416                        end                        end
417                    | S.S_MapReduce{results, reductions, body, args, source} => ??                    | S.S_MapReduce{results, reductions, body, args, source} => raise Fail "FIXME"
418                  (* end case *))                  (* end case *))
419            in            in
420              cvt (env, IR.CFG.empty, stms)              cvt (env, IR.CFG.empty, code)
421            end            end
422  (*DEBUG*)handle ex => raise ex  (*DEBUG*)handle ex => raise ex
423    
424      fun cvtMethod (loadGlobals, env, name, state, svars, blk) = let      fun cvtMethod (loadGlobals, env, isStabilize, state, svars, blk) = let
425          (* load the globals into fresh variables *)          (* load the globals into fresh variables *)
426            val (loadGlobsCFG, env) = loadGlobals env            val (loadGlobsCFG, env) = loadGlobals env
427          (* load the state into fresh variables *)          (* load the state into fresh variables *)
# Line 437  Line 438 
438          (* add the entry/exit nodes *)          (* add the entry/exit nodes *)
439            val entry = IR.Node.mkENTRY ()            val entry = IR.Node.mkENTRY ()
440            val loadCFG = IR.CFG.prependNode (entry, loadCFG)            val loadCFG = IR.CFG.prependNode (entry, loadCFG)
441            val exit = (case name            val exit = if isStabilize
442                   of StrandUtil.Initially => IR.Node.mkACTIVE ()                  then IR.Node.mkRETURN()
443                    | StrandUtil.Update => IR.Node.mkACTIVE ()                  else IR.Node.mkACTIVE()
                   | StrandUtil.Stabilize => IR.Node.mkRETURN []  
                 (* end case *))  
444            val body = IR.CFG.concat (loadCFG, cfg)            val body = IR.CFG.concat (loadCFG, cfg)
445  (*DEBUG**val _ = prEnv (StrandUtil.nameToString name, env);*)  (*DEBUG**val _ = prEnv (StrandUtil.nameToString name, env);*)
446  (* FIXME: the following code doesn't work properly *)  (* FIXME: the following code doesn't work properly *)
# Line 449  Line 448 
448                  then IR.CFG.concat (body, saveStrandState (env, (state, svars), exit))                  then IR.CFG.concat (body, saveStrandState (env, (state, svars), exit))
449                  else IR.CFG{entry = IR.CFG.entry body, exit = exit}                  else IR.CFG{entry = IR.CFG.entry body, exit = exit}
450            in            in
451              IR.Method{              body
                 name = name,  
                 body = body  
               }  
452            end            end
453  (*DEBUG*)handle ex => (print(concat["error in cvtMethod(", StrandUtil.nameToString name, ", ...)\n"]); raise ex)  (*DEBUG*)handle ex => (print "error in cvtMethod\n"; raise ex)
   
   (* convert the initial strand creation code *)  
     fun cvtCreate (loadGlobals, S.Create{dim, code}) = let  
         (* load the globals into fresh variables *)  
           val (loadCFG, env) = loadGlobals VMap.empty  
         (* convert the code *)  
           val (cfg, _) = cvtBlock (([], []), env, [], code)  
           in  
             IR.Initially{  
                 isArray = isArray,  
                 rangeInit = cfg,  
                 iters = List.rev iters,  
                 create = (argInitCFG, name, List.map (lookup env) args)  
               }  
           end  
 (*DEBUG*)handle ex => raise ex  
454    
455    (* a function for generating a block of assignments to load globals *)    (* a function for generating a block of assignments to load globals *)
456      fun loadGlobs globs env = let      fun loadGlobs globs env = let
# Line 486  Line 466 
466              load (env, globs, [])              load (env, globs, [])
467            end            end
468    
469      fun cvtInputs (inputInit, inputs) = let    (* convert the Simple AST inputs to CFG inputs *)
470            val (initBlk, env) = cvtBlock (([], []), VMap.empty, [], inputInit)      fun cvtInputs (env, inputs) = let
471            fun cvt (S.INP{var, desc, init}, (gvs, stms)) = let            fun cvt (Inputs.INP{var, name, desc, init}, (env, inps)) = let
472                  val name = SV.nameOf var                  val var' = IR.GlobalVar.new(true, name, cvtTy(SV.typeOf var))
473                  val var' = newVar var                  val inp' = Inputs.INP{var = var', name = name, desc = desc, init = init}
                 val ty' = IR.Var.ty var'  
                 val gVar = IR.GlobalVar.new(true, name, ty')  
                 val rhs = (case init  
                        of S.NoDefault =>  
                             Op.Input(Inp.INP{ty = ty', name = name, desc = desc, init = NONE})  
                         | S.ConstExpr => ??  
                         | S.LoadSeq nrrd => ??  
                         | S.Proxy(nrrd, info) => ??  
                         | S.Image info =>  
                             Op.InputWithDefault(Inp.INP{  
                             })  
                       (* end case *))  
                 val stms = IR.ASSGN(var', rhs) :: IR.GASSGN(gVar, var') :: stms  
474                  in                  in
475                    ((var, gVar)::gvs, stms)                    (VMap.insert(env, var, var'), inp' :: inps)
476                  end                  end
           fun cvt ((x, inp), (gvs, stms)) = let  
                 val x' = newVar x  
                 val gx = IR.GlobalVar.new(  
                         true,  
                         SV.nameOf x,  
                         cvtTy(SV.typeOf x))  
                 val rhs = (case VMap.find(env, x)  
                        of SOME dflt => IR.OP(Op.InputWithDefault(Inputs.map cvtTy inp), [dflt])  
                         | NONE => IR.OP(Op.Input(Inputs.map cvtTy inp), [])  
                       (* end case *))  
                 val stms =  IR.ASSGN(x', rhs) :: IR.GASSGN(gx, x') :: stms  
                 in  
                   ((x, gx)::gvs, stms)  
                 end  
           val (gvs, stms) = List.foldr cvt ([], []) inputs  
           val cfg = IR.CFG.appendBlock (initBlk, stms)  
           val cfg = IR.CFG.prependNode (IR.Node.mkENTRY(), cfg)  
           val cfg = IR.CFG.appendNode (cfg, IR.Node.mkRETURN [])  
477            in            in
478              (cfg, gvs)              List.foldr cvt (env, []) inputs
479            end            end
480    
481    (* convert Simple globals to HighIR globals and return a function that generates    (* convert Simple globals to HighIR globals and return a function that generates
# Line 545  Line 494 
494              List.map cvt globals              List.map cvt globals
495            end            end
496    
497      (* convert the initial strand creation code *)
498        fun cvtCreate (loadGlobals, S.Create{dim, code}) = let
499            (* load the globals into fresh variables *)
500              val (loadCFG, env) = loadGlobals VMap.empty
501            (* convert the code *)
502              val (cfg, _) = cvtBlock (([], []), env, [], code)
503              in
504                IR.Create{dim = dim, code = IR.CFG.concat (loadCFG, cfg)}
505              end
506    (*DEBUG*)handle ex => raise ex
507    
508      fun translate prog = let      fun translate prog = let
509            val S.Program{            val S.Program{
510                    props, consts, inputs, constInit, globals, funcs, init, strand, create, update                    props, consts, inputs, constInit, globals, funcs, init, strand, create, update
511                  } = prog                  } = prog
512            val (inputInit, inputGlobs) = cvtInputs (inputDefaults, inputs)            val (env, consts) = ?? (* FIXME *)
513              val (env, inputs) = cvtInputs (env, inputs)
514              val inputGlobs = List.map Inputs.varOf inputs
515    (* FIXME: constInit *)
516            val globals = cvtGlobals globals            val globals = cvtGlobals globals
517          (* create the global initialization code *)          (* create the global initialization code *)
518            val globalInit = let            val globalInit = let
519                (* we start by loading the input globals, since they may be needed to compute the                (* we start by loading the input globals, since they may be needed to compute the
520                 * other globals                 * other globals
521                 *)                 *)
522                  val (cfg, env) = loadGlobs inputGlobs VMap.empty                  val (cfg, env) = loadGlobs (consts @ inputGlobs) VMap.empty
523                  val (globBlk, env) = cvtBlock (([], []), env, [], globalInit)                  val (globBlk, env) = cvtBlock (([], []), env, [], init)
524                (* build a sequence of statements for initializing the IR globals *)                (* build a sequence of statements for initializing the IR globals *)
525                  val saveGlobsBlk = let                  val saveGlobsBlk = let
526                        fun saveGlob (x, gx) = let                        fun saveGlob (x, gx) = let
# Line 571  Line 534 
534                  val cfg = IR.CFG.prependNode (IR.Node.mkENTRY(), cfg)                  val cfg = IR.CFG.prependNode (IR.Node.mkENTRY(), cfg)
535                  val cfg = IR.CFG.concat(cfg, globBlk)                  val cfg = IR.CFG.concat(cfg, globBlk)
536                  val cfg = IR.CFG.concat(cfg, saveGlobsBlk)                  val cfg = IR.CFG.concat(cfg, saveGlobsBlk)
537                  val cfg = IR.CFG.appendNode (cfg, IR.Node.mkRETURN [])                  val cfg = IR.CFG.appendNode (cfg, IR.Node.mkRETURN())
538                  in                  in
539                    cfg                    cfg
540                  end                  end
541            val loadGlobals = loadGlobs (inputGlobs @ globals)            val globals = List.map #2 globals
542            val init = cvtInitially (loadGlobals, init)            val loadGlobals = loadGlobs (consts @ inputGlobs @ globals)
543            fun cvtStrand (S.Strand{name, params, state, stateInit, methods}) = let            val create = cvtCreate (loadGlobals, create)
544              fun cvtStrand (S.Strand{name, params, state, stateInit, initM, updateM, stabilizeM}) = let
545                (* extend the global environment with the strand's parameters *)                (* extend the global environment with the strand's parameters *)
546                  val (env, params) = let                  val (env, params) = let
547                        fun cvtParam (x, (env, xs)) = let                        fun cvtParam (x, (env, xs)) = let
# Line 605  Line 569 
569                        val cfg = IR.CFG.concat(loadGlobsCFG, cfg)                        val cfg = IR.CFG.concat(loadGlobsCFG, cfg)
570                        val cfg = IR.CFG.prependNode (IR.Node.mkENTRY(), cfg)                        val cfg = IR.CFG.prependNode (IR.Node.mkENTRY(), cfg)
571                        val cfg = IR.CFG.concat (cfg,                        val cfg = IR.CFG.concat (cfg,
572                              saveStrandState (env, (state, svars), IR.Node.mkSINIT()))                              saveStrandState (env, (state, svars), IR.Node.mkRETURN()))
573                        in                        in
574                          (cfg, env)                          (cfg, env)
575                        end                        end
576                  fun cvtMeth (S.Method(name, blk)) =                  fun cvtMeth isStabilize blk =
577                        cvtMethod (loadGlobals, env, name, state, svars, blk)                        cvtMethod (loadGlobals, env, isStabilize, state, svars, blk)
578                  in                  in
579                    IR.Strand{                    IR.Strand{
580                        name = name,                        name = name,
581                        params = params,                        params = params,
582                        state = svars,                        state = svars,
583                        stateInit = stateInit,                        stateInit = stateInit,
584                        methods = List.map cvtMeth methods                        initM = Option.map (cvtMeth false) initM,
585                          updateM = cvtMeth false updateM,
586                          stabilizeM = Option.map (cvtMeth true) stabilizeM
587                      }                      }
588                  end                  end
589            val prog = IR.Program{            val prog = IR.Program{
590                    props = props,                    props = props,
591                    globals = List.map #2 (inputGlobs @ globals),                    consts = consts,
592                    inputInit = inputInit,                    inputs = inputs,
593    (* QUESTION: should the globals include the consts and inputs too? *)
594                      globals = globals,
595                      constInit = ??,
596                    globalInit = globalInit,                    globalInit = globalInit,
597                    initially = init,                    strand = cvtStrand strand,
598                    strands = List.map cvtStrand strands                    create = create,
599                      update = ??
600                  }                  }
601            in            in
602              Census.init prog;              Census.init prog;

Legend:
Removed from v.3504  
changed lines
  Added in v.3505

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