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 1345, Tue Jun 14 16:19:21 2011 UTC revision 1421, Thu Jun 30 21:22:28 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       (* translate TreeIL types to shadow types *)
32        fun convertToShadow (ty,name) = (case ty
33               of Ty.IVecTy 1 => CL.mkAssign(CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
34                                    CL.mkIndirect(CL.mkVar(RN.globalsVarName), name))
35                | Ty.TensorTy[n]=> CL.mkCall(RN.convertToShadowVec n,[
36                             CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
37                              CL.mkIndirect(CL.mkVar(RN.globalsVarName), name)])
38                | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) =>  CL.mkCall(RN.shadowImageFunc dim, [
39                             CL.mkVar "context",
40                             CL.mkUnOp(CL.%&,CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name)),
41                             CL.mkIndirect(CL.mkVar(RN.globalsVarName),name)
42                             ])
43                | Ty.TensorTy[n, m] => CL.mkCall(RN.convertToShadowMat(m,n),[
44                             CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
45                              CL.mkIndirect(CL.mkVar(RN.globalsVarName), name)])
46                | _ => CL.mkAssign(CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
47                                    CL.mkIndirect(CL.mkVar(RN.globalsVarName), name))
48               (*end case *))
49    
50    (* helper functions for specifying parameters in various address spaces *)    (* helper functions for specifying parameters in various address spaces *)
51      fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)      fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)
52      fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)      fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)
# Line 22  Line 54 
54      fun localParam (ty, x) = CL.PARAM(["__local"], ty, x)      fun localParam (ty, x) = CL.PARAM(["__local"], ty, x)
55      fun privateParam (ty, x) = CL.PARAM(["__private"], ty, x)      fun privateParam (ty, x) = CL.PARAM(["__private"], ty, x)
56    
57      (* OpenCL global pointer type *)
58        fun globalPtr ty = CL.T_Qual("__global", CL.T_Ptr ty)
59    
60    (* C variable translation *)    (* C variable translation *)
61      structure TrCVar =      structure TrCVar =
62        struct        struct
# Line 64  Line 99 
99    (* variable or field that is mirrored between host and GPU *)    (* variable or field that is mirrored between host and GPU *)
100      type mirror_var = {      type mirror_var = {
101              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)
102                shadowTy : CL.ty,           (* host-side shadow type of GPU type *)
103              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)
104                hToS: stm,                                  (*the statement that converts the variable to its shadow representation *)
105              var : CL.var                (* variable name *)              var : CL.var                (* variable name *)
106            }            }
107    
# Line 142  Line 179 
179                  case scope                  case scope
180  (* 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! *)
181                   of StrandScope stateVars =>                   of StrandScope stateVars =>
182                        ToCL.trBlock (vMap, saveState "StrandScope" stateVars ToC.trAssign, blk)                        ToCL.trBlock (vMap, saveState "StrandScope" stateVars ToCL.trAssign, blk)
183                    | MethodScope stateVars =>                    | MethodScope stateVars =>
184                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)
185                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)
# Line 155  Line 192 
192    (* variables *)    (* variables *)
193      structure Var =      structure Var =
194        struct        struct
195            fun mirror (ty, name) = {
196                    hostTy = ToC.trType ty,
197                    shadowTy = shadowTy ty,
198                    gpuTy = ToCL.trType ty,
199                    hToS = convertToShadow(ty,name),
200                    var = name
201                  }
202          fun name (ToCL.V(_, name)) = name          fun name (ToCL.V(_, name)) = name
203          fun global (Prog{globals, imgGlobals, ...}, name, ty) = let          fun global (Prog{globals, imgGlobals, ...}, name, ty) = let
204                val x = {hostTy = ToC.trType ty, gpuTy = ToCL.trType ty, var = name}                val x = mirror (ty, name)
205                fun isImgGlobal (Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}), name) =                fun isImgGlobal (Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}), name) =
206                      imgGlobals  := (name,dim) :: !imgGlobals                      imgGlobals  := (name,dim) :: !imgGlobals
207                  | isImgGlobal _ =  ()                  | isImgGlobal _ =  ()
# Line 169  Line 213 
213          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)
214          fun state (Strand{state, ...}, x) = let          fun state (Strand{state, ...}, x) = let
215                val ty = V.ty x                val ty = V.ty x
216                val x' = {hostTy = ToC.trType ty, gpuTy = ToCL.trType ty, var = V.name x}                val x' = mirror (ty, V.name x)
217                in                in
218                  state := x' :: !state;                  state := x' :: !state;
219                  ToCL.V(#gpuTy x', #var x')                  ToCL.V(#gpuTy x', #var x')
# Line 216  Line 260 
260                    imgGlobals = ref[],                    imgGlobals = ref[],
261                    prFn = ref(CL.D_Comment(["No Print Function"]))                    prFn = ref(CL.D_Comment(["No Print Function"]))
262                  })                  })
263        (* 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  
 *)  
264        (* 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 *)
265          fun inputs (Prog{topDecls, ...}, stm) = let          fun inputs (Prog{topDecls, ...}, stm) = let
266                val inputsFn = CL.D_Func(                val inputsFn = CL.D_Func(
# Line 241  Line 274 
274        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
275          fun init (Prog{topDecls, ...}, init) = let          fun init (Prog{topDecls, ...}, init) = let
276                val globalsDecl = CL.mkAssign(CL.E_Var RN.globalsVarName,                val globalsDecl = CL.mkAssign(CL.E_Var RN.globalsVarName,
277                      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,[])  
278                val initFn = CL.D_Func(                val initFn = CL.D_Func(
279                      [], CL.voidTy, RN.initGlobals, [],                      [], CL.voidTy, RN.initGlobals, [],
280                      CL.mkBlock([globalsDecl,initGlobalsCall]))                      CL.mkBlock[
281                val initFn_helper = CL.D_Func(              globalsDecl,
282                      [], CL.voidTy, RN.initGlobalsHelper, [],              CL.mkCall(RN.initGlobalsHelper, [CL.mkVar RN.globalsVarName])
283                  ])
284                  val initHelperFn = CL.D_Func(
285                        [], CL.voidTy, RN.initGlobalsHelper,
286                [CL.PARAM([], globPtrTy, RN.globalsVarName)],
287                      init)                      init)
288                val shutdownFn = CL.D_Func(                val shutdownFn = CL.D_Func(
289                      [], CL.voidTy, RN.shutdown,                      [], CL.voidTy, RN.shutdown,
290                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.worldTy), "wrld")],                      [CL.PARAM([], CL.T_Ptr(CL.T_Named RN.worldTy), "wrld")],
291                      CL.S_Block[])                      CL.S_Block[])
292                in                in
293                  topDecls := shutdownFn :: initFn :: initFn_helper :: !topDecls                  topDecls := shutdownFn :: initFn :: initHelperFn :: !topDecls
294                end                end
295    
296        (* create and register the initially function for a program *)        (* create and register the initially function for a program *)
297          fun initially {          fun initially {
298                prog = Prog{name=progName, strands, initially, numDims, ...},                prog = Prog{name=progName, strands, initially, numDims, ...},
# Line 290  Line 327 
327                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [
328                              CL.mkVar "ProgramName",                              CL.mkVar "ProgramName",
329                              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)]),  
330                              CL.E_Bool isArray,                              CL.E_Bool isArray,
331                              CL.E_Int(IntInf.fromInt nDims, CL.int32),                              CL.E_Int(IntInf.fromInt nDims, CL.int32),
332                              CL.E_Var "base",                              CL.E_Var "base",
# Line 336  Line 372 
372        (***** OUTPUT *****)        (***** OUTPUT *****)
373          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let
374              (* the print function *)              (* the print function *)
375                val prFnName = concat[name, "_print"]                val prFnName = concat[name, "Print"]
376                val prFn = let                val prFn = let
377                      val params = [                      val params = [
378                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
379                                CL.PARAM([], CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)),"status"),
380                                CL.PARAM([], CL.intTy,"numStrands"),
381                              CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")                              CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")
382                            ]                            ]
383                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
384                      val outState = CL.mkIndirect(CL.mkVar "self", x)                      val outState = CL.mkSelect(CL.mkSubscript(CL.mkVar "self", CL.E_Var "i"), x)
385                      val prArgs = (case ty                      val prArgs = (case ty
386                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]
387                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
# Line 365  Line 403 
403                                  end                                  end
404                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)
405                            (* end case *))                            (* end case *))
406                        val forBody = CL.mkIfThen(
407                              CL.mkBinOp(CL.mkSubscript(CL.E_Var "status",CL.E_Var "i"), CL.#==, CL.E_Var "DIDEROT_STABILIZE"),
408                              CL.mkBlock([CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs)]))
409                        val body =  CL.mkFor(
410                            [(CL.intTy, "i", CL.mkInt 0)],
411                            CL.mkBinOp(CL.E_Var "i", CL.#<, CL.E_Var "numStrands"),
412                            [CL.mkPostOp(CL.E_Var "i", CL.^++)],
413                            forBody)
414                      in                      in
415                        CL.D_Func(["static"], CL.voidTy, prFnName, params,                        CL.D_Func(["static"], CL.voidTy, prFnName, params, body)
                         CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs))  
416                      end                      end
417                in                in
418                  prFn                  prFn
# Line 379  Line 424 
424                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),
425                  tyName)                  tyName)
426    
       (* generates the load kernel function *)  
   
427        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
428          fun getGlobalDataBuffers (globals,contextVar,errVar) = let          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let
429                val globalBuffErr = "error creating OpenCL global buffer"                val globalBuffErr = "error creating OpenCL global buffer"
430                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"),
431                      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]),
432                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
433                  val shadowTypeDecl =
434                        CL.mkDecl(CL.T_Named(RN.shadowGlobalsTy), RN.shadowGlaobalsName, NONE)
435                  val globalToShadowStms = List.map (fn (x:mirror_var) => #hToS x ) globals
436                val globalBufferDecl =  CL.mkDecl(clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)                val globalBufferDecl =  CL.mkDecl(clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)
437                val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]),                val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]),
438                      CL.mkApply("clCreateBuffer", [                      CL.mkApply("clCreateBuffer", [
439                          CL.mkVar contextVar,                          CL.mkVar contextVar,
440                          CL.mkVar "CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR",                          CL.mkBinOp(CL.mkVar "CL_MEM_READ_ONLY", CL.#|, CL.mkVar "CL_MEM_COPY_HOST_PTR"),
441                          CL.mkApply("sizeof",[CL.mkVar RN.globalsTy]),                          CL.mkSizeof(CL.T_Named RN.shadowGlobalsTy),
442                          CL.mkVar RN.globalsVarName,                          CL.mkUnOp(CL.%&,CL.mkVar RN.shadowGlaobalsName),
443                          CL.mkUnOp(CL.%&,CL.mkVar errVar)                          CL.mkUnOp(CL.%&,CL.mkVar errVar)
444                        ]))                        ]))
445                fun genDataBuffers ([],_,_,_) = []                fun genDataBuffers ([],_,_,_) = []
446                  | genDataBuffers ((var,nDims)::globals, contextVar, errVar,errFn) = let                  | genDataBuffers ((var,nDims)::globals, contextVar, errVar,errFn) = let
447                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)
448  (* FIXME: use CL constructors to build expressions (not strings) *)                      val size = CL.mkIndirect(hostVar, "dataSzb")
                     fun sizeExp i = CL.mkSubscript(CL.mkIndirect(hostVar, "size"), CL.mkInt i)  
                     val size = CL.mkBinOp(CL.mkApply("sizeof",[CL.mkVar "float"]), CL.#*, sizeExp 0)  
                     val size = if (nDims > 1)  
                           then CL.mkBinOp(size, CL.#*, sizeExp 1)  
                           else size  
                     val size = if (nDims > 2)  
                           then CL.mkBinOp(size, CL.#*, sizeExp 2)  
                           else size  
449                      in                      in
                       CL.mkDecl(clMemoryTy, RN.addBufferSuffix var ,NONE)::  
450                        CL.mkDecl(clMemoryTy, RN.addBufferSuffixData var ,NONE)::                        CL.mkDecl(clMemoryTy, RN.addBufferSuffixData var ,NONE)::
                       CL.mkAssign(CL.mkVar(RN.addBufferSuffix var),  
                         CL.mkApply("clCreateBuffer", [  
                             CL.mkVar contextVar,  
                             CL.mkVar "CL_MEM_COPY_HOST_PTR",  
                             CL.mkApply("sizeof",[CL.mkVar (RN.imageTy nDims)]),  
                             hostVar,  
                             CL.mkUnOp(CL.%&,CL.mkVar errVar)  
                           ])) ::  
                       errFn(concat["error in creating ",RN.addBufferSuffix var, " global buffer"]) ::  
451                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),
452                          CL.mkApply("clCreateBuffer", [                          CL.mkApply("clCreateBuffer", [
453                              CL.mkVar contextVar,                              CL.mkVar contextVar,
454                              CL.mkVar "CL_MEM_COPY_HOST_PTR",                              CL.mkVar "CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR",
455                              size,                              size,
456                              CL.mkIndirect(hostVar, "data"),                              CL.mkIndirect(hostVar, "data"),
457                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
# Line 432  Line 460 
460                          genDataBuffers(globals,contextVar,errVar,errFn)                          genDataBuffers(globals,contextVar,errVar,errFn)
461                      end                      end
462                in                in
463                  globalBufferDecl                  [shadowTypeDecl] @ globalToShadowStms
464                  :: globalBuffer                  @ [globalBufferDecl, globalBuffer,errorFn(globalBuffErr)]
465                  :: errorFn(globalBuffErr)                  @ genDataBuffers(imgGlobals,contextVar,errVar,errorFn)
                 :: genDataBuffers(globals,contextVar,errVar,errorFn)  
466                end                end
467    
468        (* generates the kernel arguments for the image data *)        (* generates the kernel arguments for the image data *)
# Line 444  Line 471 
471                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"),
472                      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]),
473                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
474                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.&=,
475                      CL.mkApply("clSetKernelArg",                      CL.mkApply("clSetKernelArg",
476                        [CL.mkVar kernelVar,                        [CL.mkVar kernelVar,
477                         CL.mkPostOp(CL.E_Var count, CL.^++),                         CL.mkPostOp(CL.E_Var count, CL.^++),
# Line 457  Line 484 
484                          [CL.mkVar kernelVar,                          [CL.mkVar kernelVar,
485                           CL.mkPostOp(CL.E_Var count, CL.^++),                           CL.mkPostOp(CL.E_Var count, CL.^++),
486                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
                          CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffix var))]))) ::  
                          errFn(concat["error in creating ",RN.addBufferSuffix var, " argument"]) ::  
                     CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.$=,  
                       CL.mkApply("clSetKernelArg",  
                         [CL.mkVar kernelVar,  
                          CL.mkPostOp(CL.E_Var count, CL.^++),  
                          CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),  
487                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::
488                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument"]) ::                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument"]) ::
489                      genDataArguments (globals,count,kernelVar,errVar,errFn)                      genDataArguments (globals,count,kernelVar,errVar,errFn)
# Line 472  Line 492 
492                end                end
493    
494        (* generates the globals buffers and arguments function *)        (* generates the globals buffers and arguments function *)
495          fun genGlobalBuffersArgs (imgGlobals) = let          fun genGlobalBuffersArgs (globals,imgGlobals) = let
496              (* Delcare opencl setup objects *)              (* Delcare opencl setup objects *)
497                val errVar = "err"                val errVar = "err"
498                val imgDataSizeVar = "image_dataSize"                val imgDataSizeVar = "image_dataSize"
# Line 482  Line 502 
502                        CL.PARAM([],CL.T_Named("cl_command_queue"), "cmdQ"),                        CL.PARAM([],CL.T_Named("cl_command_queue"), "cmdQ"),
503                        CL.PARAM([],CL.T_Named("int"), "argStart")                        CL.PARAM([],CL.T_Named("int"), "argStart")
504                      ]                      ]
505                val clGlobalBuffers = getGlobalDataBuffers(!imgGlobals, "context", errVar)                val clGlobalBuffers = getGlobalDataBuffers(globals,!imgGlobals, "context", errVar)
506                val clGlobalArguments = genGlobalArguments(!imgGlobals, "argStart", "kernel", errVar)                val clGlobalArguments = genGlobalArguments(!imgGlobals, "argStart", "kernel", errVar)
507              (* Body put all the statments together *)              (* Body put all the statments together *)
508                val body = CL.mkDecl(clIntTy, errVar, SOME(CL.I_Exp(CL.mkInt 0)))                val body = CL.mkDecl(clIntTy, errVar, SOME(CL.I_Exp(CL.mkInt 0)))
# Line 493  Line 513 
513    
514        (* generate the data and global parameters *)        (* generate the data and global parameters *)
515          fun genKeneralGlobalParams ((name,tyname)::rest) =          fun genKeneralGlobalParams ((name,tyname)::rest) =
               globalParam (CL.T_Ptr(CL.T_Named (RN.imageTy tyname)), RN.addBufferSuffix name) ::  
516                globalParam (CL.T_Ptr(CL.voidTy), RN.addBufferSuffixData name) ::                globalParam (CL.T_Ptr(CL.voidTy), RN.addBufferSuffixData name) ::
517                genKeneralGlobalParams rest                genKeneralGlobalParams rest
518            | genKeneralGlobalParams [] = []            | genKeneralGlobalParams [] = []
519    
       (*generate code for intilizing kernel global data *)  
 (* FIXME: should use List.map here *)  
         fun initGlobalImages ((name, tyname)::rest) =  
              CL.mkAssign(CL.mkIndirect(CL.E_Var RN.globalsVarName, name), CL.mkVar (RN.addBufferSuffix name)) ::  
              CL.mkAssign(CL.mkIndirect(CL.E_Var RN.globalsVarName,concat[name,"->","data"]),CL.mkVar (RN.addBufferSuffixData name)) ::  
              initGlobalImages rest  
           | initGlobalImages [] = []  
   
520        (* generate the main kernel function for the .cl file *)        (* generate the main kernel function for the .cl file *)
521          fun genKernelFun (strand, nDims, globals, imgGlobals) = let          fun genKernelFun (strand, nDims, globals, imgGlobals) = let
522                val Strand{name, tyName, state, output, code,...} = strand                val Strand{name, tyName, state, output, code,...} = strand
# Line 516  Line 527 
527                val params = [                val params = [
528                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),
529                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),
530                        globalParam (CL.intTy, "width"),                        globalParam(CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus"),
531                        globalParam (CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName)                        CL.PARAM([], CL.intTy, "width"),
532                          globalParam(globPtrTy, RN.globalsVarName)
533                      ] @ genKeneralGlobalParams(!imgGlobals)                      ] @ genKeneralGlobalParams(!imgGlobals)
534                val thread_ids = if nDims = 1                val thread_ids = if nDims = 1
535                        then [                        then [
# Line 533  Line 545 
545                          ]                          ]
546                      else raise Fail "nDims > 2"                      else raise Fail "nDims > 2"
547                val strandDecl = [                val strandDecl = [
548                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), inState, NONE),                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), inState, NONE),
549                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), outState, NONE),                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), outState, NONE),
550                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), tempVar, NONE)                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), tempVar, NONE)
551                      ]                      ]
552                val swapStms = [                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)
553                        CL.mkAssign(CL.E_Var tempVar, CL.E_Var inState),                val imageDataStms = List.map (fn (x,_) =>
554                      CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),
555                                  CL.mkVar(RN.addBufferSuffixData x))) (!imgGlobals)
556                  val barrierCode = CL.mkIfThen(CL.mkBinOp(CL.E_Var "status",CL.#==,CL.E_Var "DIDEROT_ACTIVE"),
557                                     CL.mkBlock ([CL.mkAssign(CL.E_Var tempVar, CL.E_Var inState),
558                        CL.mkAssign(CL.E_Var inState, CL.E_Var outState),                        CL.mkAssign(CL.E_Var inState, CL.E_Var outState),
559                        CL.mkAssign(CL.E_Var outState, CL.E_Var tempVar)                                   CL.mkAssign(CL.E_Var outState, CL.E_Var tempVar)]))
560                      ]                val barrierStm = CL.mkCall("barrier",[CL.E_Var "CLK_LOCAL_MEM_FENCE"])
561                val strandObjects = if nDims = 1                val index = if nDims = 1 then
562                      then [                          CL.mkStr "x"
563                          CL.mkAssign( CL.mkVar inState,  CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfIn", CL.mkStr "x"))),                      else
564                          CL.mkAssign(CL.mkVar outState, CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfOut", CL.mkStr "x")))                          CL.mkBinOp(
                       ]  
                     else let  
                       val index = CL.mkBinOp(  
565                              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")
566                        in [  
567                          CL.mkAssign(CL.mkVar inState,  CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfIn",index))),                val strandObjects =
568                          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)),
569                        ] end                         CL.mkAssign(CL.mkVar outState, CL.mkBinOp(CL.mkVar "selfOut",CL.#+,index))
570                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkInt 0)))                       ]
571    
572                    val stabalizeStm = CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",index),
573                                                                            CL.E_Var "status")
574                  val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "strandStatus",index))))
575                val strandInitStm = CL.mkCall(RN.strandInit name, [                val strandInitStm = CL.mkCall(RN.strandInit name, [
576                        CL.E_Var RN.globalsVarName,                        CL.mkVar RN.globalsVarName,
577                        CL.E_Var inState,                        CL.mkVar inState,
578                        CL.E_Var "x",                        CL.mkVar "x",
579  (* 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
580   * the initially code!   * the initially code!
581   *)   *)
582                        CL.E_Var "y"])                        CL.mkVar "y"])
583                val local_vars = thread_ids                val local_vars = thread_ids
584                      @ initGlobalImages(!imgGlobals)                      @ [imageDataDecl]
585                        @ imageDataStms
586                      @ strandDecl                      @ strandDecl
587                      @ strandObjects                      @ strandObjects
588                      @ [strandInitStm,status]                      @ [strandInitStm,status]
589                val while_exp = CL.mkBinOp(                val while_exp = CL.mkBinOp(CL.mkVar "status",CL.#==, CL.mkVar RN.kActive)
590                      CL.mkBinOp(CL.mkVar "status",CL.#!=, CL.mkVar RN.kStabilize),                val whileBody = CL.mkBlock ([
                     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 *)  
591                        CL.mkAssign(CL.mkVar "status",                        CL.mkAssign(CL.mkVar "status",
592                          CL.mkApply(RN.strandUpdate name,                          CL.mkApply(RN.strandUpdate name,
593                            [CL.mkVar inState, CL.mkVar outState,CL.E_Var RN.globalsVarName]))] )                            [CL.mkVar inState,
594                               CL.mkVar outState,
595                               CL.mkVar RN.globalsVarName,
596                               CL.mkVar RN.globalImageDataName]))] @ [barrierCode,barrierStm] )
597                val whileBlock = [CL.mkWhile(while_exp, whileBody)]                val whileBlock = [CL.mkWhile(while_exp, whileBody)]
598                val body = CL.mkBlock(local_vars @ whileBlock)                val body = CL.mkBlock(local_vars @ whileBlock @ [stabalizeStm])
599                in                in
600                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)
601                end                end
602        (* generate a global structure from the globals *)  
603          fun genGlobalStruct (targetTy, globals) = let        (* generate a global structure type definition from the list of globals *)
604            fun genGlobalStruct (targetTy, globals, tyName) = let
605                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
606                in                in
607                  CL.D_StructDef(globs, RN.globalsTy)                  CL.D_StructDef(globs, tyName)
608                  end
609    
610          (* generate a global structure type definition from the image data of the image globals *)
611            fun genImageDataStruct (imgGlobals, tyName) = let
612                  val globs = List.map
613                        (fn (x, _) => (globalPtr CL.voidTy, RN.imageDataName x))
614                          imgGlobals
615                  in
616                    CL.D_StructDef(globs, tyName)
617                end                end
618    
619          fun genGlobals (declFn, targetTy, globals) = let          fun genGlobals (declFn, targetTy, globals) = let
# Line 608  Line 635 
635                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),
636  *)  *)
637                            ("update", fnPtr("update_method_t", "0")),                            ("update", fnPtr("update_method_t", "0")),
638                            ("print", fnPtr("print_method_t", name ^ "_print"))                            ("print", fnPtr("print_method_t", name ^ "Print"))
639                          ]                          ]
640                      end                      end
641                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 653  Line 680 
680                      "#define DIDEROT_TARGET_CL",                      "#define DIDEROT_TARGET_CL",
681                      "#include \"Diderot/cl-diderot.h\""                      "#include \"Diderot/cl-diderot.h\""
682                    ]));                    ]));
683                  clppDecl (genGlobalStruct (#gpuTy, !globals));                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));
684                    clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));
685                  clppDecl (genStrandTyDef(#gpuTy, strand));                  clppDecl (genStrandTyDef(#gpuTy, strand));
686                  clppDecl  (!init_code);                  clppDecl  (!init_code);
687                  List.app clppDecl (!code);                  List.app clppDecl (!code);
# Line 668  Line 696 
696                    ]));                    ]));
697                  cppDecl (CL.D_Var(["static"], CL.charPtr, "ProgramName",                  cppDecl (CL.D_Var(["static"], CL.charPtr, "ProgramName",
698                    SOME(CL.I_Exp(CL.mkStr progName))));                    SOME(CL.I_Exp(CL.mkStr progName))));
699                  cppDecl (genGlobalStruct (#hostTy, !globals));                  cppDecl (genGlobalStruct (#hostTy, !globals, RN.globalsTy));
700                  cppDecl (CL.D_Var(["static"], CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName, NONE));                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));
701    (* FIXME: does this really need to be a global? *)
702                    cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));
703                  cppDecl (genStrandTyDef (#hostTy, strand));                  cppDecl (genStrandTyDef (#hostTy, strand));
704                  cppDecl (genStrandPrint strand);                  cppDecl (genStrandPrint strand);
705                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
706                  cppDecl (genGlobalBuffersArgs imgGlobals);                  cppDecl (genGlobalBuffersArgs (!globals,imgGlobals));
707                  List.app (fn strand => cppDecl (genStrandDesc strand)) strands;                  List.app (fn strand => cppDecl (genStrandDesc strand)) strands;
708                  genStrandTable (cppDecl, strands);                  genStrandTable (cppDecl, strands);
709                  cppDecl (!initially);                  cppDecl (!initially);
# Line 683  Line 713 
713                  TextIO.closeOut clOutS                  TextIO.closeOut clOutS
714                end                end
715    
716        (* 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.  
        *)  
717          fun generate (basename, prog as Prog{double, parallel, debug, ...}) = let          fun generate (basename, prog as Prog{double, parallel, debug, ...}) = let
718                fun condCons (true, x, xs) = x::xs                fun condCons (true, x, xs) = x::xs
719                  | condCons (false, _, xs) = xs                  | condCons (false, _, xs) = xs
# Line 754  Line 782 
782                val params = [                val params = [
783                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),
784                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),
785                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName)                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName),
786                          CL.PARAM([],CL.T_Named(RN.imageDataType),RN.globalImageDataName)
787                      ]                      ]
788                val methFn = CL.D_Func([], CL.int32, fName, params, body)                val methFn = CL.D_Func([], CL.int32, fName, params, body)
789                in                in

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

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