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 1343, Tue Jun 14 16:15:33 2011 UTC revision 1382, Thu Jun 23 20:03:05 2011 UTC
# Line 15  Line 15 
15      structure ToCL = TreeToCL      structure ToCL = TreeToCL
16      structure N = CNames      structure N = CNames
17    
18      (* translate TreeIL types to shadow types *)
19        fun shadowTy ty = (case ty
20               of Ty.BoolTy => CL.T_Named "cl_bool"
21                | Ty.StringTy => raise Fail "unexpected string type"
22                | Ty.IVecTy 1 => CL.T_Named(RN.shadowIntTy ())
23                | Ty.IVecTy n => raise Fail "unexpected int vector type"
24                | Ty.TensorTy[] => CL.T_Named(RN.shadowRealTy ())
25                | Ty.TensorTy[n] => CL.T_Named(RN.shadowVecTy n)
26                | Ty.TensorTy[n, m] => CL.T_Named(RN.shadowMatTy(n,m))
27                | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.T_Named(RN.shadowImageTy dim)
28                | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])
29              (* end case *))
30    
31    (* helper functions for specifying parameters in various address spaces *)    (* helper functions for specifying parameters in various address spaces *)
32      fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)      fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)
33      fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)      fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)
# Line 64  Line 77 
77    (* variable or field that is mirrored between host and GPU *)    (* variable or field that is mirrored between host and GPU *)
78      type mirror_var = {      type mirror_var = {
79              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)
80                shadowTy : CL.ty,           (* host-side shadow type of GPU type *)
81              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)
82              var : CL.var                (* variable name *)              var : CL.var                (* variable name *)
83            }            }
# Line 142  Line 156 
156                  case scope                  case scope
157  (* NOTE: if we move strand initialization to the GPU, then we'll have to change the following code! *)  (* NOTE: if we move strand initialization to the GPU, then we'll have to change the following code! *)
158                   of StrandScope stateVars =>                   of StrandScope stateVars =>
159                        ToCL.trBlock (vMap, saveState "StrandScope" stateVars ToC.trAssign, blk)                        ToCL.trBlock (vMap, saveState "StrandScope" stateVars ToCL.trAssign, blk)
160                    | MethodScope stateVars =>                    | MethodScope stateVars =>
161                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)
162                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)
# Line 155  Line 169 
169    (* variables *)    (* variables *)
170      structure Var =      structure Var =
171        struct        struct
172            fun mirror (ty, name) = {
173                    hostTy = ToC.trType ty,
174                    shadowTy = shadowTy ty,
175                    gpuTy = ToCL.trType ty,
176                    var = name
177                  }
178          fun name (ToCL.V(_, name)) = name          fun name (ToCL.V(_, name)) = name
179          fun global (Prog{globals, imgGlobals, ...}, name, ty) = let          fun global (Prog{globals, imgGlobals, ...}, name, ty) = let
180                val x = {hostTy = ToC.trType ty, gpuTy = ToCL.trType ty, var = name}                val x = mirror (ty, name)
181                fun isImgGlobal (Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}), name) =                fun isImgGlobal (Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}), name) =
182                      imgGlobals  := (name,dim) :: !imgGlobals                      imgGlobals  := (name,dim) :: !imgGlobals
183                  | isImgGlobal _ =  ()                  | isImgGlobal _ =  ()
# Line 169  Line 189 
189          fun param x = ToCL.V(ToCL.trType(V.ty x), V.name x)          fun param x = ToCL.V(ToCL.trType(V.ty x), V.name x)
190          fun state (Strand{state, ...}, x) = let          fun state (Strand{state, ...}, x) = let
191                val ty = V.ty x                val ty = V.ty x
192                val x' = {hostTy = ToC.trType ty, gpuTy = ToCL.trType ty, var = V.name x}                val x' = mirror (ty, V.name x)
193                in                in
194                  state := x' :: !state;                  state := x' :: !state;
195                  ToCL.V(#gpuTy x', #var x')                  ToCL.V(#gpuTy x', #var x')
# Line 216  Line 236 
236                    imgGlobals = ref[],                    imgGlobals = ref[],
237                    prFn = ref(CL.D_Comment(["No Print Function"]))                    prFn = ref(CL.D_Comment(["No Print Function"]))
238                  })                  })
239        (* register the global initialization part of a program *)  
 (* FIXME: unused code; can this be removed??  
           fun globalIndirects (globals,stms) = let  
                 fun getGlobals ({name,target as TargetUtil.TARGET_CL}::rest) =  
                       CL.mkAssign(CL.mkIndirect(CL.mkVar RN.globalsVarName,name),CL.mkVar name)  
                         ::getGlobals rest  
                   | getGlobals [] = []  
                   | getGlobals (_::rest) = getGlobals rest  
                 in  
                   stms @ getGlobals globals  
                 end  
 *)  
240        (* 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 *)
241          fun inputs (Prog{topDecls, ...}, stm) = let          fun inputs (Prog{topDecls, ...}, stm) = let
242                val inputsFn = CL.D_Func(                val inputsFn = CL.D_Func(
# Line 241  Line 250 
250        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
251          fun init (Prog{topDecls, ...}, init) = let          fun init (Prog{topDecls, ...}, init) = let
252                val globalsDecl = CL.mkAssign(CL.E_Var RN.globalsVarName,                val globalsDecl = CL.mkAssign(CL.E_Var RN.globalsVarName,
253                      CL.mkApply("malloc", [CL.mkApply("sizeof",[CL.mkVar RN.globalsTy])]))                      CL.mkApply("malloc", [CL.mkSizeof(CL.T_Named RN.globalsTy)]))
               val initGlobalsCall = CL.mkCall(RN.initGlobalsHelper,[])  
254                val initFn = CL.D_Func(                val initFn = CL.D_Func(
255                      [], CL.voidTy, RN.initGlobals, [],                      [], CL.voidTy, RN.initGlobals, [],
256                      CL.mkBlock([globalsDecl,initGlobalsCall]))                      CL.mkBlock[
257                val initFn_helper = CL.D_Func(                          globalsDecl,
258                      [], CL.voidTy, RN.initGlobalsHelper, [],                          CL.mkCall(RN.initGlobalsHelper, [CL.mkVar RN.globalsVarName])
259                          ])
260                  val initHelperFn = CL.D_Func(
261                        [], CL.voidTy, RN.initGlobalsHelper,
262                        [CL.PARAM([], globPtrTy, RN.globalsVarName)],
263                      init)                      init)
264                val shutdownFn = CL.D_Func(                val shutdownFn = CL.D_Func(
265                      [], CL.voidTy, RN.shutdown,                      [], CL.voidTy, RN.shutdown,
266                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.worldTy), "wrld")],                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.worldTy), "wrld")],
267                      CL.S_Block[])                      CL.S_Block[])
268                in                in
269                  topDecls := shutdownFn :: initFn :: initFn_helper :: !topDecls                  topDecls := shutdownFn :: initFn :: initHelperFn :: !topDecls
270                end                end
271    
272        (* create and register the initially function for a program *)        (* create and register the initially function for a program *)
273          fun initially {          fun initially {
274                prog = Prog{name=progName, strands, initially, numDims, ...},                prog = Prog{name=progName, strands, initially, numDims, ...},
# Line 290  Line 303 
303                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [
304                              CL.mkVar "ProgramName",                              CL.mkVar "ProgramName",
305                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),
                                                                          CL.mkApply("sizeof",[CL.E_Var (N.strandTy name)]),  
306                              CL.E_Bool isArray,                              CL.E_Bool isArray,
307                              CL.E_Int(IntInf.fromInt nDims, CL.int32),                              CL.E_Int(IntInf.fromInt nDims, CL.int32),
308                              CL.E_Var "base",                              CL.E_Var "base",
# Line 336  Line 348 
348        (***** OUTPUT *****)        (***** OUTPUT *****)
349          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let
350              (* the print function *)              (* the print function *)
351                val prFnName = concat[name, "_print"]                val prFnName = concat[name, "Print"]
352                val prFn = let                val prFn = let
353                      val params = [                      val params = [
354                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
355                                CL.PARAM([], CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)),"status"),
356                                CL.PARAM([], CL.intTy,"numStrands"),
357                              CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")                              CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")
358                            ]                            ]
359                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
360                      val outState = CL.mkIndirect(CL.mkVar "self", x)                      val outState = CL.mkSelect(CL.mkSubscript(CL.mkVar "self", CL.E_Var "i"), x)
361                      val prArgs = (case ty                      val prArgs = (case ty
362                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]
363                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
# Line 365  Line 379 
379                                  end                                  end
380                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)
381                            (* end case *))                            (* end case *))
382                        val forBody = CL.mkIfThen(
383                              CL.mkBinOp(CL.mkSubscript(CL.E_Var "status",CL.E_Var "i"), CL.#==, CL.E_Var "DIDEROT_STABILIZE"),
384                              CL.mkBlock([CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs)]))
385                        val body =  CL.mkFor(
386                            [(CL.intTy, "i", CL.mkInt 0)],
387                            CL.mkBinOp(CL.E_Var "i", CL.#<, CL.E_Var "numStrands"),
388                            [CL.mkPostOp(CL.E_Var "i", CL.^++)],
389                            forBody)
390                      in                      in
391                        CL.D_Func(["static"], CL.voidTy, prFnName, params,                        CL.D_Func(["static"], CL.voidTy, prFnName, params, body)
                         CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs))  
392                      end                      end
393                in                in
394                  prFn                  prFn
# Line 379  Line 400 
400                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),
401                  tyName)                  tyName)
402    
403        (* generates the load kernel function *)          fun genStrandCopy(Strand{tyName,name,state,...}) = let
404                  val params = [
405                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),
406                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfOut")
407                      ]
408                  val assignStms = List.rev(List.map(fn x => CL.mkAssign(CL.mkIndirect(CL.E_Var "selfOut", #var x),                                                                                                                          CL.mkIndirect(CL.E_Var "selfIn", #var x))) (!state))
409                  in
410                    CL.D_Func([""], CL.voidTy, RN.strandCopy name, params,CL.mkBlock(assignStms))
411                  end
412    
413        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
414          fun getGlobalDataBuffers (globals,contextVar,errVar) = let          fun getGlobalDataBuffers (globals,contextVar,errVar) = let
# Line 392  Line 421 
421                      CL.mkApply("clCreateBuffer", [                      CL.mkApply("clCreateBuffer", [
422                          CL.mkVar contextVar,                          CL.mkVar contextVar,
423                          CL.mkVar "CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR",                          CL.mkVar "CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR",
424                          CL.mkApply("sizeof",[CL.mkVar RN.globalsTy]),                          CL.mkSizeof(CL.T_Named RN.globalsTy),
425                          CL.mkVar RN.globalsVarName,                          CL.mkVar RN.globalsVarName,
426                          CL.mkUnOp(CL.%&,CL.mkVar errVar)                          CL.mkUnOp(CL.%&,CL.mkVar errVar)
427                        ]))                        ]))
# Line 401  Line 430 
430                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)
431  (* FIXME: use CL constructors to build expressions (not strings) *)  (* FIXME: use CL constructors to build expressions (not strings) *)
432                      fun sizeExp i = CL.mkSubscript(CL.mkIndirect(hostVar, "size"), CL.mkInt i)                      fun sizeExp i = CL.mkSubscript(CL.mkIndirect(hostVar, "size"), CL.mkInt i)
433                      val size = CL.mkBinOp(CL.mkApply("sizeof",[CL.mkVar "float"]), CL.#*, sizeExp 0)  (* FIXME: there is no reason that images have to be restricted to float elements! *)
434                        val size = CL.mkBinOp(CL.mkSizeof(CL.float), CL.#*, sizeExp 0)
435                      val size = if (nDims > 1)                      val size = if (nDims > 1)
436                            then CL.mkBinOp(size, CL.#*, sizeExp 1)                            then CL.mkBinOp(size, CL.#*, sizeExp 1)
437                            else size                            else size
# Line 415  Line 445 
445                          CL.mkApply("clCreateBuffer", [                          CL.mkApply("clCreateBuffer", [
446                              CL.mkVar contextVar,                              CL.mkVar contextVar,
447                              CL.mkVar "CL_MEM_COPY_HOST_PTR",                              CL.mkVar "CL_MEM_COPY_HOST_PTR",
448                              CL.mkApply("sizeof",[CL.mkVar (RN.imageTy nDims)]),                              CL.mkSizeof(CL.T_Named(RN.imageTy nDims)),
449                              hostVar,                              hostVar,
450                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
451                            ])) :: errFn(concat["error in creating ",RN.addBufferSuffix var, " global buffer"]) ::                            ])) ::
452                          errFn(concat["error in creating ",RN.addBufferSuffix var, " global buffer"]) ::
453                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),
454                          CL.mkApply("clCreateBuffer", [                          CL.mkApply("clCreateBuffer", [
455                              CL.mkVar contextVar,                              CL.mkVar contextVar,
# Line 426  Line 457 
457                              size,                              size,
458                              CL.mkIndirect(hostVar, "data"),                              CL.mkIndirect(hostVar, "data"),
459                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
460                            ])) :: errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer"]) :: genDataBuffers(globals,contextVar,errVar,errFn)                            ])) ::
461                            errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer"]) ::
462                            genDataBuffers(globals,contextVar,errVar,errFn)
463                      end                      end
464                in                in
465                  [globalBufferDecl] @ [globalBuffer,errorFn(globalBuffErr)] @ genDataBuffers(globals,contextVar,errVar,errorFn)                  globalBufferDecl
466                    :: globalBuffer
467                    :: errorFn(globalBuffErr)
468                    :: genDataBuffers(globals,contextVar,errVar,errorFn)
469                end                end
470    
471        (* generates the kernel arguments for the image data *)        (* generates the kernel arguments for the image data *)
# Line 466  Line 502 
502                end                end
503    
504        (* generates the globals buffers and arguments function *)        (* generates the globals buffers and arguments function *)
505          fun genGlobalBuffersArgs (imgGlobals) = let          fun genGlobalBuffersArgs imgGlobals = let
506              (* Delcare opencl setup objects *)              (* Delcare opencl setup objects *)
507                val errVar = "err"                val errVar = "err"
508                val imgDataSizeVar = "image_dataSize"                val imgDataSizeVar = "image_dataSize"
# Line 495  Line 531 
531        (*generate code for intilizing kernel global data *)        (*generate code for intilizing kernel global data *)
532  (* FIXME: should use List.map here *)  (* FIXME: should use List.map here *)
533          fun initGlobalImages ((name, tyname)::rest) =          fun initGlobalImages ((name, tyname)::rest) =
534               CL.mkAssign(CL.mkIndirect(CL.E_Var RN.globalsVarName, name), CL.mkVar (RN.addBufferSuffix name)) ::                CL.mkAssign(
535               CL.mkAssign(CL.mkIndirect(CL.E_Var RN.globalsVarName,concat[name,"->","data"]),CL.mkVar (RN.addBufferSuffixData name)) ::                  CL.mkIndirect(CL.E_Var RN.globalsVarName, name),
536                    CL.mkVar (RN.addBufferSuffix name)) ::
537                  CL.mkAssign(
538                    CL.mkIndirect(CL.mkIndirect(CL.E_Var RN.globalsVarName, name), "data"),
539                    CL.mkVar (RN.addBufferSuffixData name)) ::
540               initGlobalImages rest               initGlobalImages rest
541            | initGlobalImages [] = []            | initGlobalImages [] = []
542    
# Line 508  Line 548 
548                val outState = "strand_out"                val outState = "strand_out"
549                                    val tempVar = "tmp"                                    val tempVar = "tmp"
550                val params = [                val params = [
551                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),
552                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfOut"),
553                        globalParam (CL.intTy, "width"),                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus"),
554                        globalParam (CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName)                        CL.PARAM(["__global"], CL.intTy, "width"),
555                          CL.PARAM(["__global"], globPtrTy, RN.globalsVarName)
556                      ] @ genKeneralGlobalParams(!imgGlobals)                      ] @ genKeneralGlobalParams(!imgGlobals)
557                val thread_ids = if nDims = 1                val thread_ids = if nDims = 1
558                        then [                        then [
# Line 531  Line 572 
572                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), outState, NONE),                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), outState, NONE),
573                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), tempVar, NONE)                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), tempVar, NONE)
574                      ]                      ]
575                val swapStms = [                val barrierCode = CL.mkCall(RN.strandCopy name, [CL.E_Var outState, CL.E_Var inState])
576                        CL.mkAssign(CL.E_Var tempVar, CL.E_Var inState),                val barrierStm = CL.mkCall("barrier",[CL.E_Var "CLK_LOCAL_MEM_FENCE"])
577                        CL.mkAssign(CL.E_Var inState, CL.E_Var outState),                val index = if nDims = 1 then
578                        CL.mkAssign(CL.E_Var outState, CL.E_Var tempVar)                          CL.mkStr "x"
579                      ]                      else
580                val strandObjects = if nDims = 1                          CL.mkBinOp(
                     then [  
                         CL.mkAssign( CL.mkVar inState,  CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfIn", CL.mkStr "x"))),  
                         CL.mkAssign(CL.mkVar outState, CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfOut", CL.mkStr "x")))  
                       ]  
                     else let  
                       val index = CL.mkBinOp(  
581                              CL.mkBinOp(CL.mkVar "x", CL.#*, CL.mkVar "width"), CL.#+, CL.mkVar "y")                              CL.mkBinOp(CL.mkVar "x", CL.#*, CL.mkVar "width"), CL.#+, CL.mkVar "y")
582                        in [  
583                          CL.mkAssign(CL.mkVar inState,  CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfIn",index))),                val strandObjects =
584                          CL.mkAssign(CL.mkVar outState, CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfOut",index)))                       [ CL.mkAssign(CL.mkVar inState,  CL.mkBinOp(CL.mkVar "selfIn",CL.#+,index)),
585                        ] end                         CL.mkAssign(CL.mkVar outState, CL.mkBinOp(CL.mkVar "selfOut",CL.#+,index))
586                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkInt 0)))                       ]
587    
588                    val stabalizeStm = CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",index),
589                                                                            CL.E_Var "status")
590                  val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "strandStatus",index))))
591                val strandInitStm = CL.mkCall(RN.strandInit name, [                val strandInitStm = CL.mkCall(RN.strandInit name, [
592                        CL.E_Var RN.globalsVarName,                        CL.E_Var RN.globalsVarName,
593                        CL.E_Var inState,                        CL.E_Var outState,
594                        CL.E_Var "x",                        CL.E_Var "x",
595  (* FIXME: if nDims = 1, then "y" is not defined! the arguments to this call should really come from  (* FIXME: if nDims = 1, then "y" is not defined! the arguments to this call should really come from
596   * the initially code!   * the initially code!
# Line 562  Line 601 
601                      @ strandDecl                      @ strandDecl
602                      @ strandObjects                      @ strandObjects
603                      @ [strandInitStm,status]                      @ [strandInitStm,status]
604                val while_exp = CL.mkBinOp(                val while_exp = CL.mkBinOp(CL.mkVar "status",CL.#==, CL.mkVar RN.kActive)
605                      CL.mkBinOp(CL.mkVar "status",CL.#!=, CL.mkVar RN.kStabilize),                val whileBody = CL.mkBlock ([barrierCode,barrierStm] @ [
                     CL.#&&,  
                     CL.mkBinOp(CL.mkVar "status", CL.#!=, CL.mkVar RN.kDie))  
               val whileBody = CL.mkBlock (swapStms @ [  
 (* FIXME: need a barrier synchronization at beginning of loop *)  
606                        CL.mkAssign(CL.mkVar "status",                        CL.mkAssign(CL.mkVar "status",
607                          CL.mkApply(RN.strandUpdate name,                          CL.mkApply(RN.strandUpdate name,
608                            [CL.mkVar inState, CL.mkVar outState,CL.E_Var RN.globalsVarName]))] )                            [CL.mkVar inState, CL.mkVar outState,CL.E_Var RN.globalsVarName]))] )
609                val whileBlock = [CL.mkWhile(while_exp, whileBody)]                val whileBlock = [CL.mkWhile(while_exp, whileBody)]
610                val body = CL.mkBlock(local_vars @ whileBlock)                val body = CL.mkBlock(local_vars @ whileBlock @ [stabalizeStm])
611                in                in
612                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)
613                end                end
614        (* generate a global structure from the globals *)  
615          fun genGlobalStruct (targetTy, globals) = let        (* generate a global structure type definition from the list of globals *)
616            fun genGlobalStruct (targetTy, globals, tyName) = let
617                val globs = List.map (fn (x : mirror_var) => (targetTy x, #var x)) globals                val globs = List.map (fn (x : mirror_var) => (targetTy x, #var x)) globals
618                in                in
619                  CL.D_StructDef(globs, RN.globalsTy)                  CL.D_StructDef(globs, tyName)
620                end                end
621    
622          fun genGlobals (declFn, targetTy, globals) = let          fun genGlobals (declFn, targetTy, globals) = let
# Line 602  Line 638 
638                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),
639  *)  *)
640                            ("update", fnPtr("update_method_t", "0")),                            ("update", fnPtr("update_method_t", "0")),
641                            ("print", fnPtr("print_method_t", name ^ "_print"))                            ("print", fnPtr("print_method_t", name ^ "Print"))
642                          ]                          ]
643                      end                      end
644                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)
# Line 647  Line 683 
683                      "#define DIDEROT_TARGET_CL",                      "#define DIDEROT_TARGET_CL",
684                      "#include \"Diderot/cl-diderot.h\""                      "#include \"Diderot/cl-diderot.h\""
685                    ]));                    ]));
686                  clppDecl (genGlobalStruct (#gpuTy, !globals));                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));
687                  clppDecl (genStrandTyDef(#gpuTy, strand));                  clppDecl (genStrandTyDef(#gpuTy, strand));
688                  clppDecl  (!init_code);                  clppDecl  (!init_code);
689                    clppDecl  (genStrandCopy(strand));
690                  List.app clppDecl (!code);                  List.app clppDecl (!code);
691                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));
692                (* Generate the Host C file *)                (* Generate the Host C file *)
# Line 662  Line 699 
699                    ]));                    ]));
700                  cppDecl (CL.D_Var(["static"], CL.charPtr, "ProgramName",                  cppDecl (CL.D_Var(["static"], CL.charPtr, "ProgramName",
701                    SOME(CL.I_Exp(CL.mkStr progName))));                    SOME(CL.I_Exp(CL.mkStr progName))));
702                  cppDecl (genGlobalStruct (#hostTy, !globals));                  cppDecl (genGlobalStruct (#hostTy, !globals, RN.globalsTy));
703                  cppDecl (CL.D_Var(["static"], CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName, NONE));                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));
704    (* FIXME: does this really need to be a global? *)
705                    cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));
706                  cppDecl (genStrandTyDef (#hostTy, strand));                  cppDecl (genStrandTyDef (#hostTy, strand));
707                  cppDecl (genStrandPrint strand);                  cppDecl (genStrandPrint strand);
708                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
# Line 677  Line 716 
716                  TextIO.closeOut clOutS                  TextIO.closeOut clOutS
717                end                end
718    
719        (* output the code to a file.  The string is the basename of the file, the extension        (* output the code to the filesystem.  The string is the basename of the source file *)
        * is provided by the target.  
        *)  
720          fun generate (basename, prog as Prog{double, parallel, debug, ...}) = let          fun generate (basename, prog as Prog{double, parallel, debug, ...}) = let
721                fun condCons (true, x, xs) = x::xs                fun condCons (true, x, xs) = x::xs
722                  | condCons (false, _, xs) = xs                  | condCons (false, _, xs) = xs

Legend:
Removed from v.1343  
changed lines
  Added in v.1382

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