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 1300, Thu Jun 9 21:11:47 2011 UTC revision 1301, Thu Jun 9 23:58:40 2011 UTC
# Line 27  Line 27 
27        }        }
28    
29      datatype program = Prog of {      datatype program = Prog of {
30            name : string,                  (* stem of source file *)
31          double : bool,                  (* true for double-precision support *)          double : bool,                  (* true for double-precision support *)
32          parallel : bool,                (* true for multithreaded (or multi-GPU) target *)          parallel : bool,                (* true for multithreaded (or multi-GPU) target *)
33          debug : bool,                   (* true for debug support in executable *)          debug : bool,                   (* true for debug support in executable *)
# Line 135  Line 136 
136    (* programs *)    (* programs *)
137      structure Program =      structure Program =
138        struct        struct
139          fun new {double, parallel, debug} = (          fun new {name, double, parallel, debug} = (
140                RN.initTargetSpec double;                RN.initTargetSpec double;
141                Prog{                Prog{
142                      name = name,
143                    double = double, parallel = parallel, debug = debug,                    double = double, parallel = parallel, debug = debug,
144                    globals = ref [                    globals = ref [ (* NOTE: in reverse order! *)
145                          CL.D_Var(["static"], CL.charPtr, "ProgramName",
146                            SOME(CL.I_Exp(CL.mkStr name))),
147                      CL.D_Verbatim[                      CL.D_Verbatim[
148                          if double                          if double
149                            then "#define DIDEROT_DOUBLE_PRECISION"                            then "#define DIDEROT_DOUBLE_PRECISION"
150                            else "#define DIDEROT_SINGLE_PRECISION",                            else "#define DIDEROT_SINGLE_PRECISION",
151                              if parallel
152                                then "#define DIDEROT_TARGET_PARALLEL"
153                                else "#define DIDEROT_TARGET_C",
154                          "#include \"Diderot/diderot.h\""                          "#include \"Diderot/diderot.h\""
155                        ]],                          ]
156                        ],
157                    topDecls = ref [],                    topDecls = ref [],
158                    strands = AtomTable.mkTable (16, Fail "strand table"),                    strands = AtomTable.mkTable (16, Fail "strand table"),
159                    initially = ref(CL.D_Comment["missing initially"])                    initially = ref(CL.D_Comment["missing initially"])
160                  })                  })
161          (* register the code that is used to register command-line options for input variables *)
162            fun inputs (Prog{topDecls, ...}, stm) = let
163                  val inputsFn = CL.D_Func(
164                        [], CL.voidTy, RN.registerOpts,
165                        [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.optionsTy), "opts")],
166                        stm)
167                  in
168                    topDecls := inputsFn :: !topDecls
169                  end
170        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
171          fun init (Prog{topDecls, ...}, init) = let          fun init (Prog{topDecls, ...}, init) = let
172                val initFn = CL.D_Func(                val initFn = CL.D_Func([], CL.voidTy, RN.initGlobals, [], init)
                     [], CL.voidTy, RN.initGlobals, [  
                         CL.PARAM([], CL.intTy, "argc"),  
                         CL.PARAM(["const"], CL.T_Ptr(CL.charPtr), "argv")  
                       ],  
                     init)  
173                val shutdownFn = CL.D_Func(                val shutdownFn = CL.D_Func(
174                      [], CL.voidTy, RN.shutdown,                      [], CL.voidTy, RN.shutdown,
175                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.worldTy), "wrld")],                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.worldTy), "wrld")],
# Line 167  Line 179 
179                end                end
180        (* create and register the initially function for a program *)        (* create and register the initially function for a program *)
181          fun initially {          fun initially {
182                prog = Prog{strands, initially, ...},                prog = Prog{name=progName, strands, initially, ...},
183                isArray : bool,                isArray : bool,
184                iterPrefix : stm list,                iterPrefix : stm list,
185                iters : (var * exp * exp) list,                iters : (var * exp * exp) list,
# Line 189  Line 201 
201                      (fn (i, (ToC.V(ty, _), lo, hi)) =>                      (fn (i, (ToC.V(ty, _), lo, hi)) =>
202                          (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))))
203                      ) iters                      ) iters
204                (* code to allocate the world and initial strands *)
205                  val wrld = "wrld"
206                val allocCode = [                val allocCode = [
207                        CL.mkComment["allocate initial block of strands"],                        CL.mkComment["allocate initial block of strands"],
208                        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)),
209                        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)),
210                        CL.mkDecl(worldTy, "wrld",                        CL.mkDecl(worldTy, wrld,
211                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [
212                                CL.mkVar "ProgramName",
213                              CL.mkUnOp(CL.%&, CL.E_Var(RN.strandDesc name)),                              CL.mkUnOp(CL.%&, CL.E_Var(RN.strandDesc name)),
214                              CL.E_Bool isArray,                              CL.E_Bool isArray,
215                              CL.E_Int(IntInf.fromInt nDims, CL.int32),                              CL.E_Int(IntInf.fromInt nDims, CL.int32),
# Line 227  Line 242 
242                        CL.mkDecl(CL.uint32, indexVar, SOME(CL.I_Exp(CL.E_Int(0, CL.uint32)))),                        CL.mkDecl(CL.uint32, indexVar, SOME(CL.I_Exp(CL.E_Int(0, CL.uint32)))),
243                        mkLoopNest iters                        mkLoopNest iters
244                      ]                      ]
245                val body = CL.mkBlock(iterPrefix @ allocCode @ iterCode @ [CL.mkReturn(SOME(CL.E_Var "wrld"))])                val body = CL.mkBlock(
246                        iterPrefix @
247                        allocCode @
248                        iterCode @
249                        [CL.mkReturn(SOME(CL.E_Var "wrld"))])
250                val initFn = CL.D_Func([], worldTy, RN.initially, [], body)                val initFn = CL.D_Func([], worldTy, RN.initially, [], body)
251                in                in
252                  initially := initFn                  initially := initFn
# Line 278  Line 297 
297                      fun fnPtr (ty, f) = CL.I_Exp(CL.mkCast(CL.T_Named ty, CL.mkVar f))                      fun fnPtr (ty, f) = CL.I_Exp(CL.mkCast(CL.T_Named ty, CL.mkVar f))
298                      in                      in
299                        CL.I_Struct[                        CL.I_Struct[
300                            ("name", CL.I_Exp(CL.E_Str name)),                            ("name", CL.I_Exp(CL.mkStr name)),
301                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),
302                            ("update", fnPtr("update_method_t", name ^ "_update")),                            ("update", fnPtr("update_method_t", name ^ "_update")),
303                            ("print", fnPtr("print_method_t", prFnName))                            ("print", fnPtr("print_method_t", prFnName))
# Line 305  Line 324 
324                    SOME(CL.I_Array(genInits (0, strands)))))                    SOME(CL.I_Array(genInits (0, strands)))))
325                end                end
326    
327          fun genSrc (baseName, Prog{globals, topDecls, strands, initially, ...}) = let          fun genSrc (baseName, prog) = let
328                  val Prog{name, globals, topDecls, strands, initially, ...} = prog
329                val fileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}                val fileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}
330                val outS = TextIO.openOut fileName                val outS = TextIO.openOut fileName
331                val ppStrm = PrintAsC.new outS                val ppStrm = PrintAsC.new outS
# Line 324  Line 344 
344        (* output the code to a file.  The string is the basename of the file, the extension        (* output the code to a file.  The string is the basename of the file, the extension
345         * is provided by the target.         * is provided by the target.
346         *)         *)
347          fun generate (basename, prog as Prog{double, parallel, debug, ...}) = let          fun generate (basename, prog as Prog{name, double, parallel, debug, ...}) = let
348                fun condCons (true, x, xs) = x::xs                fun condCons (true, x, xs) = x::xs
349                  | condCons (false, _, xs) = xs                  | condCons (false, _, xs) = xs
350              (* generate the C compiler flags *)              (* generate the C compiler flags *)

Legend:
Removed from v.1300  
changed lines
  Added in v.1301

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