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 1726, Mon Mar 12 22:34:46 2012 UTC revision 1727, Mon Mar 12 22:35:18 2012 UTC
# Line 137  Line 137 
137                }                }
138        end        end
139    
140      (* strands *)
141        structure Strand =
142          struct
143            fun define (Prog{strands, ...}, strandId, state) = let
144                  val name = Atom.toString strandId
145                (* the output state variable *)
146                  val outputVar = (case List.filter IL.StateVar.isOutput state
147                         of [] => raise Fail("no output specified for strand " ^ name)
148                          | [x] => (IL.StateVar.ty x, IL.StateVar.name x)
149                          | _ => raise Fail("multiple outputs in " ^ name)
150                        (* end case *))
151                (* the state variables *)
152                  val state = let
153                        fun cvt x = CL.V(ToC.trType(IL.StateVar.ty x), IL.StateVar.name x)
154                        in
155                          List.map cvt state
156                        end
157                  val strand = Strand{
158                          name = name,
159                          tyName = N.strandTy name,
160                          state = state,
161                          output = outputVar,
162                          code = ref []
163                        }
164                  in
165                    AtomTable.insert strands (strandId, strand);
166                    strand
167                  end
168    
169          (* return the strand with the given name *)
170            fun lookup (Prog{strands, ...}, strandId) = AtomTable.lookup strands strandId
171    
172          (* register the strand-state initialization code.  The variables are the strand
173           * parameters.
174           *)
175            fun init (Strand{name, tyName, code, ...}, params, init) = let
176                  val fName = N.strandInit name
177                  val params =
178                        CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
179                          List.map (fn (CL.V(ty, x)) => CL.PARAM([], ty, x)) params
180                  val initFn = CL.D_Func([], CL.voidTy, fName, params, init)
181                  in
182                    code := initFn :: !code
183                  end
184    
185          (* register a strand method *)
186            fun method (Strand{name, tyName, code, ...}, methName, body) = let
187                  val fName = concat[name, "_", StrandUtil.nameToString methName]
188                  val params = [
189                          CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfIn"),
190                          CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut")
191                        ]
192                  val resTy = (case methName
193                         of StrandUtil.Update => CL.T_Named "StrandStatus_t"
194                          | StrandUtil.Stabilize => CL.voidTy
195                        (* end case *))
196                  val methFn = CL.D_Func(["static"], resTy, fName, params, body)
197                  in
198                    code := methFn :: !code
199                  end
200    
201          end
202    
203    (* programs *)    (* programs *)
204      structure Program =      structure Program =
205        struct        struct
# Line 172  Line 235 
235                      initially = ref(CL.D_Comment["missing initially"])                      initially = ref(CL.D_Comment["missing initially"])
236                    }                    }
237                  end                  end
238        (* register the code that is used to register command-line options for input variables *)  (* FIXME: the inputFn was used for the standalone executable; we need to do something
239          fun inputs (Prog{topDecls, ...}, stm) = let   * different for libraries.
240     *)
241          (* register the code that is used to set defaults for input variables *)
242            fun inputs (Prog{tgt, topDecls, ...}, stm) = let
243                  val worldTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))
244                val inputsFn = CL.D_Func(                val inputsFn = CL.D_Func(
245                      [], CL.voidTy, N.registerOpts,                      ["static"], CL.voidTy, N.initDefaults,
246                      [CL.PARAM([], CL.T_Ptr(CL.T_Named N.optionsTy), "opts")],                      [CL.PARAM([], worldTy, "wrld")],
247                      stm)                      stm)
248                in                in
249                  topDecls := inputsFn :: !topDecls                  topDecls := inputsFn :: !topDecls
250                end                end
251        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
252          fun init (Prog{topDecls, ...}, init) = let          fun init (Prog{tgt, topDecls, ...}, init) = let
253                val initFn = CL.D_Func(["static"], CL.voidTy, N.initGlobals, [], init)                val worldTy = CL.T_Ptr(CL.T_Named(N.worldTy tgt))
254                  val initFn = CL.D_Func(
255                        ["static"], CL.voidTy, N.initGlobals,
256                        [CL.PARAM([], worldTy, "wrld")],
257                        init)
258                in                in
259                  topDecls := initFn :: !topDecls                  topDecls := initFn :: !topDecls
260                end                end
# Line 212  Line 283 
283                          (i, CL.I_Exp(CL.mkBinOp(CL.mkBinOp(hi, CL.#-, lo), CL.#+, CL.E_Int(1, ty))))                          (i, CL.I_Exp(CL.mkBinOp(CL.mkBinOp(hi, CL.#-, lo), CL.#+, CL.E_Int(1, ty))))
284                      ) iters                      ) iters
285              (* code to allocate the world and initial strands *)              (* code to allocate the world and initial strands *)
               val wrld = "wrld"  
286                val allocCode = [                val allocCode = [
287                        CL.mkComment["allocate initial block of strands"],                        CL.mkComment["allocate initial block of strands"],
288                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "base", SOME(CL.I_Array baseInit)),                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "base", SOME(CL.I_Array baseInit)),
# Line 254  Line 324 
324                        mkLoopNest iters                        mkLoopNest iters
325                      ]                      ]
326                val body = CL.mkBlock(                val body = CL.mkBlock(
327                        CL.mkCall (N.initGlobals, [CL.mkVar "wrld"]) ::
328                      iterPrefix @                      iterPrefix @
329                      allocCode @                      allocCode @
330                      iterCode @                      iterCode @
# Line 396  Line 467 
467                  ("STRANDTY",    tyName)                  ("STRANDTY",    tyName)
468                ]                ]
469    
470          fun outputLibSrc (baseName, Prog{tgt, globals, strands, nAxes, initially, ...}) = let          fun outputLibSrc (baseName, Prog{
471                    tgt, globals, topDecls, strands, nAxes, initially, ...
472                  }) = let
473                val [strand as Strand{name, tyName, state, output, ...}] = AtomTable.listItems strands                val [strand as Strand{name, tyName, state, output, ...}] = AtomTable.listItems strands
474                val outputs = List.map (GenOutput.gen (tgt, !nAxes)) [output]                val outputs = List.map (GenOutput.gen (tgt, !nAxes)) [output]
475                val substitutions = mkSubs (tgt, strand)                val substitutions = mkSubs (tgt, strand)
# Line 410  Line 483 
483                  ppDecl (CL.verbatim [CHeadFrag.text] substitutions);                  ppDecl (CL.verbatim [CHeadFrag.text] substitutions);
484                  ppDecl (genWorldStruct(tgt, strand));                  ppDecl (genWorldStruct(tgt, strand));
485                  List.app ppDecl (List.rev (!globals));                  List.app ppDecl (List.rev (!globals));
486                    List.app ppDecl (List.rev (!topDecls));
487                  List.app ppDecl (genStrand(tgt, strand));                  List.app ppDecl (genStrand(tgt, strand));
488                  List.app ppDecl outputs;                  List.app ppDecl outputs;
489                  ppStrandTable (ppStrm, [strand]);                  ppStrandTable (ppStrm, [strand]);
# Line 448  Line 522 
522    
523        end        end
524    
   (* strands *)  
     structure Strand =  
       struct  
         fun define (Prog{strands, ...}, strandId, state) = let  
               val name = Atom.toString strandId  
             (* the output state variable *)  
               val outputVar = (case List.filter IL.StateVar.isOutput state  
                      of [] => raise Fail("no output specified for strand " ^ name)  
                       | [x] => (IL.StateVar.ty x, IL.StateVar.name x)  
                       | _ => raise Fail("multiple outputs in " ^ name)  
                     (* end case *))  
             (* the state variables *)  
               val state = let  
                     fun cvt x = CL.V(ToC.trType(IL.StateVar.ty x), IL.StateVar.name x)  
                     in  
                       List.map cvt state  
                     end  
               val strand = Strand{  
                       name = name,  
                       tyName = N.strandTy name,  
                       state = state,  
                       output = outputVar,  
                       code = ref []  
                     }  
               in  
                 AtomTable.insert strands (strandId, strand);  
                 strand  
               end  
   
       (* return the strand with the given name *)  
         fun lookup (Prog{strands, ...}, strandId) = AtomTable.lookup strands strandId  
   
       (* register the strand-state initialization code.  The variables are the strand  
        * parameters.  
        *)  
         fun init (Strand{name, tyName, code, ...}, params, init) = let  
               val fName = N.strandInit name  
               val params =  
                     CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::  
                       List.map (fn (CL.V(ty, x)) => CL.PARAM([], ty, x)) params  
               val initFn = CL.D_Func([], CL.voidTy, fName, params, init)  
               in  
                 code := initFn :: !code  
               end  
   
       (* register a strand method *)  
         fun method (Strand{name, tyName, code, ...}, methName, body) = let  
               val fName = concat[name, "_", StrandUtil.nameToString methName]  
               val params = [  
                       CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfIn"),  
                       CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut")  
                     ]  
               val resTy = (case methName  
                      of StrandUtil.Update => CL.T_Named "StrandStatus_t"  
                       | StrandUtil.Stabilize => CL.voidTy  
                     (* end case *))  
               val methFn = CL.D_Func(["static"], resTy, fName, params, body)  
               in  
                 code := methFn :: !code  
               end  
   
       end  
   
525    end    end
526    
527  structure CBackEnd = CodeGenFn(CTarget)  structure CBackEnd = CodeGenFn(CTarget)

Legend:
Removed from v.1726  
changed lines
  Added in v.1727

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