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

SCM Repository

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

Diff of /branches/pure-cfg/src/compiler/c-target/c-target.sml

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

revision 623, Tue Mar 15 17:04:53 2011 UTC revision 624, Tue Mar 15 21:23:04 2011 UTC
# Line 30  Line 30 
30      datatype program = Prog of {      datatype program = Prog of {
31          globals : CL.decl list ref,          globals : CL.decl list ref,
32          topDecls : CL.decl list ref,          topDecls : CL.decl list ref,
33          strands : strand list ref          strands : strand AtomTable.hash_table,
34            initially : CL.decl ref
35        }        }
36    
37    (* for SSE, we have 128-bit vectors *)    (* for SSE, we have 128-bit vectors *)
# Line 94  Line 95 
95                      "#include \"Diderot/diderot.h\""                      "#include \"Diderot/diderot.h\""
96                    ]],                    ]],
97                topDecls = ref [],                topDecls = ref [],
98                strands = ref []                strands = AtomTable.mkTable (16, Fail "strand table"),
99                  initially = ref(CL.D_Comment["missing initially"])
100              })              })
101    
102    (* register the global initialization part of a program *)    (* register the global initialization part of a program *)
# Line 106  Line 108 
108    
109    (* create and register the initially function for a program *)    (* create and register the initially function for a program *)
110      fun initially {      fun initially {
111              prog = Prog{topDecls, ...},              prog = Prog{strands, initially, ...},
112              isArray : bool,              isArray : bool,
113              iterPrefix : stm list,              iterPrefix : stm,
114              iters : (var * exp * exp) list,              iters : (var * exp * exp) list,
115              createPrefix : stm list,              createPrefix : stm,
116              strand=Strand{name, ...},              strand : Atom.atom,
117              args : exp list              args : exp list
118            } = let            } = let
119              val iterPrefix = (case iterPrefix
120                     of CL.S_Block stms => stms
121                      | stm => [stm]
122                    (* end case *))
123              val createPrefix = (case createPrefix
124                     of CL.S_Block stms => stms
125                      | stm => [stm]
126                    (* end case *))
127              val name = Atom.toString strand
128            val nDims = List.length iters            val nDims = List.length iters
129            val worldTy = CL.T_Ptr(CL.T_Named RN.worldTy)            val worldTy = CL.T_Ptr(CL.T_Named RN.worldTy)
130            fun mapi f xs = let            fun mapi f xs = let
# Line 145  Line 156 
156            fun mkLoopNest [] = CL.mkBlock(createPrefix @ [            fun mkLoopNest [] = CL.mkBlock(createPrefix @ [
157                    CL.S_Decl(CL.T_Ptr(CL.T_Named(RN.strandTy name)), "sp",                    CL.S_Decl(CL.T_Ptr(CL.T_Named(RN.strandTy name)), "sp",
158                      SOME(CL.I_Exp(CL.E_Apply(RN.inState, [CL.E_Var "wrld", CL.E_Var indexVar])))),                      SOME(CL.I_Exp(CL.E_Apply(RN.inState, [CL.E_Var "wrld", CL.E_Var indexVar])))),
159                    CL.S_Call(RN.strandInit name, CL.E_Var "sp" :: List.map (fn (E(e, _)) => e) args)                    CL.S_Call(RN.strandInit name, CL.E_Var "sp" :: List.map (fn (E(e, _)) => e) args),
160                      CL.S_Assign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))
161                  ])                  ])
162              | mkLoopNest ((V(ty, param), E(lo,_), E(hi, _))::iters) = let              | mkLoopNest ((V(ty, param), E(lo,_), E(hi, _))::iters) = let
163                  val body = mkLoopNest iters                  val body = mkLoopNest iters
# Line 164  Line 176 
176            val body = CL.mkBlock(iterPrefix @ allocCode @ iterCode @ [CL.S_Return(SOME(CL.E_Var "wrld"))])            val body = CL.mkBlock(iterPrefix @ allocCode @ iterCode @ [CL.S_Return(SOME(CL.E_Var "wrld"))])
177            val initFn = CL.D_Func([], worldTy, RN.initially, [], body)            val initFn = CL.D_Func([], worldTy, RN.initially, [], body)
178            in            in
179              topDecls := initFn :: !topDecls              initially := initFn
180            end            end
181    
182      structure Var =      structure Var =
# Line 459  Line 471 
471      structure Strand =      structure Strand =
472        struct        struct
473          fun define (Prog{strands, ...}, strandId) = let          fun define (Prog{strands, ...}, strandId) = let
474                  val name = Atom.toString strandId
475                val strand = Strand{                val strand = Strand{
476                        name = strandId,                        name = name,
477                        tyName = RN.strandTy strandId,                        tyName = RN.strandTy name,
478                        state = ref [],                        state = ref [],
479                        code = ref []                        code = ref []
480                      }                      }
481                in                in
482                  strands := strand :: !strands;                  AtomTable.insert strands (strandId, strand);
483                  strand                  strand
484                end                end
485    
486          (* return the strand with the given name *)
487            fun lookup (Prog{strands, ...}, strandId) = AtomTable.lookup strands strandId
488    
489        (* register the strand-state initialization code.  The variables are the strand        (* register the strand-state initialization code.  The variables are the strand
490         * parameters.         * parameters.
491         *)         *)
# Line 497  Line 513 
513        end (* Strand *)        end (* Strand *)
514    
515      fun genStrand (Strand{name, tyName, state, code}) = let      fun genStrand (Strand{name, tyName, state, code}) = let
516            (* the type declaration for the strand's state struct *)
517            val selfTyDef = CL.D_StructDef(            val selfTyDef = CL.D_StructDef(
518                    List.rev (List.map (fn V(ty, x) => (cvtTy ty, x)) (!state)),                    List.rev (List.map (fn V(ty, x) => (cvtTy ty, x)) (!state)),
519                    tyName)                    tyName)
520            in          (* the strand's descriptor object *)
521              selfTyDef :: List.rev (!code)            val descI = let
           end  
   
   (* generate the table of strand descriptors *)  
     fun genStrandTable (ppStrm, strands) = let  
           val nStrands = length strands  
           fun genInit (Strand{name, tyName, code, ...}) = let  
522                  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))
523                  in                  in
524                    CL.I_Struct[                    CL.I_Struct[
525                        ("name", CL.I_Exp(CL.E_Str name)),                        ("name", CL.I_Exp(CL.E_Str name)),
526                        ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),                        ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),
                       ("init", fnPtr("strand_init_t", RN.strandInit name)),  
527                        ("update", fnPtr("update_method_t", name ^ "_update"))                        ("update", fnPtr("update_method_t", name ^ "_update"))
528                      ]                      ]
529                  end                  end
530              val desc = CL.D_Var([], CL.T_Named RN.strandDescTy, RN.strandDesc name, SOME descI)
531              in
532                selfTyDef :: List.rev (desc :: !code)
533              end
534    
535      (* generate the table of strand descriptors *)
536        fun genStrandTable (ppStrm, strands) = let
537              val nStrands = length strands
538              fun genInit (Strand{name, ...}) = CL.I_Exp(CL.mkUnOp(CL.%&, CL.E_Var(RN.strandDesc name)))
539            fun genInits (_, []) = []            fun genInits (_, []) = []
540              | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)              | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)
541            fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)            fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)
542            in            in
543              ppDecl (CL.D_Var([], CL.int32, RN.numStrands,              ppDecl (CL.D_Var([], CL.int32, RN.numStrands,
544                SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nStrands, CL.int32)))));                SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nStrands, CL.int32)))));
545              ppDecl (CL.D_Var([], CL.T_Array(CL.T_Named RN.strandDescTy, SOME nStrands), RN.strands,              ppDecl (CL.D_Var([],
546                  CL.T_Array(CL.T_Ptr(CL.T_Named RN.strandDescTy), SOME nStrands),
547                  RN.strands,
548                SOME(CL.I_Array(genInits (0, strands)))))                SOME(CL.I_Array(genInits (0, strands)))))
549            end            end
550    
551      fun generate (baseName, Prog{globals, topDecls, strands}) = let      fun generate (baseName, Prog{globals, topDecls, strands, initially}) = let
552            val fileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}            val fileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}
553            val outS = TextIO.openOut fileName            val outS = TextIO.openOut fileName
554            val ppStrm = PrintAsC.new outS            val ppStrm = PrintAsC.new outS
555            fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)            fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)
556              val strands = AtomTable.listItems strands
557            in            in
558              List.app ppDecl (List.rev (!globals));              List.app ppDecl (List.rev (!globals));
559              List.app ppDecl (List.rev (!topDecls));              List.app ppDecl (List.rev (!topDecls));
560              List.app (fn strand => List.app ppDecl (genStrand strand)) (!strands);              List.app (fn strand => List.app ppDecl (genStrand strand)) strands;
561              genStrandTable (ppStrm, !strands);              genStrandTable (ppStrm, strands);
562                ppDecl (!initially);
563              PrintAsC.close ppStrm;              PrintAsC.close ppStrm;
564              TextIO.closeOut outS              TextIO.closeOut outS
565            end            end

Legend:
Removed from v.623  
changed lines
  Added in v.624

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