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 1430, Tue Jul 5 16:02:02 2011 UTC revision 1460, Sun Aug 7 20:31:00 2011 UTC
# Line 149  Line 149 
149        | GlobalScope        | GlobalScope
150        | InitiallyScope        | InitiallyScope
151        | StrandScope of TreeIL.var list  (* strand initialization *)        | StrandScope of TreeIL.var list  (* strand initialization *)
152        | MethodScope of TreeIL.var list  (* method body; vars are state variables *)        | MethodScope of MethodName.name * TreeIL.var list  (* method body; vars are state variables *)
153    
154    (* the supprted widths of vectors of reals on the target. *)    (* the supprted widths of vectors of reals on the target. *)
155  (* FIXME: for OpenCL 1.1, 3 is also valid *)  (* FIXME: for OpenCL 1.1, 3 is also valid *)
# Line 185  Line 185 
185                  case scope                  case scope
186  (* 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! *)
187                   of StrandScope stateVars =>                   of StrandScope stateVars =>
188                        ToCL.trBlock (vMap, saveState "StrandScope" stateVars ToCL.trAssign, blk)                        ToC.trBlock (vMap, saveState "StrandScope" stateVars ToC.trAssign, blk)
189                    | MethodScope stateVars =>                    | MethodScope(name, stateVars) =>
190                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)
191                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)
192                    | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)
# Line 240  Line 240 
240          val scopeGlobal = setScope GlobalScope          val scopeGlobal = setScope GlobalScope
241          val scopeInitially = setScope InitiallyScope          val scopeInitially = setScope InitiallyScope
242          fun scopeStrand (env, svars) = setScope (StrandScope svars) env          fun scopeStrand (env, svars) = setScope (StrandScope svars) env
243          fun scopeMethod (env, svars) = setScope (MethodScope svars) env          fun scopeMethod (env, name, svars) = setScope (MethodScope(name, svars)) env
244        (* bind a TreeIL varaiable to a target variable *)        (* bind a TreeIL varaiable to a target variable *)
245          fun bind (ENV{info, vMap, scope}, x, x') = ENV{          fun bind (ENV{info, vMap, scope}, x, x') = ENV{
246                  info = info,                  info = info,
# Line 330  Line 330 
330                        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)),
331                        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)),
332                        CL.mkDecl(worldTy, wrld,                        CL.mkDecl(worldTy, wrld,
333                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [                          SOME(CL.I_Exp(CL.E_Apply(N.allocInitially, [
334                              CL.mkVar "ProgramName",                              CL.mkVar "ProgramName",
335                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),
336                              CL.E_Bool isArray,                              CL.E_Bool isArray,
# Line 339  Line 339 
339                              CL.E_Var "size"                              CL.E_Var "size"
340                            ]))))                            ]))))
341                      ]                      ]
342                (* create the loop nest for the initially iterations *)
343                  val indexVar = "ix"
344                  val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))
345                  fun mkLoopNest [] = CL.mkBlock(createPrefix @ [
346                          CL.mkDecl(strandTy, "sp",
347                            SOME(CL.I_Exp(
348                              CL.E_Cast(strandTy,
349                              CL.E_Apply(N.inState, [CL.E_Var "wrld", CL.mkBinOp(CL.mkVar indexVar, CL.#*, CL.mkSizeof(CL.T_Named (N.strandDesc name)))]))))),
350                          CL.mkCall(N.strandInit name, CL.E_Var "sp" :: args),
351                          CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))
352                        ])
353                    | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let
354                        val body = mkLoopNest iters
355                        in
356                          CL.mkFor(
357                            [(ty, param, lo)],
358                            CL.mkBinOp(CL.E_Var param, CL.#<=, hi),
359                            [CL.mkPostOp(CL.E_Var param, CL.^++)],
360                            body)
361                        end
362                  val iterCode = [
363                          CL.mkComment["initially"],
364                          CL.mkDecl(CL.uint32, indexVar, SOME(CL.I_Exp(CL.E_Int(0, CL.uint32)))),
365                          mkLoopNest iters
366                        ]
367                val body = CL.mkBlock(                val body = CL.mkBlock(
368                      iterPrefix @                      iterPrefix @
369                      allocCode @                      allocCode @
370                        iterCode @
371                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])
372                val initFn = CL.D_Func([], worldTy, N.initially, [], body)                val initFn = CL.D_Func([], worldTy, N.initially, [], body)
373                in                in
# Line 349  Line 375 
375                  initially := initFn                  initially := initFn
376                end                end
377    
378    
379        (***** OUTPUT *****)        (***** OUTPUT *****)
380  (* FIXME: I think that the iteration and test for stable strands can be moved into the runtime, which  (* FIXME: I think that the iteration and test for stable strands can be moved into the runtime, which
381   * will make the print function compatible with the C target version.   * will make the print function compatible with the C target version.
382   *)   *)
383          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let
384              (* the print function *)              (* the print function *)
385                val prFnName = concat[name, "Print"]                val prFnName = concat[name, "_print"]
386                val prFn = let                val prFn = let
387                      val params = [                      val params = [
388                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
389                              CL.PARAM([], CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)),"status"),                            CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")
                             CL.PARAM([], CL.intTy,"numStrands"),  
                             CL.PARAM([], CL.T_Ptr(CL.T_Named (RN.strandShadowTy name)), "self")  
390                            ]                            ]
391                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
392                      val unshadowFields = (case ty                      val outState = CL.mkIndirect(CL.mkVar "self", x)
                            of Ty.IVecTy d =>  [  
                                   CL.mkDecl(ToC.trType ty,x,NONE),  
                                   CL.mkCall(RN.unshadowVec d,[CL.mkVar(x),  
                                     CL.mkSelect(CL.mkSubscript(CL.mkVar "self", CL.E_Var "i"), x)])  
                                 ]  
                             | Ty.TensorTy[d] => [  
                                   CL.mkDecl(ToC.trType ty,x,NONE),  
                                   CL.mkCall(RN.unshadowVec d,[CL.mkVar(x),  
                                     CL.mkSelect(CL.mkSubscript(CL.mkVar "self", CL.E_Var "i"), x)])  
                                 ]  
                             | _ => []  
                           (* end case *))  
                     val outState =  (case ty  
                            of Ty.IVecTy 1 =>CL.mkSelect(CL.mkSubscript(CL.mkVar "self", CL.E_Var "i"), x)  
                             | Ty.TensorTy[] => CL.mkSelect(CL.mkSubscript(CL.mkVar "self", CL.E_Var "i"), x)  
                             | Ty.IVecTy d =>CL.mkVar(x)  
                             | Ty.TensorTy[d] =>CL.mkVar(x)  
                             | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)  
                           (* end case *))  
393                      val prArgs = (case ty                      val prArgs = (case ty
394                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]
395                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
396                                  val fmt = CL.mkStr(                                  val fmt = CL.E_Str(
397                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))
398                                        ^ "\n")                                        ^ "\n")
399                                  val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))                                  val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))
400                                  in                                  in
401                                    fmt :: args                                    fmt :: args
402                                  end                                  end
403                              | Ty.TensorTy[] => [CL.mkStr "%f\n", outState]                              | Ty.TensorTy[] => [CL.E_Str "%f\n", outState]
404                              | Ty.TensorTy[d] => let                              | Ty.TensorTy[d] => let
405                                  val fmt = CL.mkStr(                                  val fmt = CL.E_Str(
406                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))
407                                        ^ "\n")                                        ^ "\n")
408                                  val args = List.tabulate (d, fn i => ToC.vecIndex(outState, d, i))                                  val args = List.tabulate (d, fn i => ToC.vecIndex(outState, d, i))
# Line 405  Line 411 
411                                  end                                  end
412                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)
413                            (* 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(unshadowFields@[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)  
414                      in                      in
415                        CL.D_Func(["static"], CL.voidTy, prFnName, params, body)                        CL.D_Func(["static"], CL.voidTy, prFnName, params,
416                            CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs))
417                      end                      end
418                in                in
419                  prFn                  prFn
# Line 426  Line 425 
425                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),
426                  tyName)                  tyName)
427    
428    
429             fun genStrandCopy(Strand{tyName,name,state,...}) = let
430                  val params = [
431                          CL.PARAM([""], CL.T_Ptr(CL.T_Named tyName), "selfIn"),
432                          CL.PARAM([""], CL.T_Ptr(CL.T_Named tyName), "selfOut")
433                      ]
434                    val assignStms = List.rev(List.map(fn x => CL.mkAssign(CL.mkIndirect(CL.E_Var "selfOut", #var x),
435                                                                                                           CL.mkIndirect(CL.E_Var "selfIn", #var x))) (!state))
436                     in
437                            CL.D_Func([""], CL.voidTy, RN.strandCopy name, params,CL.mkBlock(assignStms))
438                     end
439    
440        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
441          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let
442                val globalBuffErr = "error creating OpenCL global buffer"                val globalBuffErr = "error creating OpenCL global buffer\n"
443                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"),
444                      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]),
445                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
# Line 458  Line 469 
469                              CL.mkIndirect(hostVar, "data"),                              CL.mkIndirect(hostVar, "data"),
470                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
471                            ])) ::                            ])) ::
472                          errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer"]) ::                          errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer\n"]) ::
473                          genDataBuffers(globals,contextVar,errVar,errFn)                          genDataBuffers(globals,contextVar,errVar,errFn)
474                      end                      end
475                in                in
# Line 469  Line 480 
480    
481        (* generates the kernel arguments for the image data *)        (* generates the kernel arguments for the image data *)
482          fun genGlobalArguments (globals, count, kernelVar, errVar) = let          fun genGlobalArguments (globals, count, kernelVar, errVar) = let
483                val globalArgErr = "error creating OpenCL global argument"                val globalArgErr = "error creating OpenCL global argument\n"
484                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"),
485                      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]),
486                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
# Line 487  Line 498 
498                           CL.mkPostOp(CL.E_Var count, CL.^++),                           CL.mkPostOp(CL.E_Var count, CL.^++),
499                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
500                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::
501                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument"]) ::                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument\n"]) ::
502                      genDataArguments (globals,count,kernelVar,errVar,errFn)                      genDataArguments (globals,count,kernelVar,errVar,errFn)
503                in                in
504                 [globalArgument,errorFn(globalArgErr)] @ genDataArguments(globals, count, kernelVar, errVar,errorFn)                  globalArgument :: errorFn globalArgErr ::
505                      genDataArguments(globals, count, kernelVar, errVar,errorFn)
506                end                end
507    
508        (* generates the globals buffers and arguments function *)        (* generates the globals buffers and arguments function *)
# Line 523  Line 535 
535          fun genKernelFun (strand, nDims, globals, imgGlobals) = let          fun genKernelFun (strand, nDims, globals, imgGlobals) = let
536                val Strand{name, tyName, state, output, code,...} = strand                val Strand{name, tyName, state, output, code,...} = strand
537                val fName = RN.kernelFuncName;                val fName = RN.kernelFuncName;
538                val inState = "strand_in"                val inState = "selfIn"
539                val outState = "strand_out"                val outState = "selfOut"
540                val tempVar = "tmp"                val tempVar = "tmp"
541                val sizeParams = if nDims = 1 then  
542                          []                val (workerOffset,localOffset) = if nDims = 1 then
543                            ( CL.mkApply(RN.getGroupId,[CL.mkInt 0]), CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0]) )
544                      else if nDims = 2 then                      else if nDims = 2 then
545                          [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])),
546                                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])))
547                      else                      else
548                          [CL.PARAM([], CL.intTy, "width"),CL.PARAM([], CL.intTy, "height")]                            ( CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(
549                                CL.mkBinOp(CL.mkApply(RN.getGroupId,[CL.mkInt 0]), CL.#*, CL.mkApply(RN.getNumGroups,[CL.mkInt 1])),CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 2])), CL.#+,
550                                CL.mkBinOp(CL.mkApply(RN.getGroupId,[CL.mkInt 1]),CL.#*,CL.mkApply(RN.getLocalSize,[CL.mkInt 1]))),CL.#+,CL.mkApply(RN.getGroupId,[CL.mkInt 2])),
551                               CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(
552                                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.#+,
553                                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])) )
554    
555                val params = [                val params = [
556                        globalParam(CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam(CL.T_Ptr(CL.T_Named tyName), "strands"),
557                        globalParam(CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam(CL.T_Ptr(CL.intTy), "strandStatus"),
558                        globalParam(CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus")] @                        globalParam(CL.T_Ptr(CL.intTy), "workerQueue"),
559                        sizeParams @                        globalParam(CL.T_Ptr(CL.intTy),"numAvail"),
560                          clParam("",CL.intTy,"numStrands"),
561                          clParam("",CL.intTy,"limit")] @
562                        [globalParam(globPtrTy, RN.globalsVarName)] @                        [globalParam(globPtrTy, RN.globalsVarName)] @
563                        genKeneralGlobalParams(!imgGlobals)                        genKeneralGlobalParams(!imgGlobals)
564                val thread_ids = if nDims = 1  
565                        then [              val index_ids = [
566                            CL.mkDecl(CL.intTy, "x",                            CL.mkDecl(CL.intTy, "workerIndex",
567                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0]))))                              SOME(CL.I_Exp(workerOffset))),
568                          ]                            CL.mkDecl(CL.intTy, "strandIndex",
569                      else if nDims = 2                              SOME(CL.I_Exp(CL.mkBinOp(CL.mkSubscript(CL.mkVar "workQueue",CL.mkVar "workerIndex"),CL.#+,CL.mkBinOp(localOffset,CL.#*,CL.mkVar "limit")))))
                       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]))))  
570                          ]                          ]
571    
572                val strandDecl = [                val strandDecl = [
573                        CL.mkAttrDecl(["__global"], CL.T_Ptr(CL.T_Named tyName), inState, NONE),                        CL.mkDecl(CL.T_Named tyName, "selfIn", NONE),
574                        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)  
575                      ]                      ]
576                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)
577                val imageDataStms = List.map (fn (x,_) =>                val imageDataStms = List.map (fn (x,_) =>
578                    CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),                    CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),
579                                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")  
580    
581                val args = (case nDims              val status = [CL.mkDecl(CL.intTy, "status", NONE)]
582                       of 1 => [CL.mkVar "x"]  
583                        | 2 => [CL.mkVar "x", CL.mkVar "y"]  
584                        | 3 => [CL.mkVar "x", CL.mkVar "y", CL.mkVar "z"]         fun strandCopy(inStrand, outStrand) = CL.mkCall(RN.strandCopy name,[inStrand,outStrand])
585                      (* end case *))         val updateStm =  CL.mkAssign(CL.mkVar "status",
586                val strandObjects = [                          CL.mkApply(RN.strandUpdate name,
587                        CL.mkAssign(CL.mkVar inState,  CL.mkBinOp(CL.mkVar "selfIn",CL.#+,index)),                            [CL.mkUnOp(CL.%&,CL.mkVar inState),
588                        CL.mkAssign(CL.mkVar outState, CL.mkBinOp(CL.mkVar "selfOut",CL.#+,index))                             CL.mkUnOp(CL.%&,CL.mkVar outState),
589                      ]                             CL.mkVar RN.globalsVarName,
590                val stabalizeStm = CL.mkAssign(                             CL.mkVar RN.globalImageDataName]))
591                      CL.mkSubscript(CL.mkVar "strandStatus",index),  
592                      CL.E_Var "status")                (*      CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kStable),
593                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "strandStatus",index))))                                  strandCopy(CL.mkUnOp(CL.%&,CL.mkVar "selfOut"),CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "strandIndex")),
594                val strandInitStm = CL.mkCall(RN.strandInit name,                                  CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubcript(CL.mkVar "numAvail",CL.mkInt 0))])]),
595                        CL.mkVar RN.globalsVarName :: CL.mkVar inState :: args)                      CL.mkBlock([CL.mkIfThen(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kDie),
596                val local_vars = thread_ids                                  CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kDie),
597                                    strandCopy(CL.mkUnOp(CL.%&,CL.mkVar "selfOut"),CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "strandIndex")),
598                                    CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])])) *)
599    
600           val statusIf = CL.mkIfThenElse(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kStabilize),
601                        CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kStable),
602                                    strandCopy(CL.mkUnOp(CL.%&,CL.mkVar "selfOut"),CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "strandIndex")),
603                                    CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])]),
604                        CL.mkBlock([CL.mkIfThen(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kDie),
605                                    CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kDie),
606                                    strandCopy(CL.mkUnOp(CL.%&,CL.mkVar "selfOut"),CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "strandIndex")),
607                                    CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])]))]))
608    
609           val incStrand = CL.mkExpStm(CL.mkPostOp(CL.mkVar "strandIndex",CL.^++))
610    
611            val forStablize = CL.mkFor( [(CL.intTy,"idx",CL.mkInt 0)], CL.mkBinOp(CL.mkBinOp(CL.mkVar "idx", CL.#<, CL.mkVar "limit"),CL.#&&,
612                                                                         CL.mkBinOp(CL.mkVar "strandIndex", CL.#<, CL.mkVar "numStrands")),
613                                           [CL.mkPostOp(CL.mkVar "idx", CL.^++)], CL.mkBlock(
614                                           [
615                                             strandCopy(CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "strandIndex"),CL.mkUnOp(CL.%&,CL.mkVar "selfIn")),
616                                             updateStm,
617                                             statusIf,
618                                             incStrand
619                                           ]))
620    
621                  val local_vars = index_ids
622                      @ [imageDataDecl]                      @ [imageDataDecl]
623                      @ imageDataStms                      @ imageDataStms
624                      @ strandDecl                      @ strandDecl
625                      @ strandObjects                      @ status
626                      @ [strandInitStm,status]  
627                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])  
628                in                in
629                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)
630                end                end
# Line 648  Line 659 
659                      in                      in
660                        CL.I_Struct[                        CL.I_Struct[
661                            ("name", CL.I_Exp(CL.mkStr name)),                            ("name", CL.I_Exp(CL.mkStr name)),
662                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandShadowTy name)))),                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),
663  (*  (*
664                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),
665  *)  *)
666                            ("update", fnPtr("update_method_t", "0")),                            ("update", fnPtr("update_method_t", "0")),
667                            ("print", fnPtr("print_method_t", name ^ "Print"))                            ("print", fnPtr("print_method_t", name ^ "_print"))
668                          ]                          ]
669                      end                      end
670                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 701  Line 712 
712                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));
713                  clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));                  clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));
714                  clppDecl (genStrandTyDef(#gpuTy, strand,tyName));                  clppDecl (genStrandTyDef(#gpuTy, strand,tyName));
715                  clppDecl  (!init_code);                  clppDecl (genStrandCopy(strand));
716                  List.app clppDecl (!code);                  List.app clppDecl (!code);
717                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));
718                (* Generate the Host C file *)                (* Generate the Host C file *)
# Line 718  Line 729 
729                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));
730  (* FIXME: does this really need to be a global? *)  (* FIXME: does this really need to be a global? *)
731                  cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));                  cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));
732                  cppDecl (genStrandTyDef (#shadowTy, strand,RN.strandShadowTy name));                  cppDecl (genStrandTyDef (#hostTy, strand, tyName));
733                    cppDecl  (!init_code);
734                  cppDecl (genStrandPrint strand);                  cppDecl (genStrandPrint strand);
735                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
736                  cppDecl (genGlobalBuffersArgs (!globals,imgGlobals));                  cppDecl (genGlobalBuffersArgs (!globals,imgGlobals));
# Line 786  Line 798 
798          fun init (Strand{name, tyName, code, init_code, ...}, params, init) = let          fun init (Strand{name, tyName, code, init_code, ...}, params, init) = let
799                val fName = RN.strandInit name                val fName = RN.strandInit name
800                val params =                val params =
801                      globalParam (globPtrTy, RN.globalsVarName) ::                      clParam ("",CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
                     globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut") ::  
802                        List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params                        List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params
803                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)
804                in                in
# Line 796  Line 807 
807    
808        (* register a strand method *)        (* register a strand method *)
809          fun method (Strand{name, tyName, code,...}, methName, body) = let          fun method (Strand{name, tyName, code,...}, methName, body) = let
810                val fName = concat[name, "_", methName]                val fName = concat[name, "_", MethodName.toString methName]
811                val params = [                val params = [
812                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        clParam ("",CL.T_Ptr(CL.T_Named tyName), "selfIn"),
813                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        clParam ("",CL.T_Ptr(CL.T_Named tyName), "selfOut"),
814                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName),                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName),
815                        CL.PARAM([],CL.T_Named(RN.imageDataType),RN.globalImageDataName)                        CL.PARAM([],CL.T_Named(RN.imageDataType),RN.globalImageDataName)
816                      ]                      ]
817                val methFn = CL.D_Func([], CL.int32, fName, params, body)                val resTy = (case methName
818                         of MethodName.Update => CL.T_Named "StrandStatus_t"
819                          | MethodName.Stabilize => CL.voidTy
820                        (* end case *))
821                  val methFn = CL.D_Func([], resTy, fName, params, body)
822                in                in
823                  code := methFn :: !code                  code := methFn :: !code
824                end                end

Legend:
Removed from v.1430  
changed lines
  Added in v.1460

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