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

SCM Repository

[diderot] Diff of /branches/pure-cfg/src/compiler/c-target/c-target.sml
ViewVC logotype

Diff of /branches/pure-cfg/src/compiler/c-target/c-target.sml

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

revision 1215, Sat May 14 05:54:07 2011 UTC revision 1261, Sat May 28 23:16:30 2011 UTC
# Line 11  Line 11 
11      structure V = IL.Var      structure V = IL.Var
12      structure Ty = IL.Ty      structure Ty = IL.Ty
13      structure CL = CLang      structure CL = CLang
14      structure RN = RuntimeNames      structure N = TargetNames
15      structure ToC = TreeToC      structure ToC = TreeToC
16    
17      type var = ToC.var      type var = ToC.var
# Line 136  Line 136 
136      structure Program =      structure Program =
137        struct        struct
138          fun new {double, parallel, debug} = (          fun new {double, parallel, debug} = (
139                RN.initTargetSpec double;                N.initTargetSpec double;
140                Prog{                Prog{
141                    double = double, parallel = parallel, debug = debug,                    double = double, parallel = parallel, debug = debug,
142                    globals = ref [                    globals = ref [
# Line 150  Line 150 
150                    strands = AtomTable.mkTable (16, Fail "strand table"),                    strands = AtomTable.mkTable (16, Fail "strand table"),
151                    initially = ref(CL.D_Comment["missing initially"])                    initially = ref(CL.D_Comment["missing initially"])
152                  })                  })
153          (* register the code that is used to register command-line options for input variables *)
154            fun inputs (Prog{topDecls, ...}, stm) = let
155                  val inputsFn = CL.D_Func(
156                        [], CL.voidTy, N.registerOpts,
157                        [CL.PARAM([], CL.T_Ptr(CL.T_Named N.optionsTy), "opts")],
158                        stm)
159                  in
160                    topDecls := inputsFn :: !topDecls
161                  end
162        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
163          fun init (Prog{topDecls, ...}, init) = let          fun init (Prog{topDecls, ...}, init) = let
164                val initFn = CL.D_Func(                val initFn = CL.D_Func([], CL.voidTy, N.initGlobals, [], init)
                     [], CL.voidTy, RN.initGlobals, [  
                         CL.PARAM([], CL.intTy, "argc"),  
                         CL.PARAM(["const"], CL.T_Ptr(CL.charPtr), "argv")  
                       ],  
                     init)  
165                val shutdownFn = CL.D_Func(                val shutdownFn = CL.D_Func(
166                      [], CL.voidTy, RN.shutdown,                      [], CL.voidTy, N.shutdown,
167                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.worldTy), "wrld")],                      [CL.PARAM([], CL.T_Ptr(CL.T_Named N.worldTy), "wrld")],
168                      CL.S_Block[])                      CL.S_Block[])
169                in                in
170                  topDecls := shutdownFn :: initFn :: !topDecls                  topDecls := shutdownFn :: initFn :: !topDecls
# Line 177  Line 181 
181              } = let              } = let
182                val name = Atom.toString strand                val name = Atom.toString strand
183                val nDims = List.length iters                val nDims = List.length iters
184                val worldTy = CL.T_Ptr(CL.T_Named RN.worldTy)                val worldTy = CL.T_Ptr(CL.T_Named N.worldTy)
185                fun mapi f xs = let                fun mapi f xs = let
186                      fun mapf (_, []) = []                      fun mapf (_, []) = []
187                        | mapf (i, x::xs) = f(i, x) :: mapf(i+1, xs)                        | mapf (i, x::xs) = f(i, x) :: mapf(i+1, xs)
# Line 194  Line 198 
198                        CL.mkDecl(CL.T_Array(CL.int32, SOME nDims), "base", SOME(CL.I_Array baseInit)),                        CL.mkDecl(CL.T_Array(CL.int32, SOME nDims), "base", SOME(CL.I_Array baseInit)),
199                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "size", SOME(CL.I_Array sizeInit)),                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "size", SOME(CL.I_Array sizeInit)),
200                        CL.mkDecl(worldTy, "wrld",                        CL.mkDecl(worldTy, "wrld",
201                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [                          SOME(CL.I_Exp(CL.E_Apply(N.allocInitially, [
202                              CL.mkUnOp(CL.%&, CL.E_Var(RN.strandDesc name)),                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),
203                              CL.E_Bool isArray,                              CL.E_Bool isArray,
204                              CL.E_Int(IntInf.fromInt nDims, CL.int32),                              CL.E_Int(IntInf.fromInt nDims, CL.int32),
205                              CL.E_Var "base",                              CL.E_Var "base",
# Line 204  Line 208 
208                      ]                      ]
209              (* create the loop nest for the initially iterations *)              (* create the loop nest for the initially iterations *)
210                val indexVar = "ix"                val indexVar = "ix"
211                val strandTy = CL.T_Ptr(CL.T_Named(RN.strandTy name))                val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))
212                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [
213                        CL.mkDecl(strandTy, "sp",                        CL.mkDecl(strandTy, "sp",
214                          SOME(CL.I_Exp(                          SOME(CL.I_Exp(
215                            CL.E_Cast(strandTy,                            CL.E_Cast(strandTy,
216                            CL.E_Apply(RN.inState, [CL.E_Var "wrld", CL.E_Var indexVar]))))),                            CL.E_Apply(N.inState, [CL.E_Var "wrld", CL.E_Var indexVar]))))),
217                        CL.mkCall(RN.strandInit name, CL.E_Var "sp" :: args),                        CL.mkCall(N.strandInit name, CL.E_Var "sp" :: args),
218                        CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))                        CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))
219                      ])                      ])
220                  | mkLoopNest ((ToC.V(ty, param), lo, hi)::iters) = let                  | mkLoopNest ((ToC.V(ty, param), lo, hi)::iters) = let
# Line 228  Line 232 
232                        mkLoopNest iters                        mkLoopNest iters
233                      ]                      ]
234                val body = CL.mkBlock(iterPrefix @ allocCode @ iterCode @ [CL.mkReturn(SOME(CL.E_Var "wrld"))])                val body = CL.mkBlock(iterPrefix @ allocCode @ iterCode @ [CL.mkReturn(SOME(CL.E_Var "wrld"))])
235                val initFn = CL.D_Func([], worldTy, RN.initially, [], body)                val initFn = CL.D_Func([], worldTy, N.initially, [], body)
236                in                in
237                  initially := initFn                  initially := initFn
238                end                end
# Line 249  Line 253 
253                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
254                      val outState = CL.mkIndirect(CL.mkVar "self", x)                      val outState = CL.mkIndirect(CL.mkVar "self", x)
255                      val prArgs = (case ty                      val prArgs = (case ty
256                             of Ty.IVecTy 1 => [CL.E_Str(!RN.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]
257                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
258                                  val fmt = CL.E_Str(                                  val fmt = CL.E_Str(
259                                        String.concatWith " " (List.tabulate(d, fn _ => !RN.gIntFormat))                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))
260                                        ^ "\n")                                        ^ "\n")
261                                  val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))                                  val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))
262                                  in                                  in
# Line 279  Line 283 
283                      in                      in
284                        CL.I_Struct[                        CL.I_Struct[
285                            ("name", CL.I_Exp(CL.E_Str name)),                            ("name", CL.I_Exp(CL.E_Str name)),
286                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(N.strandTy name)))),
287                            ("update", fnPtr("update_method_t", name ^ "_update")),                            ("update", fnPtr("update_method_t", name ^ "_update")),
288                            ("print", fnPtr("print_method_t", prFnName))                            ("print", fnPtr("print_method_t", prFnName))
289                          ]                          ]
290                      end                      end
291                val desc = CL.D_Var([], CL.T_Named RN.strandDescTy, RN.strandDesc name, SOME descI)                val desc = CL.D_Var([], CL.T_Named N.strandDescTy, N.strandDesc name, SOME descI)
292                in                in
293                  selfTyDef :: List.rev (desc :: prFn :: !code)                  selfTyDef :: List.rev (desc :: prFn :: !code)
294                end                end
# Line 292  Line 296 
296        (* generate the table of strand descriptors *)        (* generate the table of strand descriptors *)
297          fun genStrandTable (ppStrm, strands) = let          fun genStrandTable (ppStrm, strands) = let
298                val nStrands = length strands                val nStrands = length strands
299                fun genInit (Strand{name, ...}) = CL.I_Exp(CL.mkUnOp(CL.%&, CL.E_Var(RN.strandDesc name)))                fun genInit (Strand{name, ...}) = CL.I_Exp(CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)))
300                fun genInits (_, []) = []                fun genInits (_, []) = []
301                  | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)                  | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)
302                fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)                fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)
303                in                in
304                  ppDecl (CL.D_Var([], CL.int32, RN.numStrands,                  ppDecl (CL.D_Var([], CL.int32, N.numStrands,
305                    SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nStrands, CL.int32)))));                    SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nStrands, CL.int32)))));
306                  ppDecl (CL.D_Var([],                  ppDecl (CL.D_Var([],
307                    CL.T_Array(CL.T_Ptr(CL.T_Named RN.strandDescTy), SOME nStrands),                    CL.T_Array(CL.T_Ptr(CL.T_Named N.strandDescTy), SOME nStrands),
308                    RN.strands,                    N.strands,
309                    SOME(CL.I_Array(genInits (0, strands)))))                    SOME(CL.I_Array(genInits (0, strands)))))
310                end                end
311    
# Line 357  Line 361 
361                val name = Atom.toString strandId                val name = Atom.toString strandId
362                val strand = Strand{                val strand = Strand{
363                        name = name,                        name = name,
364                        tyName = RN.strandTy name,                        tyName = N.strandTy name,
365                        state = ref [],                        state = ref [],
366                        output = ref NONE,                        output = ref NONE,
367                        code = ref []                        code = ref []
# Line 374  Line 378 
378         * parameters.         * parameters.
379         *)         *)
380          fun init (Strand{name, tyName, code, ...}, params, init) = let          fun init (Strand{name, tyName, code, ...}, params, init) = let
381                val fName = RN.strandInit name                val fName = N.strandInit name
382                val params =                val params =
383                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
384                        List.map (fn (ToC.V(ty, x)) => CL.PARAM([], ty, x)) params                        List.map (fn (ToC.V(ty, x)) => CL.PARAM([], ty, x)) params

Legend:
Removed from v.1215  
changed lines
  Added in v.1261

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