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 1425, Fri Jul 1 18:05:07 2011 UTC revision 1462, Tue Aug 9 07:22:45 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.mkUnOp(CL.%&,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    
54       (* translate strand TreeIL types to shadow types *)
55        fun convertStrandToShadow (ty, name, selfIn, selfOut) = (case ty
56               of Ty.IVecTy 1 => CL.mkAssign(
57                    CL.mkIndirect(CL.mkVar selfIn,name),
58                    CL.mkIndirect(CL.mkVar selfOut, name))
59                | Ty.TensorTy[n]=> CL.mkCall(RN.convertToShadowVec n, [
60                      CL.mkUnOp(CL.%&,CL.mkIndirect(CL.mkVar selfOut,name)),
61                      CL.mkIndirect(CL.mkVar selfIn, name)
62                    ])
63                | Ty.TensorTy[n, m] => CL.mkCall(RN.convertToShadowMat(m,n), [
64                      CL.mkUnOp(CL.%&,CL.mkIndirect(CL.mkVar selfOut,name)),
65                      CL.mkIndirect(CL.mkVar selfIn, name)
66                    ])
67                | _ => CL.mkAssign(
68                    CL.mkIndirect(CL.mkVar selfIn,name),
69                    CL.mkIndirect(CL.mkVar selfOut, name))
70              (* end case *))
71    
72    
73    (* helper functions for specifying parameters in various address spaces *)    (* helper functions for specifying parameters in various address spaces *)
74      fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)      fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)
75      fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)      fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)
# Line 95  Line 118 
118      val clPlatformIdTy = CL.T_Named "cl_platform_id"      val clPlatformIdTy = CL.T_Named "cl_platform_id"
119      val clMemoryTy = CL.T_Named "cl_mem"      val clMemoryTy = CL.T_Named "cl_mem"
120      val globPtrTy = CL.T_Ptr(CL.T_Named RN.globalsTy)      val globPtrTy = CL.T_Ptr(CL.T_Named RN.globalsTy)
121        val strandShadowEnv = 1
122        val globalShadowEnv = 2
123    
124    (* variable or field that is mirrored between host and GPU *)    (* variable or field that is mirrored between host and GPU *)
125      type mirror_var = {      type mirror_var = {
126    (* FIXME: perhaps it would be cleaner to just track the TreeIL type of the variable? *)
127              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)
128              shadowTy : CL.ty,           (* host-side shadow type of GPU type *)              shadowTy : CL.ty,           (* host-side shadow type of GPU type *)
129              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)
130              hToS: stm,                                  (*the statement that converts the variable to its shadow representation *)              hToS: stm,                  (* the statement that converts the variable to its *)
131                                            (* shadow representation *)
132              var : CL.var                (* variable name *)              var : CL.var                (* variable name *)
133            }            }
134    
# Line 143  Line 170 
170        | GlobalScope        | GlobalScope
171        | InitiallyScope        | InitiallyScope
172        | StrandScope of TreeIL.var list  (* strand initialization *)        | StrandScope of TreeIL.var list  (* strand initialization *)
173        | MethodScope of TreeIL.var list  (* method body; vars are state variables *)        | MethodScope of MethodName.name * TreeIL.var list  (* method body; vars are state variables *)
174    
175    (* the supprted widths of vectors of reals on the target. *)    (* the supprted widths of vectors of reals on the target. *)
176  (* FIXME: for OpenCL 1.1, 3 is also valid *)  (* FIXME: for OpenCL 1.1, 3 is also valid *)
# Line 179  Line 206 
206                  case scope                  case scope
207  (* 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! *)
208                   of StrandScope stateVars =>                   of StrandScope stateVars =>
209                        ToCL.trBlock (vMap, saveState "StrandScope" stateVars ToCL.trAssign, blk)                        ToC.trBlock (vMap, saveState "StrandScope" stateVars ToC.trAssign, blk)
210                    | MethodScope stateVars =>                    | MethodScope(name, stateVars) =>
211                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)
212                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)
213                    | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)
# Line 192  Line 219 
219    (* variables *)    (* variables *)
220      structure Var =      structure Var =
221        struct        struct
222          fun mirror (ty, name) = {          fun mirror (ty, name, shadowEnv ) = {
223                  hostTy = ToC.trType ty,                  hostTy = ToC.trType ty,
224                  shadowTy = shadowTy ty,                  shadowTy = shadowTy ty,
225                  gpuTy = ToCL.trType ty,                  gpuTy = ToCL.trType ty,
226                  hToS = convertToShadow(ty,name),                  hToS = if globalShadowEnv = shadowEnv then
227                              convertToShadow(ty,name)
228                           else
229                              convertStrandToShadow(ty,name,"selfIn", "selfOut"),
230    
231                  var = name                  var = name
232                }                }
233          fun name (ToCL.V(_, name)) = name          fun name (ToCL.V(_, name)) = name
234          fun global (Prog{globals, imgGlobals, ...}, name, ty) = let          fun global (Prog{globals, imgGlobals, ...}, name, ty) = let
235                val x = mirror (ty, name)                val x = mirror (ty, name, globalShadowEnv)
236                fun isImgGlobal (Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}), name) =                fun isImgGlobal (Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}), name) =
237                      imgGlobals  := (name,dim) :: !imgGlobals                      imgGlobals  := (name,dim) :: !imgGlobals
238                  | isImgGlobal _ =  ()                  | isImgGlobal _ =  ()
# Line 213  Line 244 
244          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)
245          fun state (Strand{state, ...}, x) = let          fun state (Strand{state, ...}, x) = let
246                val ty = V.ty x                val ty = V.ty x
247                val x' = mirror (ty, V.name x)                val x' = mirror (ty, V.name x, strandShadowEnv)
248                in                in
249                  state := x' :: !state;                  state := x' :: !state;
250                  ToCL.V(#gpuTy x', #var x')                  ToCL.V(#gpuTy x', #var x')
# Line 234  Line 265 
265          val scopeGlobal = setScope GlobalScope          val scopeGlobal = setScope GlobalScope
266          val scopeInitially = setScope InitiallyScope          val scopeInitially = setScope InitiallyScope
267          fun scopeStrand (env, svars) = setScope (StrandScope svars) env          fun scopeStrand (env, svars) = setScope (StrandScope svars) env
268          fun scopeMethod (env, svars) = setScope (MethodScope svars) env          fun scopeMethod (env, name, svars) = setScope (MethodScope(name, svars)) env
269        (* bind a TreeIL varaiable to a target variable *)        (* bind a TreeIL varaiable to a target variable *)
270          fun bind (ENV{info, vMap, scope}, x, x') = ENV{          fun bind (ENV{info, vMap, scope}, x, x') = ENV{
271                  info = info,                  info = info,
# Line 324  Line 355 
355                        CL.mkDecl(CL.T_Array(CL.int32, SOME nDims), "base", SOME(CL.I_Array baseInit)),                        CL.mkDecl(CL.T_Array(CL.int32, SOME nDims), "base", SOME(CL.I_Array baseInit)),
356                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "size", SOME(CL.I_Array sizeInit)),                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "size", SOME(CL.I_Array sizeInit)),
357                        CL.mkDecl(worldTy, wrld,                        CL.mkDecl(worldTy, wrld,
358                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [                          SOME(CL.I_Exp(CL.E_Apply(N.allocInitially, [
359                              CL.mkVar "ProgramName",                              CL.mkVar "ProgramName",
360                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),
361                              CL.E_Bool isArray,                              CL.E_Bool isArray,
# Line 333  Line 364 
364                              CL.E_Var "size"                              CL.E_Var "size"
365                            ]))))                            ]))))
366                      ]                      ]
367              (* create the loop nest for the initially iterations              (* create the loop nest for the initially iterations *)
368                val indexVar = "ix"                val indexVar = "ix"
369                val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))                val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))
370                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [
371                        CL.mkDecl(strandTy, "sp",                        CL.mkDecl(strandTy, "sp",
372                          SOME(CL.I_Exp(                          SOME(CL.I_Exp(
373                            CL.E_Cast(strandTy,                            CL.E_Cast(strandTy,
374                            CL.E_Apply(N.inState, [CL.E_Var "wrld", CL.E_Var indexVar]))))),                            CL.E_Apply(N.inState, [CL.E_Var "wrld", CL.mkBinOp(CL.mkVar indexVar, CL.#*, CL.mkSizeof(CL.T_Named (N.strandTy name)))]))))),
375                        CL.mkCall(N.strandInit name,                        CL.mkCall(N.strandInit name, CL.E_Var "sp" :: args),
                         CL.E_Var RN.globalsVarName :: CL.E_Var "sp" :: args),  
376                        CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))                        CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))
377                      ])                      ])
378                  | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let                  | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let
# Line 358  Line 388 
388                        CL.mkComment["initially"],                        CL.mkComment["initially"],
389                        CL.mkDecl(CL.uint32, indexVar, SOME(CL.I_Exp(CL.E_Int(0, CL.uint32)))),                        CL.mkDecl(CL.uint32, indexVar, SOME(CL.I_Exp(CL.E_Int(0, CL.uint32)))),
390                        mkLoopNest iters                        mkLoopNest iters
391                      ] *)                      ]
392                val body = CL.mkBlock(                val body = CL.mkBlock(
393                      iterPrefix @                      iterPrefix @
394                      allocCode @                      allocCode @
395                        iterCode @
396                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])
397                val initFn = CL.D_Func([], worldTy, N.initially, [], body)                val initFn = CL.D_Func([], worldTy, N.initially, [], body)
398                in                in
# Line 369  Line 400 
400                  initially := initFn                  initially := initFn
401                end                end
402    
403    
404        (***** OUTPUT *****)        (***** OUTPUT *****)
405    (* FIXME: I think that the iteration and test for stable strands can be moved into the runtime, which
406     * will make the print function compatible with the C target version.
407     *)
408          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let
409              (* the print function *)              (* the print function *)
410                val prFnName = concat[name, "Print"]                val prFnName = concat[name, "_print"]
411                val prFn = let                val prFn = let
412                      val params = [                      val params = [
413                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
414                              CL.PARAM([], CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)),"status"),                            CL.PARAM([], CL.T_Ptr(CL.T_Named (RN.strandShadowTy tyName)), "self")
                             CL.PARAM([], CL.intTy,"numStrands"),  
                             CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")  
415                            ]                            ]
416                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
417                      val outState = CL.mkSelect(CL.mkSubscript(CL.mkVar "self", CL.E_Var "i"), x)                      val outState = CL.mkIndirect(CL.mkVar "self", x)
418                      val prArgs = (case ty                      val prArgs = (case ty
419                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]
420                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
421                                  val fmt = CL.mkStr(                                  val fmt = CL.E_Str(
422                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))
423                                        ^ "\n")                                        ^ "\n")
424                                  val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))                                  val args = List.tabulate (d, fn i => CL.mkApply("VSUBP",[outState, CL.mkInt (IntInf.fromInt i)] ))
425                                  in                                  in
426                                    fmt :: args                                    fmt :: args
427                                  end                                  end
428                              | Ty.TensorTy[] => [CL.mkStr "%f\n", outState]                              | Ty.TensorTy[] => [CL.E_Str "%f\n", outState]
429                              | Ty.TensorTy[d] => let                              | Ty.TensorTy[d] => let
430                                  val fmt = CL.mkStr(                                  val fmt = CL.E_Str(
431                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))
432                                        ^ "\n")                                        ^ "\n")
433                                  val args = List.tabulate (d, fn i => ToC.vecIndex(outState, d, i))                                  val args = List.tabulate (d, fn i => CL.mkApply("VSUBP",[outState, CL.mkInt (IntInf.fromInt i)]))
434                                  in                                  in
435                                    fmt :: args                                    fmt :: args
436                                  end                                  end
437                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)
438                            (* 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)  
439                      in                      in
440                        CL.D_Func(["static"], CL.voidTy, prFnName, params, body)                        CL.D_Func(["static"], CL.voidTy, prFnName, params,
441                            CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs))
442                      end                      end
443                in                in
444                  prFn                  prFn
445                end                end
446    
447          fun genStrandTyDef (targetTy, Strand{tyName, state,...}) =          fun genStrandTyDef (targetTy, Strand{state,...},tyName) =
448              (* the type declaration for the strand's state struct *)              (* the type declaration for the strand's state struct *)
449                CL.D_StructDef(                CL.D_StructDef(
450                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),
451                  tyName)                  tyName)
452    
453         (* generates the globals buffers and arguments function *)
454            fun genConvertShadowTypes (Strand{tyName, state,...}) = let
455                (* Delcare opencl setup objects *)
456                  val errVar = "err"
457                  val imgDataSizeVar = "image_dataSize"
458                  val params = [
459                          CL.PARAM([],CL.T_Ptr(CL.T_Named(tyName)), "selfIn"),
460                          CL.PARAM([],CL.T_Ptr(CL.T_Named(RN.strandShadowTy tyName)), "selfOut")
461                        ]
462                  val body = List.map (fn (x:mirror_var) => #hToS x ) (!state)
463                  in
464                    CL.D_Func([],CL.voidTy,RN.strandConvertName,params,CL.mkBlock(body))
465                  end
466        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
467          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let
468                val globalBuffErr = "error creating OpenCL global buffer"                val globalBuffErr = "error creating OpenCL global buffer\n"
469                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"),
470                      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]),
471                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
# Line 456  Line 495 
495                              CL.mkIndirect(hostVar, "data"),                              CL.mkIndirect(hostVar, "data"),
496                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
497                            ])) ::                            ])) ::
498                          errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer"]) ::                          errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer\n"]) ::
499                          genDataBuffers(globals,contextVar,errVar,errFn)                          genDataBuffers(globals,contextVar,errVar,errFn)
500                      end                      end
501                in                in
# Line 467  Line 506 
506    
507        (* generates the kernel arguments for the image data *)        (* generates the kernel arguments for the image data *)
508          fun genGlobalArguments (globals, count, kernelVar, errVar) = let          fun genGlobalArguments (globals, count, kernelVar, errVar) = let
509                val globalArgErr = "error creating OpenCL global argument"                val globalArgErr = "error creating OpenCL global argument\n"
510                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"),
511                      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]),
512                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
# Line 485  Line 524 
524                           CL.mkPostOp(CL.E_Var count, CL.^++),                           CL.mkPostOp(CL.E_Var count, CL.^++),
525                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
526                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::
527                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument"]) ::                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument\n"]) ::
528                      genDataArguments (globals,count,kernelVar,errVar,errFn)                      genDataArguments (globals,count,kernelVar,errVar,errFn)
529                in                in
530                 [globalArgument,errorFn(globalArgErr)] @ genDataArguments(globals, count, kernelVar, errVar,errorFn)                  globalArgument :: errorFn globalArgErr ::
531                      genDataArguments(globals, count, kernelVar, errVar,errorFn)
532                end                end
533    
534        (* generates the globals buffers and arguments function *)        (* generates the globals buffers and arguments function *)
# Line 521  Line 561 
561          fun genKernelFun (strand, nDims, globals, imgGlobals) = let          fun genKernelFun (strand, nDims, globals, imgGlobals) = let
562                val Strand{name, tyName, state, output, code,...} = strand                val Strand{name, tyName, state, output, code,...} = strand
563                val fName = RN.kernelFuncName;                val fName = RN.kernelFuncName;
564                val inState = "strand_in"                val inState = "selfIn"
565                val outState = "strand_out"                val outState = "selfOut"
566                val tempVar = "tmp"                val tempVar = "tmp"
567                val sizeParams = if nDims = 1 then  
568                          []                val (workerOffset,localOffset) = if nDims = 1 then
569                            ( CL.mkApply(RN.getGroupId,[CL.mkInt 0]), CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0]) )
570                      else if nDims = 2 then                      else if nDims = 2 then
571                          [CL.PARAM([], CL.intTy, "width")]                       (CL.mkBinOp(CL.mkBinOp(CL.mkApply(RN.getGroupId,[CL.mkInt 0]),CL.#*, CL.mkApply(RN.getNumGroups,[CL.mkInt 1])),CL.#+,CL.mkApply(RN.getGroupId,[CL.mkInt 1])),
572                                CL.mkBinOp(CL.mkBinOp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0]),CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 1])),CL.#+,CL.mkApply(RN.getLocalThreadId,[CL.mkInt 1])))
573                      else                      else
574                          [CL.PARAM([], CL.intTy, "width"),CL.PARAM([], CL.intTy, "height")]                            ( CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(
575                                CL.mkBinOp(CL.mkApply(RN.getGroupId,[CL.mkInt 0]), CL.#*, CL.mkApply(RN.getNumGroups,[CL.mkInt 1])),CL.#*, CL.mkApply(RN.getNumGroups,[CL.mkInt 2])), CL.#+,
576                                CL.mkBinOp(CL.mkApply(RN.getGroupId,[CL.mkInt 1]),CL.#*,CL.mkApply(RN.getNumGroups,[CL.mkInt 1]))),CL.#+,CL.mkApply(RN.getGroupId,[CL.mkInt 2])),
577                               CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(
578                                CL.mkBinOp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0]), CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 1])),CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 2])), CL.#+,
579                                CL.mkBinOp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 1]),CL.#*,CL.mkApply(RN.getLocalSize,[CL.mkInt 1]))),CL.#+,CL.mkApply(RN.getLocalThreadId,[CL.mkInt 2])) )
580    
581    
582                val copyInStm =  List.rev(List.map(fn x => CL.mkAssign(CL.mkSelect(CL.mkVar "selfIn", #var x),
583                                                                                                           CL.mkIndirect(CL.mkGrp(CL.mkBinOp(CL.mkVar "strands",CL.#+, CL.mkVar "strandIndex")), #var x))) (!state))
584    
585                val copyOutStm =  List.rev(List.map(fn x => CL.mkAssign(CL.mkIndirect(CL.mkGrp(CL.mkBinOp(CL.mkVar "strands",CL.#+, CL.mkVar "strandIndex")), #var x), CL.mkSelect(CL.mkVar "selfOut", #var x))) (!state))
586    
587                val params = [                val params = [
588                        globalParam(CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam(CL.T_Ptr(CL.T_Named tyName), "strands"),
589                        globalParam(CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam(CL.T_Ptr(CL.intTy), "strandStatus"),
590                        globalParam(CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus")] @                        globalParam(CL.T_Ptr(CL.intTy), "workQueue"),
591                        sizeParams @                        globalParam(CL.T_Ptr(CL.intTy),"numAvail"),
592                       [ globalParam(globPtrTy, RN.globalsVarName)                        clParam("",CL.intTy,"numStrands"),
593                      ] @ genKeneralGlobalParams(!imgGlobals)                        clParam("",CL.intTy,"limit")] @
594                val thread_ids = if nDims = 1                        [globalParam(globPtrTy, RN.globalsVarName)] @
595                        then [                        genKeneralGlobalParams(!imgGlobals)
596                            CL.mkDecl(CL.intTy, "x",  
597                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0]))))              val index_ids = [
598                              CL.mkDecl(CL.intTy, "workerIndex",
599                                SOME(CL.I_Exp(workerOffset))),
600                              CL.mkDecl(CL.intTy, "strandIndex",
601                                SOME(CL.I_Exp(CL.mkBinOp(CL.mkSubscript(CL.mkVar "workQueue",CL.mkVar "workerIndex"),CL.#+,CL.mkBinOp(localOffset,CL.#*,CL.mkVar "limit")))))
602                          ]                          ]
                     else if nDims = 2  
                       then [  
                           CL.mkDecl(CL.intTy, "x",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1])))),  
                           CL.mkDecl(CL.intTy, "y",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0]))))  
                         ]  
                     else  
                        [  
                           CL.mkDecl(CL.intTy, "x",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1])))),  
                           CL.mkDecl(CL.intTy, "y",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),  
                           CL.mkDecl(CL.intTy, "z",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 2]))))  
                        ]  
   
603    
604                val strandDecl = [                val strandDecl = [
605                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), inState, NONE),                        CL.mkDecl(CL.T_Named tyName, "selfIn", NONE),
606                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), outState, NONE),                        CL.mkDecl(CL.T_Named tyName, "selfOut", NONE)
                       CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), tempVar, NONE)  
607                      ]                      ]
608                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)
609                val imageDataStms = List.map (fn (x,_) =>                val imageDataStms = List.map (fn (x,_) =>
610                    CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),                    CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),
611                                CL.mkVar(RN.addBufferSuffixData x))) (!imgGlobals)                                CL.mkVar(RN.addBufferSuffixData x))) (!imgGlobals)
               val barrierCode = CL.mkIfThen(CL.mkBinOp(CL.E_Var "status",CL.#==,CL.E_Var "DIDEROT_ACTIVE"),  
                                  CL.mkBlock ([CL.mkAssign(CL.E_Var tempVar, CL.E_Var inState),  
                                  CL.mkAssign(CL.E_Var inState, CL.E_Var outState),  
                                  CL.mkAssign(CL.E_Var outState, CL.E_Var tempVar)]))  
               val barrierStm = CL.mkCall("barrier",[CL.E_Var "CLK_LOCAL_MEM_FENCE"])  
               val index = if nDims = 1 then  
                         CL.mkVar "x"  
                     else if nDims = 2 then  
                         CL.mkBinOp(  
                             CL.mkBinOp(CL.mkVar "y", CL.#*, CL.mkVar "width"), CL.#+, CL.mkVar "x")  
                     else  
                        CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(  
                             CL.mkBinOp(CL.mkVar "z", CL.#*, CL.mkVar "width"),CL.#*, CL.mkVar "height"), CL.#+,  
                             CL.mkBinOp(CL.mkVar "y",CL.#*,CL.mkVar "height")),CL.#+,CL.mkVar "x")  
612    
613                val args = if nDims = 1 then              val status = [CL.mkDecl(CL.intTy, "status", NONE)]
                         [CL.mkVar "x"]  
                     else if nDims = 2 then  
                         [CL.mkVar "x", CL.mkVar "y"]  
                     else  
                         [CL.mkVar "x", CL.mkVar "y", CL.mkVar "z"]  
614    
615    
616                val strandObjects =         val updateStm =  CL.mkAssign(CL.mkVar "status",
617                       [ CL.mkAssign(CL.mkVar inState,  CL.mkBinOp(CL.mkVar "selfIn",CL.#+,index)),                          CL.mkApply(RN.strandUpdate name,
618                         CL.mkAssign(CL.mkVar outState, CL.mkBinOp(CL.mkVar "selfOut",CL.#+,index))                            [CL.mkUnOp(CL.%&,CL.mkVar inState),
619                       ]                             CL.mkUnOp(CL.%&,CL.mkVar outState),
   
                 val stabalizeStm = CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",index),  
                                                                         CL.E_Var "status")  
               val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "strandStatus",index))))  
               val strandInitStm = CL.mkCall(RN.strandInit name, [  
620                        CL.mkVar RN.globalsVarName,                        CL.mkVar RN.globalsVarName,
621                        CL.mkVar inState] @ args)                             CL.mkVar RN.globalImageDataName]))
622                val local_vars = thread_ids  
623           val statusIf = CL.mkIfThenElse(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kStabilize),
624                        CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kStable)] @
625                                    copyOutStm @
626                                    [CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])]),
627                        CL.mkBlock([CL.mkIfThen(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kDie),
628                                    CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kDie)] @
629                                    copyOutStm @
630                                    [CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])]))]))
631    
632           val incStrand = CL.mkExpStm(CL.mkPostOp(CL.mkVar "strandIndex",CL.^++))
633    
634            val forStablize = CL.mkFor( [(CL.intTy,"idx",CL.mkInt 0)], CL.mkBinOp(CL.mkBinOp(CL.mkVar "idx", CL.#<, CL.mkVar "limit"),CL.#&&,
635                                                                         CL.mkBinOp(CL.mkVar "strandIndex", CL.#<, CL.mkVar "numStrands")),
636                                           [CL.mkPostOp(CL.mkVar "idx", CL.^++)], CL.mkBlock(
637    
638                                             copyInStm @
639                                            [ updateStm,
640                                             statusIf,
641                                             incStrand
642                                           ]))
643    
644                  val local_vars = index_ids
645                      @ [imageDataDecl]                      @ [imageDataDecl]
646                      @ imageDataStms                      @ imageDataStms
647                      @ strandDecl                      @ strandDecl
648                      @ strandObjects                      @ status
649                      @ [strandInitStm,status]  
650                val while_exp = CL.mkBinOp(CL.mkVar "status",CL.#==, CL.mkVar RN.kActive)                val body = CL.mkBlock(local_vars @ [forStablize])
               val whileBody = CL.mkBlock ([  
                       CL.mkAssign(CL.mkVar "status",  
                         CL.mkApply(RN.strandUpdate name,  
                           [CL.mkVar inState,  
                            CL.mkVar outState,  
                            CL.mkVar RN.globalsVarName,  
                            CL.mkVar RN.globalImageDataName]))] @ [barrierCode,barrierStm] )  
               val whileBlock = [CL.mkWhile(while_exp, whileBody)]  
               val body = CL.mkBlock(local_vars @ whileBlock @ [stabalizeStm])  
651                in                in
652                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)
653                end                end
# Line 653  Line 682 
682                      in                      in
683                        CL.I_Struct[                        CL.I_Struct[
684                            ("name", CL.I_Exp(CL.mkStr name)),                            ("name", CL.I_Exp(CL.mkStr name)),
685                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(N.strandTy name)))),                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),
686                              ("shadowStrandSzb",CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandShadowTy (RN.strandTy name))))),
687  (*  (*
688                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),
689  *)  *)
690                            ("update", fnPtr("update_method_t", "0")),                            ("update", fnPtr("update_method_t", "0")),
691                            ("print", fnPtr("print_method_t", name ^ "Print"))                            ("strandCopy",  fnPtr("convert_method_t", "Diderot_Strand_Covert_To_Shadow")),
692                              ("print", fnPtr("print_method_t", name ^ "_print"))
693                          ]                          ]
694                      end                      end
695                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 700  Line 731 
731                      if double                      if double
732                        then "#define DIDEROT_DOUBLE_PRECISION"                        then "#define DIDEROT_DOUBLE_PRECISION"
733                        else "#define DIDEROT_SINGLE_PRECISION",                        else "#define DIDEROT_SINGLE_PRECISION",
734                        "#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics: enable",
735                      "#define DIDEROT_TARGET_CL",                      "#define DIDEROT_TARGET_CL",
736                      "#include \"Diderot/cl-diderot.h\""                      "#include \"Diderot/cl-diderot.h\""
737                    ]));                    ]));
738                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));
739                  clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));                  clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));
740                  clppDecl (genStrandTyDef(#gpuTy, strand));                  clppDecl (genStrandTyDef(#gpuTy, strand,tyName));
                 clppDecl  (!init_code);  
741                  List.app clppDecl (!code);                  List.app clppDecl (!code);
742                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));
743                (* Generate the Host C file *)                (* Generate the Host C file *)
# Line 723  Line 754 
754                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));
755  (* FIXME: does this really need to be a global? *)  (* FIXME: does this really need to be a global? *)
756                  cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));                  cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));
757                  cppDecl (genStrandTyDef (#hostTy, strand));                  cppDecl (genStrandTyDef (#hostTy, strand, tyName));
758                    cppDecl (genStrandTyDef (#shadowTy, strand, RN.strandShadowTy tyName));
759                    cppDecl (genConvertShadowTypes strand);
760                    cppDecl  (!init_code);
761                  cppDecl (genStrandPrint strand);                  cppDecl (genStrandPrint strand);
762                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
763                  cppDecl (genGlobalBuffersArgs (!globals,imgGlobals));                  cppDecl (genGlobalBuffersArgs (!globals,imgGlobals));
# Line 762  Line 796 
796                  RunCC.link (basename, ldOpts)                  RunCC.link (basename, ldOpts)
797                end                end
798    
799        end        end (* Program *)
800    
801    (* strands *)    (* strands *)
802      structure Strand =      structure Strand =
# Line 791  Line 825 
825          fun init (Strand{name, tyName, code, init_code, ...}, params, init) = let          fun init (Strand{name, tyName, code, init_code, ...}, params, init) = let
826                val fName = RN.strandInit name                val fName = RN.strandInit name
827                val params =                val params =
828                      globalParam (globPtrTy, RN.globalsVarName) ::                      clParam ("",CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
                     globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut") ::  
829                        List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params                        List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params
830                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)
831                in                in
# Line 801  Line 834 
834    
835        (* register a strand method *)        (* register a strand method *)
836          fun method (Strand{name, tyName, code,...}, methName, body) = let          fun method (Strand{name, tyName, code,...}, methName, body) = let
837                val fName = concat[name, "_", methName]                val fName = concat[name, "_", MethodName.toString methName]
838                val params = [                val params = [
839                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        clParam ("",CL.T_Ptr(CL.T_Named tyName), "selfIn"),
840                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        clParam ("",CL.T_Ptr(CL.T_Named tyName), "selfOut"),
841                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName),                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName),
842                        CL.PARAM([],CL.T_Named(RN.imageDataType),RN.globalImageDataName)                        CL.PARAM([],CL.T_Named(RN.imageDataType),RN.globalImageDataName)
843                      ]                      ]
844                val methFn = CL.D_Func([], CL.int32, fName, params, body)                val resTy = (case methName
845                         of MethodName.Update => CL.T_Named "StrandStatus_t"
846                          | MethodName.Stabilize => CL.voidTy
847                        (* end case *))
848                  val methFn = CL.D_Func([], resTy, fName, params, body)
849                in                in
850                  code := methFn :: !code                  code := methFn :: !code
851                end                end

Legend:
Removed from v.1425  
changed lines
  Added in v.1462

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