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

SCM Repository

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

Annotation of /branches/charisee/src/compiler/codegen/codegen-fn.sml

Parent Directory Parent Directory | Revision Log Revision Log


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

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