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 1457, Fri Aug 5 07:23:07 2011 UTC revision 1458, Sun Aug 7 08:17:35 2011 UTC
# 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.
# Line 402  Line 429 
429                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),
430                  tyName)                  tyName)
431    
432    
433             fun genStrandCopy(Strand{tyName,name,state,...}) = let
434                  val params = [
435                          CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),
436                          CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfOut")
437                      ]
438                    val assignStms = List.rev(List.map(fn x => CL.mkAssign(CL.mkIndirect(CL.E_Var "selfOut", #var x),
439                                                                                                           CL.mkIndirect(CL.E_Var "selfIn", #var x))) (!state))
440                     in
441                            CL.D_Func([""], CL.voidTy, RN.strandCopy name, params,CL.mkBlock(assignStms))
442                     end
443    
444        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
445          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let
446                val globalBuffErr = "error creating OpenCL global buffer\n"                val globalBuffErr = "error creating OpenCL global buffer\n"
# Line 503  Line 542 
542                val inState = "strand_in"                val inState = "strand_in"
543                val outState = "strand_out"                val outState = "strand_out"
544                val tempVar = "tmp"                val tempVar = "tmp"
545                val localPoolNextStrand = "localPoolNextStrand"  
546                val localPoolStrandCount = "localPoolStrandCount"                val (workerOffset,localOffset) = if nDims = 1 then
547                val sizeParams = if nDims = 1 then                          ( CL.mkApply(RN.getGroupId,[CL.mkInt 0]), CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0]) )
                         []  
548                      else if nDims = 2 then                      else if nDims = 2 then
549                          [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])),
550                                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])))
551                      else                      else
552                          [CL.PARAM([], CL.intTy, "width"),CL.PARAM([], CL.intTy, "height")]                            ( CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(
553                                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.#+,
554                                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])),
555                               CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(
556                                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.#+,
557                                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])) )
558    
559                val params = [                val params = [
560                        globalParam(CL.T_Ptr(CL.T_Named tyName), "strands"),                        globalParam(CL.T_Ptr(CL.T_Named tyName), "strands"),
561                        globalParam(CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus"),                        globalParam(CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus"),
562                        globalParam(CL.T_Ptr(CL.intTy),RN.globalPoolName),                        globalParam(CL.T_Ptr(CL.intTy), "workerQueue"),
563                          globalParam(CL.T_Ptr(CL.intTy),"numAvail"),
564                        clParam("",CL.intTy,"numStrands"),                        clParam("",CL.intTy,"numStrands"),
565                        localParam(CL.T_Ptr(CL.T_Named RN.workerTy), "workers")] @                        clParam("",CL.intTy,"limit")] @
                       sizeParams @  
566                        [globalParam(globPtrTy, RN.globalsVarName)] @                        [globalParam(globPtrTy, RN.globalsVarName)] @
567                        genKeneralGlobalParams(!imgGlobals)                        genKeneralGlobalParams(!imgGlobals)
568    
569                val index_ids = [
570                val thread_ids = if nDims = 1                            CL.mkDecl(CL.intTy, "workerIndex",
571                        then [                              SOME(CL.I_Exp(workerOffset))),
572                            CL.mkDecl(CL.intTy, "globalId_x",                            CL.mkDecl(CL.intTy, "strandIndex",
573                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),                              SOME(CL.I_Exp(CL.mkBinOp(CL.mkBinOp(CL.mkSubscript(CL.mkVar "workQueue",CL.mkVar "workerIndex"),CL.#+,localOffset),CL.#*,CL.mkVar "limit"))))
                           CL.mkDecl(CL.intTy, "localId_x",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0])))),  
                           CL.mkDecl(CL.intTy, "local_size",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getLocalSize,[CL.mkInt 0])))),  
                           CL.mkDecl(CL.intTy, "index",  
                             SOME(CL.I_Exp(CL.mkVar "localId_x"))),  
                           CL.mkDecl(CL.intTy, "globalIndex",  
                             SOME(CL.I_Exp(CL.mkVar "globalId_x")))  
                         ]  
                     else if nDims = 2  
                       then [  
                           CL.mkDecl(CL.intTy, "globalId_x",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),  
                           CL.mkDecl(CL.intTy, "localId_x",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0])))),  
                           CL.mkDecl(CL.intTy, "globalId_y",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1])))),  
                           CL.mkDecl(CL.intTy, "localId_y",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 1])))),  
                           CL.mkDecl(CL.intTy, "local_size",  
                             SOME(CL.I_Exp(CL.mkBinOp(CL.mkApply(RN.getLocalSize,[CL.mkInt 0]),CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 1]))))),  
                           CL.mkDecl(CL.intTy, "index",  
                             SOME(CL.I_Exp(CL.mkBinOp(CL.mkBinOp(CL.mkVar "localId_y",CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 1])),CL.#+,CL.mkVar "localId_x")))),  
                           CL.mkDecl(CL.intTy, "globalIndex",  
                             SOME(CL.I_Exp(CL.mkBinOp(CL.mkBinOp(CL.mkVar "globalId_y",CL.#*, CL.mkVar "width"),CL.#+,CL.mkVar "globalId_x"))))  
                         ]  
                       else [  
                           CL.mkDecl(CL.intTy, "globalId_x",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),  
                           CL.mkDecl(CL.intTy, "globalId_y",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1])))),  
                           CL.mkDecl(CL.intTy, "globalId_z",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 2])))),  
                           CL.mkDecl(CL.intTy, "localId_x",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0])))),  
                           CL.mkDecl(CL.intTy, "localId_y",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 1])))),  
                           CL.mkDecl(CL.intTy, "localId_z",  
                             SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 2]))))  
574                          ]                          ]
575    
576                val strandDecl = [                val strandDecl = [
577                        CL.mkDecl(CL.T_Named tyName, "in", NONE),                        CL.mkDecl(CL.T_Named tyName, "selfIn", NONE),
578                        CL.mkDecl(CL.T_Named tyName, "out", NONE),                        CL.mkDecl(CL.T_Named tyName, "selfOut", NONE)
                       CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), inState, SOME(CL.I_Exp(CL.mkUnOp(CL.%&,CL.mkVar "in")))),  
                       CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), outState, SOME(CL.I_Exp(CL.mkUnOp(CL.%&,CL.mkVar "out")))),  
                       CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), tempVar, NONE)  
579                      ]                      ]
580                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)
581                val imageDataStms = List.map (fn (x,_) =>                val imageDataStms = List.map (fn (x,_) =>
582                    CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),                    CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),
583                                CL.mkVar(RN.addBufferSuffixData x))) (!imgGlobals)                                CL.mkVar(RN.addBufferSuffixData x))) (!imgGlobals)
584    
585              val args = (case nDims              val status = [CL.mkDecl(CL.intTy, "status", NONE)]
                      of 1 => [CL.mkVar "globalId_x"]  
                       | 2 => [CL.mkVar "globalId_x", CL.mkVar "globalId_y"]  
                       | 3 => [CL.mkVar "globalId_x", CL.mkVar "globalId_y", CL.mkVar "globalId_z"]  
                     (* end case *))  
   
             val barrierCode = CL.mkIfThen(CL.mkBinOp(CL.mkVar "globalIndex" ,CL.#<=,CL.mkVar "numStrands"),  
                                  CL.mkBlock ([CL.mkCall (RN.strandInit name,  
                                                          CL.mkVar RN.globalsVarName :: CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "globalIndex") :: args)]))  
   
            fun workerField (index,field) = CL.mkSelect(CL.mkSubscript(CL.mkVar "workers", CL.mkVar index),field)  
            fun barrierStm flags = CL.mkCall(RN.barrier,flags)  
   
               val barrierLocalStm = CL.mkCall(RN.barrier,[CL.E_Var "CLK_LOCAL_MEM_FENCE"])  
               val barrierGlobalStm = CL.mkCall(RN.barrier,[CL.E_Var "CLK_GLOBAL_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")  
   
               val initCode = [  
                       CL.mkAttrDecl(["__local", "volatile"], CL.intTy, "localPoolNextStrand", NONE),  
                       CL.mkAttrDecl(["__local", "volatile"], CL.intTy, "localPoolStrandCount", NONE),  
                       CL.mkAttrDecl(["__local", "volatile"], CL.intTy, "idle_workers", NONE),  
                       CL.mkAssign(workerField("index","status"),CL.mkVar "WORKER_IDLE"),  
                       CL.mkAssign(CL.mkVar localPoolNextStrand , CL.mkInt 0),  
                       CL.mkAssign(CL.mkVar localPoolStrandCount , CL.mkInt 0),  
                       barrierStm([CL.mkVar "CLK_LOCAL_MEM_FENCE"])  
                     ]  
   
               val status = [CL.mkDecl(CL.intTy, "status", NONE), CL.mkDecl(CL.intTy, "numAvail", NONE)]  
   
   
               (* NOTE ADD THIS LINE : localPoolStrandCount = (numAvail >= 0) ? B : abs(numAvail); *)  
               val avaliableIf = CL.mkIfThenElse(CL.mkBinOp(CL.mkVar localPoolNextStrand, CL.#>, CL.mkVar "numStrands"),  
                                                 CL.mkBlock([CL.mkAssign(CL.mkVar localPoolStrandCount, CL.mkInt 0)]),  
                                                 CL.mkBlock([CL.mkAssign(CL.mkVar "numAvail", CL.mkBinOp(CL.mkVar "numStrands", CL.#-, CL.mkBinOp(CL.mkVar localPoolNextStrand, CL.#+, CL.mkVar "B")))]))  
   
               val poolCountIf = CL.mkIfThen(CL.mkBinOp(CL.mkBinOp(CL.mkVar localPoolStrandCount, CL.#==, CL.mkInt 0), CL.#&&,CL.mkBinOp(CL.mkVar localPoolNextStrand, CL.#<, CL.mkVar "numStrands")),  
                                     CL.mkBlock([CL.mkAssign(CL.mkVar localPoolNextStrand, CL.mkApply(RN.cl_atom_add,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "globalPoolNextStrand",CL.mkInt 0)),  
                                                                                                                      CL.mkVar "B"])), avaliableIf]))  
   
   
              (* Refacotring from my previous work because what I originially had isn't correct. I tried it with my experiment test case with a bigger NDRange and it failed. Now I'm rethinking my  
                 approach  
   
               val forStablize = CL.mkFor([(CL.intTy,"idx",CL.mkInt 0)], CL.mkBinOp(CL.mkVar "idx", CL.#<, CL.mkVar "local_size"), [CL.mkPostOp(CL.mkVar "idx", CL.^++)],  *)  
   
   
               val threadZeroBlock = CL.mkIfThen(CL.mkBinOp(CL.mkBinOp(CL.mkVar "localId_x", CL.#==, CL.mkInt 0), CL.#&&, CL.mkBinOp(CL.mkVar "localId_y", CL.#==, CL.mkInt 0)),  
                                     CL.mkBlock([poolCountIf]))  
   
586    
587    
588           fun strandCopy(inStrand, outStrand) = CL.mkCall(RN.strandCopy name,[inStrand,outStrand])
589           val updateStm =  CL.mkAssign(CL.mkVar "status",
590                            CL.mkApply(RN.strandUpdate name,
591                              [CL.mkVar inState,
592                               CL.mkVar outState,
593                               CL.mkVar RN.globalsVarName,
594                               CL.mkVar RN.globalImageDataName]))
595    
596                  (*      CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kStable),
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.mkSubcript(CL.mkVar "numAvail",CL.mkInt 0))])]),
599                        CL.mkBlock([CL.mkIfThen(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kDie),
600                                    CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kDie),
601                                    strandCopy(CL.mkUnOp(CL.%&,CL.mkVar "selfOut"),CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "strandIndex")),
602                                    CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])])) *)
603    
604           val statusIf = CL.mkIfThenElse(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kStabilize),
605                        CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kStable),
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                        CL.mkBlock([CL.mkIfThen(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kDie),
609                                    CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kDie),
610                                    strandCopy(CL.mkUnOp(CL.%&,CL.mkVar "selfOut"),CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "strandIndex")),
611                                    CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])]))]))
612    
613           val incStrand = CL.mkExpStm(CL.mkPostOp(CL.mkVar "strandIndex",CL.^++))
614    
615            val forStablize = CL.mkFor( [(CL.intTy,"idx",CL.mkInt 0)], CL.mkBinOp(CL.mkBinOp(CL.mkVar "idx", CL.#<, CL.mkVar "limit"),CL.#&&,
616                                                                         CL.mkBinOp(CL.mkVar "strandIndex", CL.#<, CL.mkVar "numStrands")),
617                                           [CL.mkPostOp(CL.mkVar "idx", CL.^++)], CL.mkBlock(
618                                           [
619                                             strandCopy(CL.mkUnOp(CL.%&,CL.mkVar "selfIn"),CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "strandIndex")),
620                                             updateStm,
621                                             statusIf,
622                                             incStrand
623                                           ]))
624    
625                val local_vars = thread_ids                val local_vars = index_ids
626                      @ [imageDataDecl]                      @ [imageDataDecl]
627                      @ imageDataStms                      @ imageDataStms
628                      @ strandDecl                      @ strandDecl
629                      @ status                      @ status
630                val while_exp = CL.mkBinOp(CL.mkVar "idle_workers",CL.#!=, CL.mkVar "local_size")  
631                val whileBody = CL.mkBlock ([                val body = CL.mkBlock(local_vars @ [forStablize])
                       CL.mkAssign(CL.mkVar "status",  
                         CL.mkApply(RN.strandUpdate name,  
                           [CL.mkVar inState,  
                            CL.mkVar outState,  
                            CL.mkVar RN.globalsVarName,  
                            CL.mkVar RN.globalImageDataName]))])  
               val whileBlock = [CL.mkWhile(while_exp, whileBody)]  
               val body = CL.mkBlock(local_vars @ whileBlock)  
632                in                in
633                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)
634                end                end
# Line 744  Line 717 
717                  clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));                  clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));
718                  clppDecl (genStrandTyDef(#gpuTy, strand,tyName));                  clppDecl (genStrandTyDef(#gpuTy, strand,tyName));
719                  clppDecl  (!init_code);                  clppDecl  (!init_code);
720                    clppDecl (genStrandCopy(strand));
721                  List.app clppDecl (!code);                  List.app clppDecl (!code);
722                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));
723                (* Generate the Host C file *)                (* Generate the Host C file *)

Legend:
Removed from v.1457  
changed lines
  Added in v.1458

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