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 1640 - (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 1640 val targetSupportsPrinting = ref T.supportsPrinting
27 : jhr 456
28 : jhr 1640 local
29 :     structure TargetInfo =
30 :     struct
31 :     fun supportsPrinting () = !targetSupportsPrinting
32 :     val inlineCons = T.inlineCons
33 :     val inlineMatrixExp = T.inlineMatrixExp
34 :     end
35 :     in
36 :     structure LowToTree = LowToTreeFn(TargetInfo)
37 :     end
38 :    
39 : jhr 1116 fun trMethod (strand, stateVars, env) = let
40 : jhr 1301 fun tr (IL.Method{name, body}) = let
41 : jhr 1640 val env = T.Env.scopeMethod (env, name)
42 : jhr 1301 val body = T.Tr.block (env, body)
43 :     in
44 : jhr 1444 T.Strand.method (strand, name, body)
45 : jhr 1301 end
46 :     in
47 :     tr
48 :     end
49 : jhr 456
50 : jhr 1116 fun trStrand (prog, env) (IL.Strand{name, params, state, stateInit, methods}) = let
51 : jhr 1640 val strand = T.Strand.define(prog, name, state)
52 :     val env = T.Env.scopeStrand env
53 : jhr 1301 (* define the parameters and add them to the environment *)
54 :     val params' = List.map T.Var.param params
55 :     val env = ListPair.foldlEq (fn (x, y, env) => T.Env.bind(env, x, y)) env (params, params')
56 :     in
57 :     T.Strand.init (strand, params', T.Tr.block (env, stateInit));
58 :     List.app (trMethod (strand, state, env)) methods
59 :     end
60 : jhr 454
61 : jhr 1232 fun trInitially (env, prog, {isArray, iterPrefix, iters, createPrefix, strand, args}) = let
62 : jhr 1301 val env = T.Env.scopeInitially env
63 :     val (env, iterPrefix) = T.Tr.fragment (env, iterPrefix)
64 :     fun trIter ((param, lo, hi), (env, iters)) = let
65 :     val param' = T.Var.param param
66 :     val env = T.Env.bind (env, param, param')
67 :     val iter = (param', T.Tr.exp (env, lo), T.Tr.exp (env, hi))
68 :     in
69 :     (env, iter::iters)
70 :     end
71 :     val (env, iters) = List.foldr trIter (env, []) iters
72 :     val (env, createPrefix) = T.Tr.fragment (env, createPrefix)
73 :     in
74 :     T.Program.initially {
75 :     prog = prog,
76 :     isArray = isArray,
77 :     iterPrefix = iterPrefix,
78 :     iters = iters,
79 :     createPrefix = createPrefix,
80 :     strand = strand,
81 :     args = List.map (fn e => T.Tr.exp(env, e)) args
82 :     }
83 :     end
84 : jhr 455
85 : jhr 1232 fun generate {basename, double, parallel, debug, prog=srcProg} = let
86 : jhr 1640 val _ = if parallel then targetSupportsPrinting := false else ()
87 : jhr 1301 val treeProg as TreeIL.Program{props, globals, inputInit, globalInit, strands, initially} =
88 :     PhaseTimer.withTimer Timers.timeLowToTree LowToTree.translate srcProg
89 : jhr 1116 val _ = (
90 :     TextIO.output(Log.logFile(), "********** After translation to TreeIL **********\n");
91 :     TreeILPP.program (Log.logFile(), treeProg))
92 : jhr 1301 val prog = T.Program.new {
93 :     name = basename,
94 :     double = double,
95 :     parallel = parallel,
96 :     debug = debug
97 :     }
98 :     val env = T.Env.new prog
99 :     (* define the globals and initialize the environment *)
100 :     val env = let
101 :     (* produce a list of target variables for the globals, such that each global
102 :     * has a unique name.
103 :     *)
104 :     fun genName (x, (cnt, globs)) = let
105 :     val name = IL.Var.name x
106 :     fun uniqueName (name, cnt) =
107 :     if List.exists (fn (_, y) => (name = T.Var.name y)) globs
108 :     then uniqueName(name ^ Int.toString cnt, cnt+1)
109 :     else (name, cnt)
110 :     val (name, cnt) = uniqueName (IL.Var.name x, cnt)
111 :     in
112 :     (cnt, (x, T.Var.global(prog, name, IL.Var.ty x))::globs)
113 :     end
114 :     val (_, globs) = List.foldl genName (0, []) globals
115 :     fun gvar ((x, x'), env) = T.Env.bind(env, x, x')
116 :     in
117 :     List.foldl gvar (T.Env.scopeGlobal env) globs
118 :     end
119 :     in
120 :     T.Program.inputs (prog, T.Tr.block (T.Env.scopeGlobal env, inputInit));
121 :     (* global initialization *)
122 :     T.Program.init (prog, T.Tr.block (T.Env.scopeGlobal env, globalInit));
123 :     (* translate strands *)
124 :     List.app (trStrand (prog, env)) strands;
125 :     (* generate the initially function *)
126 :     trInitially (env, prog, initially);
127 :     (* output the program *)
128 :     T.Program.generate (basename, prog)
129 :     end
130 : jhr 455
131 : jhr 454 end

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