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 1715, Sat Mar 10 14:42:07 2012 UTC revision 1716, Sat Mar 10 17:08:11 2012 UTC
# Line 13  Line 13 
13      structure CL = CLang      structure CL = CLang
14      structure N = CNames      structure N = CNames
15    
16        type target_desc = TargetUtil.target_desc
17    
18    (* variable translation *)    (* variable translation *)
19      structure TrVar =      structure TrVar =
20        struct        struct
# Line 46  Line 48 
48        }        }
49    
50      datatype program = Prog of {      datatype program = Prog of {
51          tgt : TargetUtil.target_desc,   (* info about target *)          tgt : target_desc,              (* info about target *)
52          globals : CL.decl list ref,          globals : CL.decl list ref,
53          topDecls : CL.decl list ref,          topDecls : CL.decl list ref,
54          strands : strand AtomTable.hash_table,          strands : strand AtomTable.hash_table,
# Line 138  Line 140 
140    (* programs *)    (* programs *)
141      structure Program =      structure Program =
142        struct        struct
143          fun new (tgt : TargetUtil.target_desc) = let          fun new (tgt : target_desc) = let
144    (*
145                val includes = if #exec tgt                val includes = if #exec tgt
146                      then ["#include \"Diderot/diderot.h\"\n"]                      then ["#include \"Diderot/diderot.h\"\n"]
147                      else [                      else [
# Line 146  Line 149 
149                          OS.Path.joinBaseExt{base= #outBase tgt, ext= SOME "h"},                          OS.Path.joinBaseExt{base= #outBase tgt, ext= SOME "h"},
150                          "\"\n"                          "\"\n"
151                        ]                        ]
152    *)
153                in                in
154                  N.initTargetSpec {double= #double tgt, long=false};                  N.initTargetSpec {double= #double tgt, long=false};
155                  Prog{                  Prog{
156                      tgt = tgt,                      tgt = tgt,
157                        globals = ref [
158                            CL.D_Var(["static"], CL.charPtr, "ProgramName",
159                              SOME(CL.I_Exp(CL.mkStr(#srcFile tgt))))
160                          ],
161    (*
162                      globals = ref [ (* NOTE: in reverse order! *)                      globals = ref [ (* NOTE: in reverse order! *)
163                          CL.D_Var(["static"], CL.charPtr, "ProgramName",                          CL.D_Var(["static"], CL.charPtr, "ProgramName",
164                            SOME(CL.I_Exp(CL.mkStr(#srcFile tgt)))),                            SOME(CL.I_Exp(CL.mkStr(#srcFile tgt)))),
# Line 159  Line 168 
168                              concat["#define " ^ TargetUtil.targetDef tgt, "\n"]                              concat["#define " ^ TargetUtil.targetDef tgt, "\n"]
169                            ] @ includes)                            ] @ includes)
170                        ],                        ],
171    *)
172                      topDecls = ref [],                      topDecls = ref [],
173                      strands = AtomTable.mkTable (16, Fail "strand table"),                      strands = AtomTable.mkTable (16, Fail "strand table"),
174                      nAxes = ref(SOME ~1),                      nAxes = ref(SOME ~1),
# Line 261  Line 271 
271                end                end
272    
273        (***** OUTPUT *****)        (***** OUTPUT *****)
274          fun genStrand (Strand{name, tyName, state, output, code}) = let  
275            fun genStrand (tgt : target_desc, Strand{name, tyName, state, output, code}) = let
276              (* the type declaration for the strand's state struct *)              (* the type declaration for the strand's state struct *)
277                val selfTyDef = CL.D_StructDef(                val selfTyDef = CL.D_StructDef(
278                          SOME(concat[#namespace tgt, "struct_", name]),
279                        List.rev (List.map (fn CL.V(ty, x) => (ty, x)) state),                        List.rev (List.map (fn CL.V(ty, x) => (ty, x)) state),
280                        tyName)                        NONE)
281              (* the type and access expression for the strand's output variable *)              (* the type and access expression for the strand's output variable *)
282                val (outTy, outState) = (#1 output, CL.mkIndirect(CL.mkVar "self", #2 output))                val (outTy, outState) = (#1 output, CL.mkIndirect(CL.mkVar "self", #2 output))
             (* the print function *)  
               val prFnName = concat[name, "_Print"]  
               val prFn = let  
                     val params = [  
                           CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),  
                           CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")  
                         ]  
                     val prArgs = (case outTy  
                            of Ty.IntTy => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]  
                             | Ty.TensorTy[] => [CL.E_Str "%f\n", outState]  
                             | Ty.TensorTy[d] => let  
                                 val fmt = CL.E_Str(  
                                       String.concatWith " " (List.tabulate(d, fn _ => "%f"))  
                                       ^ "\n")  
                                 val args = List.tabulate (d, fn i => ToC.vecIndex(outState, d, i))  
                                 in  
                                   fmt :: args  
                                 end  
                             | Ty.SeqTy(Ty.IntTy, d) => let  
                                 val fmt = CL.E_Str(  
                                       String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))  
                                       ^ "\n")  
                                 val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))  
                                 in  
                                   fmt :: args  
                                 end  
                             | Ty.DynSeqTy ty => [] (* FIXME *)  
                             | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString outTy)  
                           (* end case *))  
                     in  
                       CL.D_Func(["static"], CL.voidTy, prFnName, params,  
                         CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs))  
                     end  
             (* the output function *)  
               val outFnName = concat[name, "_Output"]  
               val outFn = let  
                     val params = [  
                           CL.PARAM([], CL.T_Ptr CL.voidTy, "outS"),  
                           CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")  
                         ]  
                   (* get address of output variable *)  
                     val outState = CL.mkUnOp(CL.%&, outState)  
                     in  
                       CL.D_Func(["static"], CL.voidTy, outFnName, params,  
                         CL.mkCall("memcpy", [CL.mkVar "outS", outState, CL.mkSizeof(ToC.trType outTy)] ))  
                     end  
283              (* the strand's descriptor object *)              (* the strand's descriptor object *)
284                val descI = let                val descI = let
285                      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))
# Line 323  Line 289 
289                        CL.I_Struct[                        CL.I_Struct[
290                            ("name", CL.I_Exp(CL.mkStr name)),                            ("name", CL.I_Exp(CL.mkStr name)),
291                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(N.strandTy name)))),                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(N.strandTy name)))),
                           ("outputSzb", CL.I_Exp(CL.mkInt nrrdSize)),  
                           ("nrrdSzb", CL.I_Exp(CL.mkInt nrrdSize)),  
                           ("nrrdType", CL.I_Exp(CL.mkInt nrrdTy)),  
 (* FIXME: should use StrandUtil.nameToString here *)  
292                            ("update", fnPtr("update_method_t", name ^ "_Update")),                            ("update", fnPtr("update_method_t", name ^ "_Update")),
293                            ("stabilize", fnPtr("stabilize_method_t", name ^ "_Stabilize")),                            ("stabilize", fnPtr("stabilize_method_t", name ^ "_Stabilize"))
                           ("print", fnPtr("print_method_t", prFnName)),  
                           ("output", fnPtr("output_method_t", outFnName))  
294                          ]                          ]
295                      end                      end
296                val desc = CL.D_Var([], CL.T_Named N.strandDescTy, N.strandDesc name, SOME descI)                val desc = CL.D_Var([], CL.T_Named N.strandDescTy, N.strandDesc name, SOME descI)
297                in                in
298                  selfTyDef :: List.rev (desc :: prFn :: outFn :: !code)                  selfTyDef :: List.rev (desc :: !code)
299                end                end
300    
301    (* FIXME: this function will also be used for other targets, so we should pull it into a
302     * utility module in c-util.
303     *)
304          (* generate the struct declaration for the world representation *)
305            fun genWorldStruct (tgt : target_desc, Strand{tyName, ...}) = CL.D_StructDef(
306                  SOME(#namespace tgt ^ "struct_world"),
307                  [
308                      (CL.T_Ptr(CL.T_Named "const char"),           "name"),
309                      (CL.charPtr,                                  "err"),
310                      (CL.boolTy,                                   "isArray"),
311                      (CL.uint32,                                   "nStrands"),
312                      (CL.T_Ptr(CL.T_Named "Strand_t"),             "strandDesc"),
313                      (CL.uint32,                                   "nAxes"),
314                      (CL.T_Ptr CL.uint32,                          "base"),
315                      (CL.T_Ptr CL.uint32,                          "size"),
316                      (CL.uint32,                                   "numStrands"),
317                      (CL.T_Ptr CL.uint8,                           "status"),
318                      (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),       "inState"),
319                      (CL.T_Ptr(CL.T_Ptr(CL.T_Named tyName)),       "outState")
320                    ],
321                  NONE)
322    
323        (* generate the table of strand descriptors *)        (* generate the table of strand descriptors *)
324          fun genStrandTable (ppStrm, strands) = let          fun ppStrandTable (ppStrm, strands) = let
325                val nStrands = length strands                val nStrands = length strands
326                fun genInit (Strand{name, ...}) = CL.I_Exp(CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)))                fun genInit (Strand{name, ...}) = CL.I_Exp(CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)))
327                fun genInits (_, []) = []                fun genInits (_, []) = []
# Line 355  Line 337 
337                end                end
338    
339          fun genExecSrc (baseName, prog) = let          fun genExecSrc (baseName, prog) = let
340                val Prog{globals, topDecls, strands, initially, ...} = prog                val Prog{tgt, globals, topDecls, strands, initially, ...} = prog
341                val fileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}                val fileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}
342                val outS = TextIO.openOut fileName                val outS = TextIO.openOut fileName
343                val ppStrm = PrintAsC.new outS                val ppStrm = PrintAsC.new outS
# Line 364  Line 346 
346                in                in
347                  List.app ppDecl (List.rev (!globals));                  List.app ppDecl (List.rev (!globals));
348                  List.app ppDecl (List.rev (!topDecls));                  List.app ppDecl (List.rev (!topDecls));
349                  List.app (fn strand => List.app ppDecl (genStrand strand)) strands;                  List.app (fn strand => List.app ppDecl (genStrand(tgt, strand))) strands;
350                  genStrandTable (ppStrm, strands);                  ppStrandTable (ppStrm, strands);
351                  ppDecl (!initially);                  ppDecl (!initially);
352                  PrintAsC.close ppStrm;                  PrintAsC.close ppStrm;
353                  TextIO.closeOut outS                  TextIO.closeOut outS
# Line 374  Line 356 
356          fun condCons (true, x, xs) = x::xs          fun condCons (true, x, xs) = x::xs
357            | condCons (false, _, xs) = xs            | condCons (false, _, xs) = xs
358    
359          fun compile (tgt : TargetUtil.target_desc, basename) = let          fun compile (tgt : target_desc, basename) = let
360              (* generate the C compiler flags *)              (* generate the C compiler flags *)
361                val cflags = ["-I" ^ Paths.diderotInclude, "-I" ^ Paths.teemInclude]                val cflags = ["-I" ^ Paths.diderotInclude, "-I" ^ Paths.teemInclude]
362                val cflags = condCons (#parallel tgt, #pthread Paths.cflags, cflags)                val cflags = condCons (#parallel tgt, #pthread Paths.cflags, cflags)
# Line 386  Line 368 
368                  RunCC.compile (basename, cflags)                  RunCC.compile (basename, cflags)
369                end                end
370    
371          fun ldFlags (tgt : TargetUtil.target_desc) = let          fun ldFlags (tgt : target_desc) = let
372                val extraLibs = condCons (#parallel tgt, #pthread Paths.extraLibs, [])                val extraLibs = condCons (#parallel tgt, #pthread Paths.extraLibs, [])
373                val extraLibs = Paths.teemLinkFlags @ #base Paths.extraLibs :: extraLibs                val extraLibs = Paths.teemLinkFlags @ #base Paths.extraLibs :: extraLibs
374                val rtLib = TargetUtil.runtimeName tgt                val rtLib = TargetUtil.runtimeName tgt
# Line 406  Line 388 
388                  RunCC.linkExec (basename, ldFlags tgt)                  RunCC.linkExec (basename, ldFlags tgt)
389                end                end
390    
391          fun genLibSrc (baseName, Prog{tgt, globals, strands, nAxes, ...}) = let          fun outputLibSrc (baseName, Prog{tgt, globals, strands, nAxes, ...}) = let
392                val [Strand{state, output, ...}] = AtomTable.listItems strands                val [strand as Strand{name, tyName, state, output, ...}] = AtomTable.listItems strands
393                val outputs = List.map (GenOutput.gen (tgt, !nAxes)) [output]                val outputs = List.map (GenOutput.gen (tgt, !nAxes)) [output]
394              (* output to C file *)              (* output to C file *)
395                val fileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}                val fileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}
# Line 415  Line 397 
397                val ppStrm = PrintAsC.new outS                val ppStrm = PrintAsC.new outS
398                fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)                fun ppDecl dcl = PrintAsC.output(ppStrm, dcl)
399                in                in
400    (* FIXME: use a fragment for this part of the file *)
401                    ppDecl (CL.D_Verbatim [
402                        "#include \"", OS.Path.joinBaseExt{base= #outBase tgt, ext= SOME "h"}, "\"\n",
403                        "#include \"teem/nrrd.h\"\n",
404                        "#include \"teem/biff.h\"\n",
405                        "typedef struct ", #namespace tgt, "struct_", name, " ", tyName, ";\n"
406                      ]);
407                    ppDecl (genWorldStruct(tgt, strand));
408                  List.app ppDecl (List.rev (!globals));                  List.app ppDecl (List.rev (!globals));
409                    List.app ppDecl (genStrand(tgt, strand));
410                  List.app ppDecl outputs;                  List.app ppDecl outputs;
411                  PrintAsC.close ppStrm;                  PrintAsC.close ppStrm;
412                  TextIO.closeOut outS                  TextIO.closeOut outS
# Line 433  Line 424 
424                      outputs = [output]                      outputs = [output]
425                    };                    };
426                (* *)                (* *)
427                  genLibSrc (basename, prog);                  outputLibSrc (basename, prog);
428                (* compile and link *)                (* compile and link *)
429                  compile (tgt, basename);                  compile (tgt, basename);
430                  RunCC.linkLib (basename, ldFlags tgt)                  RunCC.linkLib (basename, ldFlags tgt)

Legend:
Removed from v.1715  
changed lines
  Added in v.1716

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