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 1805, Fri Apr 6 15:50:59 2012 UTC revision 1806, Sat Apr 7 00:02:25 2012 UTC
# Line 27  Line 27 
27          fun lvalueVar (env, x) = CL.mkVar(lookup(env, x))          fun lvalueVar (env, x) = CL.mkVar(lookup(env, x))
28        (* translate a variable that occurs in an r-value context *)        (* translate a variable that occurs in an r-value context *)
29          fun rvalueVar (env, x) = CL.mkVar(lookup(env, x))          fun rvalueVar (env, x) = CL.mkVar(lookup(env, x))
30          (* translate a variable that occurs in an l-value context (i.e., as the target of an assignment) *)
31            fun lvalueVar (env, x) = (case V.kind x
32                   of IL.VK_Local => CL.mkVar(lookup(env, x))
33                    | _ => CL.mkIndirect(CL.mkVar "glob", lookup(env, x))
34                  (* end case *))
35          (* translate a variable that occurs in an r-value context *)
36            fun rvalueVar (env, x) = (case V.kind x
37                   of IL.VK_Local => CL.mkVar(lookup(env, x))
38                    | _ => CL.mkIndirect(CL.mkVar "glob", lookup(env, x))
39                  (* end case *))
40        (* translate a strand state variable that occurs in an l-value context *)        (* translate a strand state variable that occurs in an l-value context *)
41          fun lvalueStateVar x = CL.mkIndirect(CL.mkVar "selfOut", IL.StateVar.name x)          fun lvalueStateVar x = CL.mkIndirect(CL.mkVar "selfOut", IL.StateVar.name x)
42        (* translate a strand state variable that occurs in an r-value context *)        (* translate a strand state variable that occurs in an r-value context *)
# Line 40  Line 50 
50      type stm = CL.stm      type stm = CL.stm
51    
52      datatype strand = Strand of {      datatype strand = Strand of {
53            prog : program,
54          name : string,          name : string,
55          tyName : string,          tyName : string,
56          state : var list,          state : var list,
# Line 47  Line 58 
58          code : CL.decl list ref          code : CL.decl list ref
59        }        }
60    
61      datatype program = Prog of {      and program = Prog of {
62          tgt : target_desc,              (* info about target *)          tgt : target_desc,              (* info about target *)
63          inputs : GenInputs.input_desc list ref,          inputs : GenInputs.input_desc list ref,
64          globals : CL.decl list ref,          globals : (CL.ty * string) list ref,
65          topDecls : CL.decl list ref,          topDecls : CL.decl list ref,
66          strands : strand AtomTable.hash_table,          strands : strand AtomTable.hash_table,
67          nAxes : int option ref,         (* number of axes in initial grid (NONE means collection) *)          nAxes : int option ref,         (* number of axes in initial grid (NONE means collection) *)
# Line 109  Line 120 
120          fun global (Prog{globals, ...}, name, ty) = let          fun global (Prog{globals, ...}, name, ty) = let
121                val ty' = ToC.trType ty                val ty' = ToC.trType ty
122                in                in
123                  globals := CL.D_Var([], ty', name, NONE) :: !globals;                  globals := (ty', name) :: !globals;
124                  CL.V(ty', name)                  CL.V(ty', name)
125                end                end
126          fun param x = CL.V(ToC.trType(V.ty x), V.name x)          fun param x = CL.V(ToC.trType(V.ty x), V.name x)
# Line 141  Line 152 
152    (* strands *)    (* strands *)
153      structure Strand =      structure Strand =
154        struct        struct
155          fun define (Prog{strands, ...}, strandId, state) = let          fun define (prog as Prog{strands, ...}, strandId, state) = let
156                val name = Atom.toString strandId                val name = Atom.toString strandId
157              (* the output state variable *)              (* the output state variable *)
158                val outputVar = (case List.filter IL.StateVar.isOutput state                val outputVar = (case List.filter IL.StateVar.isOutput state
# Line 156  Line 167 
167                        List.map cvt state                        List.map cvt state
168                      end                      end
169                val strand = Strand{                val strand = Strand{
170                          prog = prog,
171                        name = name,                        name = name,
172                        tyName = N.strandTy name,                        tyName = N.strandTy name,
173                        state = state,                        state = state,
# Line 173  Line 185 
185        (* register the strand-state initialization code.  The variables are the strand        (* register the strand-state initialization code.  The variables are the strand
186         * parameters.         * parameters.
187         *)         *)
188          fun init (Strand{name, tyName, code, ...}, params, init) = let          fun init (Strand{prog=Prog{tgt, ...}, name, tyName, code, ...}, params, init) = let
189                  val globTy = CL.T_Ptr(CL.T_Named(N.globalTy tgt))
190                val fName = N.strandInit name                val fName = N.strandInit name
191                val params =                val params =
192                        CL.PARAM([], globTy, "glob") ::
193                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
194                        List.map (fn (CL.V(ty, x)) => CL.PARAM([], ty, x)) params                        List.map (fn (CL.V(ty, x)) => CL.PARAM([], ty, x)) params
195                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)
# Line 184  Line 198 
198                end                end
199    
200        (* register a strand method *)        (* register a strand method *)
201          fun method (Strand{name, tyName, code, ...}, methName, body) = let          fun method (Strand{prog=Prog{tgt, ...}, name, tyName, code, ...}, methName, body) = let
202                  val globTy = CL.T_Ptr(CL.T_Named(N.globalTy tgt))
203                val fName = concat[name, "_", StrandUtil.nameToString methName]                val fName = concat[name, "_", StrandUtil.nameToString methName]
204                val params = [                val params = [
205                          CL.PARAM([], globTy, "glob"),
206                        CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfIn"),
207                        CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut")                        CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut")
208                      ]                      ]
# Line 221  Line 237 
237        (* register the code that is used to set defaults for input variables *)        (* register the code that is used to set defaults for input variables *)
238          fun inputs (Prog{tgt, inputs, topDecls, ...}, env, blk) = let          fun inputs (Prog{tgt, inputs, topDecls, ...}, env, blk) = let
239                val worldTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))                val worldTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))
240                  val globTy = CL.T_Ptr(CL.T_Named(N.globalTy tgt))
241                  val body = CL.mkBlock(
242                        CL.mkDeclInit(globTy, "glob", CL.mkIndirect(CL.mkVar "wrld", "globals")) ::
243                        CL.unBlock (Tr.block (env, blk)))
244                val inputsFn = CL.D_Func(                val inputsFn = CL.D_Func(
245                      ["static"], CL.voidTy, N.initDefaults,                      ["static"], CL.voidTy, N.initDefaults,
246                      [CL.PARAM([], worldTy, "wrld")],                      [CL.PARAM([], worldTy, "wrld")],
247                      Tr.block (env, blk))                      body)
248                in                in
249                  inputs := GenInputs.gatherInputs blk;                  inputs := GenInputs.gatherInputs blk;
250                  topDecls := inputsFn :: !topDecls                  topDecls := inputsFn :: !topDecls
# Line 232  Line 252 
252        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
253          fun init (Prog{tgt, topDecls, ...}, init) = let          fun init (Prog{tgt, topDecls, ...}, init) = let
254                val worldTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))                val worldTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))
255                  val globTy = CL.T_Ptr(CL.T_Named(N.globalTy tgt))
256                  val init = CL.mkBlock(
257                        CL.mkDeclInit(globTy, "glob", CL.mkIndirect(CL.mkVar "wrld", "globals")) ::
258                        CL.unBlock init)
259                val initFn = CL.D_Func(                val initFn = CL.D_Func(
260                      ["static"], CL.voidTy, N.initGlobals,                      ["static"], CL.voidTy, N.initGlobals,
261                      [CL.PARAM([], worldTy, "wrld")],                      [CL.PARAM([], worldTy, "wrld")],
# Line 252  Line 276 
276                val name = Atom.toString strand                val name = Atom.toString strand
277                val nDims = List.length iters                val nDims = List.length iters
278                val worldTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))                val worldTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))
279                  val globTy = CL.T_Ptr(CL.T_Named(N.globalTy tgt))
280                fun mapi f xs = let                fun mapi f xs = let
281                      fun mapf (_, []) = []                      fun mapf (_, []) = []
282                        | mapf (i, x::xs) = f(i, x) :: mapf(i+1, xs)                        | mapf (i, x::xs) = f(i, x) :: mapf(i+1, xs)
# Line 287  Line 312 
312                val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))                val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))
313                fun statePtr inout = CL.mkSubscript(CL.mkIndirect(CL.mkVar "wrld", inout), CL.mkVar indexVar)                fun statePtr inout = CL.mkSubscript(CL.mkIndirect(CL.mkVar "wrld", inout), CL.mkVar indexVar)
314                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [
315                        CL.mkCall(N.strandInit name, statePtr "inState" :: args),                        CL.mkCall(N.strandInit name, CL.mkVar "glob" :: statePtr "inState" :: args),
316                        CL.mkCall("memcpy", [                        CL.mkCall("memcpy", [
317                            statePtr "outState", statePtr "inState",                            statePtr "outState", statePtr "inState",
318                            CL.mkSizeof(CL.T_Named(N.strandTy name))                            CL.mkSizeof(CL.T_Named(N.strandTy name))
# Line 310  Line 335 
335                      ]                      ]
336                val body = CL.mkBlock(                val body = CL.mkBlock(
337                      CL.mkCall (N.initGlobals, [CL.mkVar "wrld"]) ::                      CL.mkCall (N.initGlobals, [CL.mkVar "wrld"]) ::
338                        CL.mkDeclInit (globTy, "glob", CL.mkIndirect(CL.mkVar "wrld", "globals")) ::
339                      iterPrefix @                      iterPrefix @
340                      allocCode @                      allocCode @
341                      iterCode @                      iterCode @
# Line 357  Line 383 
383                  end                  end
384                else [TargetUtil.runtimeName tgt]                else [TargetUtil.runtimeName tgt]
385    
386          fun genStrand (tgt : target_desc, Strand{name, tyName, state, output, code}) = let          fun genStrand (Strand{prog=Prog{tgt, ...}, name, tyName, state, output, code}) = let
387              (* the type declaration for the strand's state struct *)              (* the type declaration for the strand's state struct *)
388                val selfTyDef = CL.D_StructDef(                val selfTyDef = CL.D_StructDef(
389                        SOME(concat[#namespace tgt, "struct_", name]),                        SOME(concat[#namespace tgt, "struct_", name]),
# Line 381  Line 407 
407                  selfTyDef :: List.rev (desc :: !code)                  selfTyDef :: List.rev (desc :: !code)
408                end                end
409    
410            fun genGlobalStruct (tgt : target_desc, globals) =
411                  CL.D_StructDef(NONE, globals, SOME(#namespace tgt ^ "Globals_t"))
412    
413  (* FIXME: this function will also be used for other targets, so we should pull it into a  (* FIXME: this function will also be used for other targets, so we should pull it into a
414   * utility module in c-util.   * utility module in c-util.
415   *)   *)
416        (* generate the struct declaration for the world representation *)        (* generate the struct declaration for the world representation *)
417          fun genWorldStruct (isTypedef, tgt : target_desc, Strand{tyName, ...}) = let          fun genWorldStruct (isTypedef, tgt : target_desc, Strand{tyName, ...}) = let
418                  val ns = #namespace tgt
419                val body = [                val body = [
420                      (* WORLD_STRUCT_PREFIX componenets (see Diderot/world.h) *)                      (* WORLD_STRUCT_PREFIX componenets (see Diderot/world.h) *)
421                        (CL.T_Ptr(CL.T_Named "const char"),       "name"),                        (CL.T_Ptr(CL.T_Named "const char"),       "name"),
# Line 399  Line 429 
429                        (CL.T_Ptr CL.uint32,                      "size"),                        (CL.T_Ptr CL.uint32,                      "size"),
430                        (CL.uint32,                               "numStrands"),                        (CL.uint32,                               "numStrands"),
431                      (* target-specific world components *)                      (* target-specific world components *)
432                          (CL.T_Ptr(CL.T_Named(ns ^ "Globals_t")),  "globals"),
433                        (CL.T_Ptr CL.uint8,                       "status"),                        (CL.T_Ptr CL.uint8,                       "status"),
434                        (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),   "inState"),                        (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),   "inState"),
435                        (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),   "outState")                        (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),   "outState")
436                      ]                      ]
437                in                in
438                  if isTypedef                  if isTypedef
439                    then CL.D_StructDef(NONE, body, SOME(#namespace tgt ^ "World_t"))                    then CL.D_StructDef(NONE, body, SOME(ns ^ "World_t"))
440                    else CL.D_StructDef(SOME(#namespace tgt ^ "struct_world"), body, NONE)                    else CL.D_StructDef(SOME(ns ^ "struct_world"), body, NONE)
441                end                end
442    
443        (* generate the table of strand descriptors *)        (* generate the table of strand descriptors *)
# Line 439  Line 470 
470                in                in
471  (* FIXME: use a fragment for this part of the file *)  (* FIXME: use a fragment for this part of the file *)
472                  ppDecl (CL.verbatim [CHeadFrag.text] substitutions);                  ppDecl (CL.verbatim [CHeadFrag.text] substitutions);
473                    ppDecl (genGlobalStruct (tgt, List.rev(!globals)));
474                  ppDecl (genWorldStruct(false, tgt, strand));                  ppDecl (genWorldStruct(false, tgt, strand));
                 List.app ppDecl (List.rev (!globals));  
475                  List.app ppDecl (List.rev (!topDecls));                  List.app ppDecl (List.rev (!topDecls));
476                  List.app ppDecl (GenInputs.genInputFuns(tgt, !inputs));                  List.app ppDecl (GenInputs.genInputFuns(tgt, !inputs));
477                  List.app ppDecl (genStrand(tgt, strand));                  List.app ppDecl (genStrand strand);
478                  List.app ppDecl outputs;                  List.app ppDecl outputs;
479                  ppStrandTable (ppStrm, [strand]);                  ppStrandTable (ppStrm, [strand]);
480                  ppDecl (CL.verbatim [CBodyFrag.text] substitutions);                  ppDecl (CL.verbatim [CBodyFrag.text] substitutions);
# Line 493  Line 524 
524                      else SeqMainFrag.text                      else SeqMainFrag.text
525                in                in
526                  ppDecl (CL.verbatim [ExecHdr.text] substitutions);                  ppDecl (CL.verbatim [ExecHdr.text] substitutions);
527                    ppDecl (genGlobalStruct (tgt, List.rev(!globals)));
528                  ppDecl (genWorldStruct(true, tgt, strand));                  ppDecl (genWorldStruct(true, tgt, strand));
                 List.app ppDecl (List.rev (!globals));  
529                  List.app ppDecl (List.rev (!topDecls));                  List.app ppDecl (List.rev (!topDecls));
530                  ppDecl (GenInputs.genRegisterInputs (tgt, !inputs));                  ppDecl (GenInputs.genRegisterInputs (tgt, !inputs));
531                  List.app ppDecl (genStrand(tgt, strand));                  List.app ppDecl (genStrand strand);
532                  List.app ppDecl outputs;                  List.app ppDecl outputs;
533                  ppStrandTable (ppStrm, [strand]);                  ppStrandTable (ppStrm, [strand]);
534                  ppDecl (CL.verbatim [InitFrag.text] substitutions);                  ppDecl (CL.verbatim [InitFrag.text] substitutions);

Legend:
Removed from v.1805  
changed lines
  Added in v.1806

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