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

SCM Repository

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

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

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

revision 1375, Wed Jun 22 21:43:18 2011 UTC revision 1376, Wed Jun 22 21:46:24 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 = CNames      structure N = CNames
15      structure ToC = TreeToC      structure ToC = TreeToC
16    
17      type var = ToC.var      type var = ToC.var
# Line 58  Line 58 
58     * the supported sizes are powers of two, but float2 is broken.     * the supported sizes are powers of two, but float2 is broken.
59     * NOTE: we should also consider the AVX vector hardware, which has 256-bit registers.     * NOTE: we should also consider the AVX vector hardware, which has 256-bit registers.
60     *)     *)
61      fun vectorWidths () = if !RN.doublePrecision      fun vectorWidths () = if !N.doublePrecision
62            then [2, 4, 8]            then [2, 4, 8]
63            else [4, 8]            else [4, 8]
64    
# Line 137  Line 137 
137      structure Program =      structure Program =
138        struct        struct
139          fun new {name, double, parallel, debug} = (          fun new {name, double, parallel, debug} = (
140                RN.initTargetSpec double;                N.initTargetSpec double;
141                Prog{                Prog{
142                    name = name,                    name = name,
143                    double = double, parallel = parallel, debug = debug,                    double = double, parallel = parallel, debug = debug,
# Line 161  Line 161 
161        (* register the code that is used to register command-line options for input variables *)        (* register the code that is used to register command-line options for input variables *)
162          fun inputs (Prog{topDecls, ...}, stm) = let          fun inputs (Prog{topDecls, ...}, stm) = let
163                val inputsFn = CL.D_Func(                val inputsFn = CL.D_Func(
164                      [], CL.voidTy, RN.registerOpts,                      [], CL.voidTy, N.registerOpts,
165                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.optionsTy), "opts")],                      [CL.PARAM([], CL.T_Ptr(CL.T_Named N.optionsTy), "opts")],
166                      stm)                      stm)
167                in                in
168                  topDecls := inputsFn :: !topDecls                  topDecls := inputsFn :: !topDecls
169                end                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([], CL.voidTy, RN.initGlobals, [], init)                val initFn = CL.D_Func([], CL.voidTy, N.initGlobals, [], init)
173                val shutdownFn = CL.D_Func(                val shutdownFn = CL.D_Func(
174                      [], CL.voidTy, RN.shutdown,                      [], CL.voidTy, N.shutdown,
175                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.worldTy), "wrld")],                      [CL.PARAM([], CL.T_Ptr(CL.T_Named N.worldTy), "wrld")],
176                      CL.S_Block[])                      CL.S_Block[])
177                in                in
178                  topDecls := shutdownFn :: initFn :: !topDecls                  topDecls := shutdownFn :: initFn :: !topDecls
# Line 189  Line 189 
189              } = let              } = let
190                val name = Atom.toString strand                val name = Atom.toString strand
191                val nDims = List.length iters                val nDims = List.length iters
192                val worldTy = CL.T_Ptr(CL.T_Named RN.worldTy)                val worldTy = CL.T_Ptr(CL.T_Named N.worldTy)
193                fun mapi f xs = let                fun mapi f xs = let
194                      fun mapf (_, []) = []                      fun mapf (_, []) = []
195                        | mapf (i, x::xs) = f(i, x) :: mapf(i+1, xs)                        | mapf (i, x::xs) = f(i, x) :: mapf(i+1, xs)
# Line 208  Line 208 
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(N.allocInitially, [
212                              CL.mkVar "ProgramName",                              CL.mkVar "ProgramName",
213                              CL.mkUnOp(CL.%&, CL.E_Var(RN.strandDesc name)),                              CL.mkUnOp(CL.%&, CL.E_Var(N.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),
216                              CL.E_Var "base",                              CL.E_Var "base",
# Line 219  Line 219 
219                      ]                      ]
220              (* create the loop nest for the initially iterations *)              (* create the loop nest for the initially iterations *)
221                val indexVar = "ix"                val indexVar = "ix"
222                val strandTy = CL.T_Ptr(CL.T_Named(RN.strandTy name))                val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))
223                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [
224                        CL.mkDecl(strandTy, "sp",                        CL.mkDecl(strandTy, "sp",
225                          SOME(CL.I_Exp(                          SOME(CL.I_Exp(
226                            CL.E_Cast(strandTy,                            CL.E_Cast(strandTy,
227                            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]))))),
228                        CL.mkCall(RN.strandInit name, CL.E_Var "sp" :: args),                        CL.mkCall(N.strandInit name, CL.E_Var "sp" :: args),
229                        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)))
230                      ])                      ])
231                  | mkLoopNest ((ToC.V(ty, param), lo, hi)::iters) = let                  | mkLoopNest ((ToC.V(ty, param), lo, hi)::iters) = let
# Line 247  Line 247 
247                      allocCode @                      allocCode @
248                      iterCode @                      iterCode @
249                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])
250                val initFn = CL.D_Func([], worldTy, RN.initially, [], body)                val initFn = CL.D_Func([], worldTy, N.initially, [], body)
251                in                in
252                  initially := initFn                  initially := initFn
253                end                end
# Line 268  Line 268 
268                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
269                      val outState = CL.mkIndirect(CL.mkVar "self", x)                      val outState = CL.mkIndirect(CL.mkVar "self", x)
270                      val prArgs = (case ty                      val prArgs = (case ty
271                             of Ty.IVecTy 1 => [CL.E_Str(!RN.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]
272                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
273                                  val fmt = CL.E_Str(                                  val fmt = CL.E_Str(
274                                        String.concatWith " " (List.tabulate(d, fn _ => !RN.gIntFormat))                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))
275                                        ^ "\n")                                        ^ "\n")
276                                  val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))                                  val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))
277                                  in                                  in
# Line 295  Line 295 
295              (* the strand's descriptor object *)              (* the strand's descriptor object *)
296                val descI = let                val descI = let
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                        val SOME(outTy, _) = !output
299                      in                      in
300                        CL.I_Struct[                        CL.I_Struct[
301                            ("name", CL.I_Exp(CL.mkStr name)),                            ("name", CL.I_Exp(CL.mkStr name)),
302                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(N.strandTy name)))),
303    (*
304                              ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),
305    *)
306                            ("update", fnPtr("update_method_t", name ^ "_update")),                            ("update", fnPtr("update_method_t", name ^ "_update")),
307                            ("print", fnPtr("print_method_t", prFnName))                            ("print", fnPtr("print_method_t", prFnName))
308                          ]                          ]
309                      end                      end
310                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)
311                in                in
312                  selfTyDef :: List.rev (desc :: prFn :: !code)                  selfTyDef :: List.rev (desc :: prFn :: !code)
313                end                end
# Line 311  Line 315 
315        (* generate the table of strand descriptors *)        (* generate the table of strand descriptors *)
316          fun genStrandTable (ppStrm, strands) = let          fun genStrandTable (ppStrm, strands) = let
317                val nStrands = length strands                val nStrands = length strands
318                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)))
319                fun genInits (_, []) = []                fun genInits (_, []) = []
320                  | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)                  | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)
321                fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)                fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)
322                in                in
323                  ppDecl (CL.D_Var([], CL.int32, RN.numStrands,                  ppDecl (CL.D_Var([], CL.int32, N.numStrands,
324                    SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nStrands, CL.int32)))));                    SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nStrands, CL.int32)))));
325                  ppDecl (CL.D_Var([],                  ppDecl (CL.D_Var([],
326                    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),
327                    RN.strands,                    N.strands,
328                    SOME(CL.I_Array(genInits (0, strands)))))                    SOME(CL.I_Array(genInits (0, strands)))))
329                end                end
330    
# Line 377  Line 381 
381                val name = Atom.toString strandId                val name = Atom.toString strandId
382                val strand = Strand{                val strand = Strand{
383                        name = name,                        name = name,
384                        tyName = RN.strandTy name,                        tyName = N.strandTy name,
385                        state = ref [],                        state = ref [],
386                        output = ref NONE,                        output = ref NONE,
387                        code = ref []                        code = ref []
# Line 394  Line 398 
398         * parameters.         * parameters.
399         *)         *)
400          fun init (Strand{name, tyName, code, ...}, params, init) = let          fun init (Strand{name, tyName, code, ...}, params, init) = let
401                val fName = RN.strandInit name                val fName = N.strandInit name
402                val params =                val params =
403                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
404                        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.1375  
changed lines
  Added in v.1376

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