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

SCM Repository

[diderot] Annotation of /trunk/src/compiler/codegen/codegen-fn.sml
ViewVC logotype

Annotation of /trunk/src/compiler/codegen/codegen-fn.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1301 - (view) (download)

1 : jhr 454 (* codegen-fn.sml
2 :     *
3 : jhr 1116 * COPYRIGHT (c) 2011 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 : jhr 454 * All rights reserved.
5 : jhr 455 *
6 : jhr 1116 * Generic support for translating LowIL code to the target representation.
7 :     *
8 :     * FIXME:
9 : jhr 1301 * We need to run the TreeIL through a splitting pass to match the target's vector widths.
10 : jhr 454 *)
11 :    
12 :     functor CodeGenFn (T : TARGET) : sig
13 :    
14 : jhr 1232 val generate : {
15 : jhr 1301 basename : string,
16 :     double : bool,
17 :     parallel : bool,
18 :     debug : bool,
19 :     prog : LowIL.program
20 :     } -> unit
21 : jhr 454
22 :     end = struct
23 :    
24 : jhr 1116 structure IL = TreeIL
25 : jhr 454
26 : jhr 1116 structure LowToTree = LowToTreeFn(T)
27 : jhr 456
28 : jhr 1116 fun trMethod (strand, stateVars, env) = let
29 : jhr 1301 val varyingStateVars = List.mapPartial
30 :     (fn (IL.SV{varying = true, var, ...}) => SOME var | _ => NONE)
31 :     stateVars
32 :     val env = T.Env.scopeMethod (env, varyingStateVars)
33 :     fun tr (IL.Method{name, body}) = let
34 :     val body = T.Tr.block (env, body)
35 :     in
36 :     T.Strand.method (strand, Atom.toString name, body)
37 :     end
38 :     in
39 :     tr
40 :     end
41 : jhr 456
42 : jhr 1116 fun trStrand (prog, env) (IL.Strand{name, params, state, stateInit, methods}) = let
43 : jhr 1301 val strand = T.Strand.define(prog, name)
44 :     val env = T.Env.scopeStrand (env, List.map (fn (IL.SV{var, ...}) => var) state)
45 :     (* the output state variable *)
46 :     val outputVar = ref NONE
47 :     (* map the state variables to target state variables and extend the environment *)
48 :     val env = let
49 :     fun cvtSVar (IL.SV{output, var=x, ...}, env) = let
50 :     val x' = T.Var.state(strand, x)
51 :     in
52 :     case (output, !outputVar)
53 :     of (true, NONE) => outputVar := SOME(IL.Var.ty x, x')
54 :     | (false, _) => ()
55 :     | _ => raise Fail("multiple outputs in " ^ Atom.toString name)
56 :     (* end case *);
57 :     T.Env.bind(env, x, x')
58 :     end
59 :     in
60 :     (* note that we folr right-to-left to get the order of state variables in the
61 :     * target strand in the right order.
62 :     *)
63 :     List.foldr cvtSVar env state
64 :     end
65 :     (* define the parameters and add them to the environment *)
66 :     val params' = List.map T.Var.param params
67 :     val env = ListPair.foldlEq (fn (x, y, env) => T.Env.bind(env, x, y)) env (params, params')
68 :     in
69 :     T.Strand.init (strand, params', T.Tr.block (env, stateInit));
70 :     case !outputVar
71 :     of NONE => raise Fail("no output specified for strand " ^ Atom.toString name)
72 :     | SOME(ty, x) => T.Strand.output (strand, ty, x)
73 :     (* end case *);
74 :     List.app (trMethod (strand, state, env)) methods
75 :     end
76 : jhr 454
77 : jhr 1232 fun trInitially (env, prog, {isArray, iterPrefix, iters, createPrefix, strand, args}) = let
78 : jhr 1301 val env = T.Env.scopeInitially env
79 :     val (env, iterPrefix) = T.Tr.fragment (env, iterPrefix)
80 :     fun trIter ((param, lo, hi), (env, iters)) = let
81 :     val param' = T.Var.param param
82 :     val env = T.Env.bind (env, param, param')
83 :     val iter = (param', T.Tr.exp (env, lo), T.Tr.exp (env, hi))
84 :     in
85 :     (env, iter::iters)
86 :     end
87 :     val (env, iters) = List.foldr trIter (env, []) iters
88 :     val (env, createPrefix) = T.Tr.fragment (env, createPrefix)
89 :     in
90 :     T.Program.initially {
91 :     prog = prog,
92 :     isArray = isArray,
93 :     iterPrefix = iterPrefix,
94 :     iters = iters,
95 :     createPrefix = createPrefix,
96 :     strand = strand,
97 :     args = List.map (fn e => T.Tr.exp(env, e)) args
98 :     }
99 :     end
100 : jhr 455
101 : jhr 1232 fun generate {basename, double, parallel, debug, prog=srcProg} = let
102 : jhr 1301 val treeProg as TreeIL.Program{props, globals, inputInit, globalInit, strands, initially} =
103 :     PhaseTimer.withTimer Timers.timeLowToTree LowToTree.translate srcProg
104 : jhr 1116 val _ = (
105 :     TextIO.output(Log.logFile(), "********** After translation to TreeIL **********\n");
106 :     TreeILPP.program (Log.logFile(), treeProg))
107 : jhr 1301 val prog = T.Program.new {
108 :     name = basename,
109 :     double = double,
110 :     parallel = parallel,
111 :     debug = debug
112 :     }
113 :     val env = T.Env.new prog
114 :     (* define the globals and initialize the environment *)
115 :     val env = let
116 :     (* produce a list of target variables for the globals, such that each global
117 :     * has a unique name.
118 :     *)
119 :     fun genName (x, (cnt, globs)) = let
120 :     val name = IL.Var.name x
121 :     fun uniqueName (name, cnt) =
122 :     if List.exists (fn (_, y) => (name = T.Var.name y)) globs
123 :     then uniqueName(name ^ Int.toString cnt, cnt+1)
124 :     else (name, cnt)
125 :     val (name, cnt) = uniqueName (IL.Var.name x, cnt)
126 :     in
127 :     (cnt, (x, T.Var.global(prog, name, IL.Var.ty x))::globs)
128 :     end
129 :     val (_, globs) = List.foldl genName (0, []) globals
130 :     fun gvar ((x, x'), env) = T.Env.bind(env, x, x')
131 :     in
132 :     List.foldl gvar (T.Env.scopeGlobal env) globs
133 :     end
134 :     in
135 :     T.Program.inputs (prog, T.Tr.block (T.Env.scopeGlobal env, inputInit));
136 :     (* global initialization *)
137 :     T.Program.init (prog, T.Tr.block (T.Env.scopeGlobal env, globalInit));
138 :     (* translate strands *)
139 :     List.app (trStrand (prog, env)) strands;
140 :     (* generate the initially function *)
141 :     trInitially (env, prog, initially);
142 :     (* output the program *)
143 :     T.Program.generate (basename, prog)
144 :     end
145 : jhr 455
146 : jhr 454 end

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