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

SCM Repository

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

Diff of /branches/vis12/src/compiler/c-target/c-target.sml

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

revision 1717, Sat Mar 10 19:44:29 2012 UTC revision 1718, Sat Mar 10 23:03:02 2012 UTC
# Line 183  Line 183 
183                end                end
184        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
185          fun init (Prog{topDecls, ...}, init) = let          fun init (Prog{topDecls, ...}, init) = let
186                val initFn = CL.D_Func([], CL.voidTy, N.initGlobals, [], init)                val initFn = CL.D_Func(["static"], CL.voidTy, N.initGlobals, [], init)
               val shutdownFn = CL.D_Func(  
                     [], CL.voidTy, N.shutdown,  
                     [CL.PARAM([], CL.T_Ptr(CL.T_Named N.worldTy), "wrld")],  
                     CL.S_Block[])  
187                in                in
188                  topDecls := shutdownFn :: initFn :: !topDecls                  topDecls := initFn :: !topDecls
189                end                end
190        (* create and register the initially function for a program *)        (* create and register the initially function for a program *)
191          fun initially {          fun initially {
192                prog = Prog{strands, nAxes, initially, ...},                prog = Prog{tgt, strands, nAxes, initially, ...},
193                isArray : bool,                isArray : bool,
194                iterPrefix : stm list,                iterPrefix : stm list,
195                iters : (var * exp * exp) list,                iters : (var * exp * exp) list,
# Line 203  Line 199 
199              } = let              } = let
200                val name = Atom.toString strand                val name = Atom.toString strand
201                val nDims = List.length iters                val nDims = List.length iters
202                val worldTy = CL.T_Ptr(CL.T_Named N.worldTy)                val worldTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))
203                fun mapi f xs = let                fun mapi f xs = let
204                      fun mapf (_, []) = []                      fun mapf (_, []) = []
205                        | mapf (i, x::xs) = f(i, x) :: mapf(i+1, xs)                        | mapf (i, x::xs) = f(i, x) :: mapf(i+1, xs)
# Line 219  Line 215 
215                val wrld = "wrld"                val wrld = "wrld"
216                val allocCode = [                val allocCode = [
217                        CL.mkComment["allocate initial block of strands"],                        CL.mkComment["allocate initial block of strands"],
218                        CL.mkDecl(CL.T_Array(CL.int32, SOME nDims), "base", SOME(CL.I_Array baseInit)),                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "base", SOME(CL.I_Array baseInit)),
219                        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)),
220                        CL.mkDecl(worldTy, wrld,                        CL.mkIfThen(CL.mkApply(N.allocInitially, [
221                          SOME(CL.I_Exp(CL.E_Apply(N.allocInitially, [                            CL.mkVar "wrld",
                             CL.mkVar "ProgramName",  
                             CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),  
222                              CL.E_Bool isArray,                              CL.E_Bool isArray,
223                              CL.E_Int(IntInf.fromInt nDims, CL.int32),                              CL.E_Int(IntInf.fromInt nDims, CL.int32),
224                              CL.E_Var "base",                              CL.E_Var "base",
225                              CL.E_Var "size"                              CL.E_Var "size"
226                            ]))))                          ]),
227                          (* then *)
228                            CL.mkBlock [
229    (* FIXME: anything else? *)
230                                CL.mkReturn(SOME(CL.mkVar "true"))
231                              ])
232                          (* endif *)
233                      ]                      ]
234              (* create the loop nest for the initially iterations *)              (* create the loop nest for the initially iterations *)
235                val indexVar = "ix"                val indexVar = "ix"
236                val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))                val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))
237                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [
238                        CL.mkDecl(strandTy, "sp",                        CL.mkCall(N.strandInit name,
239                          SOME(CL.I_Exp(                          CL.mkSubscript(CL.mkIndirect(CL.mkVar "wrld", "inState"), CL.mkVar indexVar) :: args),
240                            CL.E_Cast(strandTy,                        CL.S_Exp(CL.mkPostOp(CL.mkVar indexVar, CL.^++))
                           CL.E_Apply(N.inState, [CL.E_Var "wrld", CL.E_Var indexVar]))))),  
                       CL.mkCall(N.strandInit name, CL.E_Var "sp" :: args),  
                       CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))  
241                      ])                      ])
242                  | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let                  | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let
243                      val body = mkLoopNest iters                      val body = mkLoopNest iters
# Line 260  Line 257 
257                      iterPrefix @                      iterPrefix @
258                      allocCode @                      allocCode @
259                      iterCode @                      iterCode @
260                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])                      [CL.mkReturn(SOME(CL.mkVar "false"))])
261                val initFn = CL.D_Func([], worldTy, N.initially, [], body)                val initFn = CL.D_Func([], CL.boolTy, N.initially tgt, [CL.PARAM([], worldTy, "wrld")], body)
262                in                in
263                  nAxes := (if isArray then SOME nDims else NONE);                  nAxes := (if isArray then SOME nDims else NONE);
264                  initially := initFn                  initially := initFn
# Line 302  Line 299 
299          fun genWorldStruct (tgt : target_desc, Strand{tyName, ...}) = CL.D_StructDef(          fun genWorldStruct (tgt : target_desc, Strand{tyName, ...}) = CL.D_StructDef(
300                SOME(#namespace tgt ^ "struct_world"),                SOME(#namespace tgt ^ "struct_world"),
301                [                [
302                    (* WORLD_STRUCT_PREFIX componenets (see Diderot/world.h) *)
303                    (CL.T_Ptr(CL.T_Named "const char"),           "name"),                    (CL.T_Ptr(CL.T_Named "const char"),           "name"),
304                    (CL.charPtr,                                  "err"),                    (CL.charPtr,                                  "err"),
305                    (CL.boolTy,                                   "verboseFlg"),                    (CL.boolTy,                                   "verboseFlg"),
# Line 312  Line 310 
310                    (CL.T_Ptr CL.uint32,                          "base"),                    (CL.T_Ptr CL.uint32,                          "base"),
311                    (CL.T_Ptr CL.uint32,                          "size"),                    (CL.T_Ptr CL.uint32,                          "size"),
312                    (CL.uint32,                                   "numStrands"),                    (CL.uint32,                                   "numStrands"),
313                    (* target-specific world components *)
314                    (CL.T_Ptr CL.uint8,                           "status"),                    (CL.T_Ptr CL.uint8,                           "status"),
315                    (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),       "inState"),                    (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),       "inState"),
316                    (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),       "outState")                    (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),       "outState")
# Line 326  Line 325 
325                  | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)                  | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)
326                fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)                fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)
327                in                in
328                  ppDecl (CL.D_Var([], CL.int32, N.numStrands,                  ppDecl (CL.D_Var(["static const"], CL.int32, "NumStrands",
329                    SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nStrands, CL.int32)))));                    SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nStrands, CL.int32)))));
330                  ppDecl (CL.D_Var([],                  ppDecl (CL.D_Var([],
331                    CL.T_Array(CL.T_Ptr(CL.T_Named N.strandDescTy), SOME nStrands),                    CL.T_Array(CL.T_Ptr(CL.T_Named N.strandDescTy), SOME nStrands),
# Line 397  Line 396 
396                  ("STRANDTY",    tyName)                  ("STRANDTY",    tyName)
397                ]                ]
398    
399          fun outputLibSrc (baseName, Prog{tgt, globals, strands, nAxes, ...}) = let          fun outputLibSrc (baseName, Prog{tgt, globals, strands, nAxes, initially, ...}) = let
400                val [strand as Strand{name, tyName, state, output, ...}] = AtomTable.listItems strands                val [strand as Strand{name, tyName, state, output, ...}] = AtomTable.listItems strands
401                val outputs = List.map (GenOutput.gen (tgt, !nAxes)) [output]                val outputs = List.map (GenOutput.gen (tgt, !nAxes)) [output]
402                val substitutions = mkSubs (tgt, strand)                val substitutions = mkSubs (tgt, strand)
# Line 413  Line 412 
412                  List.app ppDecl (List.rev (!globals));                  List.app ppDecl (List.rev (!globals));
413                  List.app ppDecl (genStrand(tgt, strand));                  List.app ppDecl (genStrand(tgt, strand));
414                  List.app ppDecl outputs;                  List.app ppDecl outputs;
415                    ppStrandTable (ppStrm, [strand]);
416                  ppDecl (CL.verbatim [CBodyFrag.text] substitutions);                  ppDecl (CL.verbatim [CBodyFrag.text] substitutions);
417                    ppDecl (CL.verbatim [InitFrag.text] substitutions);
418                    ppDecl (CL.verbatim [AllocFrag.text] substitutions);
419                    ppDecl (!initially);
420                  ppDecl (CL.verbatim [RunFrag.text] substitutions);                  ppDecl (CL.verbatim [RunFrag.text] substitutions);
421                    ppDecl (CL.verbatim [ShutdownFrag.text] substitutions);
422                  PrintAsC.close ppStrm;                  PrintAsC.close ppStrm;
423                  TextIO.closeOut outS                  TextIO.closeOut outS
424                end                end

Legend:
Removed from v.1717  
changed lines
  Added in v.1718

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