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

SCM Repository

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

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

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

revision 1421, Thu Jun 30 21:22:28 2011 UTC revision 1432, Tue Jul 5 20:42:33 2011 UTC
# Line 30  Line 30 
30    
31     (* translate TreeIL types to shadow types *)     (* translate TreeIL types to shadow types *)
32      fun convertToShadow (ty,name) = (case ty      fun convertToShadow (ty,name) = (case ty
33             of Ty.IVecTy 1 => CL.mkAssign(CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),             of Ty.IVecTy 1 => CL.mkAssign(
34                    CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
35                                  CL.mkIndirect(CL.mkVar(RN.globalsVarName), name))                                  CL.mkIndirect(CL.mkVar(RN.globalsVarName), name))
36              | Ty.TensorTy[n]=> CL.mkCall(RN.convertToShadowVec n,[              | Ty.TensorTy[n]=> CL.mkCall(RN.convertToShadowVec n,[
37                           CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),                           CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
38                            CL.mkIndirect(CL.mkVar(RN.globalsVarName), name)])                    CL.mkIndirect(CL.mkVar(RN.globalsVarName), name)
39                    ])
40              | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) =>  CL.mkCall(RN.shadowImageFunc dim, [              | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) =>  CL.mkCall(RN.shadowImageFunc dim, [
41                           CL.mkVar "context",                           CL.mkVar "context",
42                           CL.mkUnOp(CL.%&,CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name)),                           CL.mkUnOp(CL.%&,CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name)),
# Line 42  Line 44 
44                           ])                           ])
45              | Ty.TensorTy[n, m] => CL.mkCall(RN.convertToShadowMat(m,n),[              | Ty.TensorTy[n, m] => CL.mkCall(RN.convertToShadowMat(m,n),[
46                           CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),                           CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
47                            CL.mkIndirect(CL.mkVar(RN.globalsVarName), name)])                    CL.mkIndirect(CL.mkVar(RN.globalsVarName), name)
48              | _ => CL.mkAssign(CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),                  ])
49                | _ => CL.mkAssign(
50                    CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
51                                  CL.mkIndirect(CL.mkVar(RN.globalsVarName), name))                                  CL.mkIndirect(CL.mkVar(RN.globalsVarName), name))
52             (*end case *))             (*end case *))
53    
# Line 98  Line 102 
102    
103    (* variable or field that is mirrored between host and GPU *)    (* variable or field that is mirrored between host and GPU *)
104      type mirror_var = {      type mirror_var = {
105    (* FIXME: perhaps it would be cleaner to just track the TreeIL type of the variable? *)
106              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)
107              shadowTy : CL.ty,           (* host-side shadow type of GPU type *)              shadowTy : CL.ty,           (* host-side shadow type of GPU type *)
108              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)
109              hToS: stm,                                  (*the statement that converts the variable to its shadow representation *)              hToS: stm,                  (* the statement that converts the variable to its *)
110                                            (* shadow representation *)
111              var : CL.var                (* variable name *)              var : CL.var                (* variable name *)
112            }            }
113    
# Line 333  Line 339 
339                              CL.E_Var "size"                              CL.E_Var "size"
340                            ]))))                            ]))))
341                      ]                      ]
             (* create the loop nest for the initially iterations  
               val indexVar = "ix"  
               val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))  
               fun mkLoopNest [] = CL.mkBlock(createPrefix @ [  
                       CL.mkDecl(strandTy, "sp",  
                         SOME(CL.I_Exp(  
                           CL.E_Cast(strandTy,  
                           CL.E_Apply(N.inState, [CL.E_Var "wrld", CL.E_Var indexVar]))))),  
                       CL.mkCall(N.strandInit name,  
                         CL.E_Var RN.globalsVarName :: CL.E_Var "sp" :: args),  
                       CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))  
                     ])  
                 | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let  
                     val body = mkLoopNest iters  
                     in  
                       CL.mkFor(  
                         [(ty, param, lo)],  
                         CL.mkBinOp(CL.E_Var param, CL.#<=, hi),  
                         [CL.mkPostOp(CL.E_Var param, CL.^++)],  
                         body)  
                     end  
               val iterCode = [  
                       CL.mkComment["initially"],  
                       CL.mkDecl(CL.uint32, indexVar, SOME(CL.I_Exp(CL.E_Int(0, CL.uint32)))),  
                       mkLoopNest iters  
                     ] *)  
342                val body = CL.mkBlock(                val body = CL.mkBlock(
343                      iterPrefix @                      iterPrefix @
344                      allocCode @                      allocCode @
# Line 370  Line 350 
350                end                end
351    
352        (***** OUTPUT *****)        (***** OUTPUT *****)
353    (* FIXME: I think that the iteration and test for stable strands can be moved into the runtime, which
354     * will make the print function compatible with the C target version.
355     *)
356          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let
357              (* the print function *)              (* the print function *)
358                val prFnName = concat[name, "Print"]                val prFnName = concat[name, "Print"]
359                val prFn = let                val prFn = let
360                      val params = [                      val params = [
361                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
                             CL.PARAM([], CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)),"status"),  
                             CL.PARAM([], CL.intTy,"numStrands"),  
362                              CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")                              CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")
363                            ]                            ]
364                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
365                      val outState = CL.mkSelect(CL.mkSubscript(CL.mkVar "self", CL.E_Var "i"), x)                      val outState = CL.mkIndirect(CL.mkVar "self", x)
366                      val prArgs = (case ty                      val prArgs = (case ty
367                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]
368                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
369                                    fun sel i = CL.mkSubscript(CL.mkSelect(outState, "s"),
370                                          CL.mkInt(IntInf.fromInt i))
371                                  val fmt = CL.mkStr(                                  val fmt = CL.mkStr(
372                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))
373                                        ^ "\n")                                        ^ "\n")
374                                  val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))                                  val args = List.tabulate (d, sel)
375                                  in                                  in
376                                    fmt :: args                                    fmt :: args
377                                  end                                  end
378                              | Ty.TensorTy[] => [CL.mkStr "%f\n", outState]                              | Ty.TensorTy[] => [CL.mkStr "%f\n", outState]
379                              | Ty.TensorTy[d] => let                              | Ty.TensorTy[d] => let
380                                    fun sel i = CL.mkSubscript(CL.mkSelect(outState, "s"),
381                                          CL.mkInt(IntInf.fromInt i))
382                                  val fmt = CL.mkStr(                                  val fmt = CL.mkStr(
383                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))
384                                        ^ "\n")                                        ^ "\n")
385                                  val args = List.tabulate (d, fn i => ToC.vecIndex(outState, d, i))                                  val args = List.tabulate (d, sel)
386                                  in                                  in
387                                    fmt :: args                                    fmt :: args
388                                  end                                  end
389                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)
390                            (* end case *))                            (* end case *))
                     val forBody = CL.mkIfThen(  
                           CL.mkBinOp(CL.mkSubscript(CL.E_Var "status",CL.E_Var "i"), CL.#==, CL.E_Var "DIDEROT_STABILIZE"),  
                           CL.mkBlock([CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs)]))  
                     val body =  CL.mkFor(  
                         [(CL.intTy, "i", CL.mkInt 0)],  
                         CL.mkBinOp(CL.E_Var "i", CL.#<, CL.E_Var "numStrands"),  
                         [CL.mkPostOp(CL.E_Var "i", CL.^++)],  
                         forBody)  
391                      in                      in
392                        CL.D_Func(["static"], CL.voidTy, prFnName, params, body)                        CL.D_Func(["static"], CL.voidTy, prFnName, params,
393                            CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs))
394                      end                      end
395                in                in
396                  prFn                  prFn
397                end                end
398    
399          fun genStrandTyDef (targetTy, Strand{tyName, state,...}) =          fun genStrandTyDef (targetTy, Strand{state,...},tyName) =
400              (* the type declaration for the strand's state struct *)              (* the type declaration for the strand's state struct *)
401                CL.D_StructDef(                CL.D_StructDef(
402                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),
# Line 426  Line 404 
404    
405        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
406          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let
407                val globalBuffErr = "error creating OpenCL global buffer"                val globalBuffErr = "error creating OpenCL global buffer\n"
408                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),
409                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),
410                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
# Line 456  Line 434 
434                              CL.mkIndirect(hostVar, "data"),                              CL.mkIndirect(hostVar, "data"),
435                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
436                            ])) ::                            ])) ::
437                          errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer"]) ::                          errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer\n"]) ::
438                          genDataBuffers(globals,contextVar,errVar,errFn)                          genDataBuffers(globals,contextVar,errVar,errFn)
439                      end                      end
440                in                in
# Line 467  Line 445 
445    
446        (* generates the kernel arguments for the image data *)        (* generates the kernel arguments for the image data *)
447          fun genGlobalArguments (globals, count, kernelVar, errVar) = let          fun genGlobalArguments (globals, count, kernelVar, errVar) = let
448                val globalArgErr = "error creating OpenCL global argument"                val globalArgErr = "error creating OpenCL global argument\n"
449                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),
450                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),
451                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
# Line 485  Line 463 
463                           CL.mkPostOp(CL.E_Var count, CL.^++),                           CL.mkPostOp(CL.E_Var count, CL.^++),
464                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
465                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::
466                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument"]) ::                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument\n"]) ::
467                      genDataArguments (globals,count,kernelVar,errVar,errFn)                      genDataArguments (globals,count,kernelVar,errVar,errFn)
468                in                in
469                 [globalArgument,errorFn(globalArgErr)] @ genDataArguments(globals, count, kernelVar, errVar,errorFn)                  globalArgument :: errorFn globalArgErr ::
470                      genDataArguments(globals, count, kernelVar, errVar,errorFn)
471                end                end
472    
473        (* generates the globals buffers and arguments function *)        (* generates the globals buffers and arguments function *)
# Line 524  Line 503 
503                val inState = "strand_in"                val inState = "strand_in"
504                val outState = "strand_out"                val outState = "strand_out"
505                val tempVar = "tmp"                val tempVar = "tmp"
506                  val sizeParams = if nDims = 1 then
507                            []
508                        else if nDims = 2 then
509                            [CL.PARAM([], CL.intTy, "width")]
510                        else
511                            [CL.PARAM([], CL.intTy, "width"),CL.PARAM([], CL.intTy, "height")]
512                val params = [                val params = [
513                        globalParam(CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam(CL.T_Ptr(CL.T_Named tyName), "selfIn"),
514                        globalParam(CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam(CL.T_Ptr(CL.T_Named tyName), "selfOut"),
515                        globalParam(CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus"),                        globalParam(CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus")] @
516                        CL.PARAM([], CL.intTy, "width"),                        sizeParams @
517                        globalParam(globPtrTy, RN.globalsVarName)                        [globalParam(globPtrTy, RN.globalsVarName)] @
518                      ] @ genKeneralGlobalParams(!imgGlobals)                        genKeneralGlobalParams(!imgGlobals)
519                val thread_ids = if nDims = 1                val thread_ids = if nDims = 1
520                        then [                        then [
521                            CL.mkDecl(CL.intTy, "x",                            CL.mkDecl(CL.intTy, "x",
# Line 539  Line 524 
524                      else if nDims = 2                      else if nDims = 2
525                        then [                        then [
526                            CL.mkDecl(CL.intTy, "x",                            CL.mkDecl(CL.intTy, "x",
527                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1])))),
528                              CL.mkDecl(CL.intTy, "y",
529                                SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0]))))
530                            ]
531                          else [
532                              CL.mkDecl(CL.intTy, "x",
533                                SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1])))),
534                            CL.mkDecl(CL.intTy, "y",                            CL.mkDecl(CL.intTy, "y",
535                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1]))))                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),
536                              CL.mkDecl(CL.intTy, "z",
537                                SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 2]))))
538                          ]                          ]
                     else raise Fail "nDims > 2"  
539                val strandDecl = [                val strandDecl = [
540                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), inState, NONE),                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), inState, NONE),
541                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), outState, NONE),                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), outState, NONE),
# Line 559  Line 551 
551                                   CL.mkAssign(CL.E_Var outState, CL.E_Var tempVar)]))                                   CL.mkAssign(CL.E_Var outState, CL.E_Var tempVar)]))
552                val barrierStm = CL.mkCall("barrier",[CL.E_Var "CLK_LOCAL_MEM_FENCE"])                val barrierStm = CL.mkCall("barrier",[CL.E_Var "CLK_LOCAL_MEM_FENCE"])
553                val index = if nDims = 1 then                val index = if nDims = 1 then
554                          CL.mkStr "x"                          CL.mkVar "x"
555                      else                      else if nDims = 2 then
556                          CL.mkBinOp(                          CL.mkBinOp(
557                              CL.mkBinOp(CL.mkVar "x", CL.#*, CL.mkVar "width"), CL.#+, CL.mkVar "y")                              CL.mkBinOp(CL.mkVar "y", CL.#*, CL.mkVar "width"), CL.#+, CL.mkVar "x")
558                        else
559                val strandObjects =                         CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(
560                       [ CL.mkAssign(CL.mkVar inState,  CL.mkBinOp(CL.mkVar "selfIn",CL.#+,index)),                              CL.mkBinOp(CL.mkVar "z", CL.#*, CL.mkVar "width"),CL.#*, CL.mkVar "height"), CL.#+,
561                                CL.mkBinOp(CL.mkVar "y",CL.#*,CL.mkVar "height")),CL.#+,CL.mkVar "x")
562    
563                  val args = (case nDims
564                         of 1 => [CL.mkVar "x"]
565                          | 2 => [CL.mkVar "x", CL.mkVar "y"]
566                          | 3 => [CL.mkVar "x", CL.mkVar "y", CL.mkVar "z"]
567                        (* end case *))
568                  val strandObjects = [
569                          CL.mkAssign(CL.mkVar inState,  CL.mkBinOp(CL.mkVar "selfIn",CL.#+,index)),
570                         CL.mkAssign(CL.mkVar outState, CL.mkBinOp(CL.mkVar "selfOut",CL.#+,index))                         CL.mkAssign(CL.mkVar outState, CL.mkBinOp(CL.mkVar "selfOut",CL.#+,index))
571                       ]                       ]
572                  val stabalizeStm = CL.mkAssign(
573                  val stabalizeStm = CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",index),                      CL.mkSubscript(CL.mkVar "strandStatus",index),
574                                                                          CL.E_Var "status")                                                                          CL.E_Var "status")
575                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "strandStatus",index))))                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "strandStatus",index))))
576                val strandInitStm = CL.mkCall(RN.strandInit name, [                val strandInitStm = CL.mkCall(RN.strandInit name,
577                        CL.mkVar RN.globalsVarName,                        CL.mkVar RN.globalsVarName :: CL.mkVar inState :: args)
                       CL.mkVar inState,  
                       CL.mkVar "x",  
 (* FIXME: if nDims = 1, then "y" is not defined! the arguments to this call should really come from  
  * the initially code!  
  *)  
                       CL.mkVar "y"])  
578                val local_vars = thread_ids                val local_vars = thread_ids
579                      @ [imageDataDecl]                      @ [imageDataDecl]
580                      @ imageDataStms                      @ imageDataStms
# Line 630  Line 625 
625                      in                      in
626                        CL.I_Struct[                        CL.I_Struct[
627                            ("name", CL.I_Exp(CL.mkStr name)),                            ("name", CL.I_Exp(CL.mkStr name)),
628                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(N.strandTy name)))),                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),
629  (*  (*
630                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),
631  *)  *)
# Line 682  Line 677 
677                    ]));                    ]));
678                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));
679                  clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));                  clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));
680                  clppDecl (genStrandTyDef(#gpuTy, strand));                  clppDecl (genStrandTyDef(#gpuTy, strand,tyName));
681                  clppDecl  (!init_code);                  clppDecl  (!init_code);
682                  List.app clppDecl (!code);                  List.app clppDecl (!code);
683                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));
# Line 700  Line 695 
695                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));
696  (* FIXME: does this really need to be a global? *)  (* FIXME: does this really need to be a global? *)
697                  cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));                  cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));
698                  cppDecl (genStrandTyDef (#hostTy, strand));                  cppDecl (genStrandTyDef (#shadowTy, strand, tyName));
699                  cppDecl (genStrandPrint strand);                  cppDecl (genStrandPrint strand);
700                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
701                  cppDecl (genGlobalBuffersArgs (!globals,imgGlobals));                  cppDecl (genGlobalBuffersArgs (!globals,imgGlobals));
# Line 739  Line 734 
734                  RunCC.link (basename, ldOpts)                  RunCC.link (basename, ldOpts)
735                end                end
736    
737        end        end (* Program *)
738    
739    (* strands *)    (* strands *)
740      structure Strand =      structure Strand =

Legend:
Removed from v.1421  
changed lines
  Added in v.1432

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