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

SCM Repository

[diderot] Annotation of /branches/pure-cfg/src/compiler/codegen/codegen-fn.sml
ViewVC logotype

Annotation of /branches/pure-cfg/src/compiler/codegen/codegen-fn.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3349 - (view) (download)

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

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