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 1640, Wed Nov 16 02:19:51 2011 UTC revision 1641, Fri Nov 18 12:44:32 2011 UTC
# Line 211  Line 211 
211          fun fragment (ENV{info, vMap, scope}, blk) = let          fun fragment (ENV{info, vMap, scope}, blk) = let
212                val (vMap, stms) = (case scope                val (vMap, stms) = (case scope
213                       of GlobalScope => ToC.trFragment (vMap, blk)                       of GlobalScope => ToC.trFragment (vMap, blk)
 (* NOTE: if we move strand initialization to the GPU, then we'll have to change the following code! *)  
214                        | InitiallyScope => ToC.trFragment (vMap, blk)                        | InitiallyScope => ToC.trFragment (vMap, blk)
215                        | _ => ToCL.trFragment (vMap, blk)                        | _ => ToCL.trFragment (vMap, blk)
216                      (* end case *))                      (* end case *))
# Line 219  Line 218 
218                  (ENV{info=info, vMap=vMap, scope=scope}, stms)                  (ENV{info=info, vMap=vMap, scope=scope}, stms)
219                end                end
220          fun block (ENV{vMap, scope, ...}, blk) = (case scope          fun block (ENV{vMap, scope, ...}, blk) = (case scope
 (* NOTE: if we move strand initialization to the GPU, then we'll have to change the following code! *)  
221                 of StrandScope => ToC.trBlock (vMap, blk)                 of StrandScope => ToC.trBlock (vMap, blk)
222                  | MethodScope name => ToCL.trBlock (vMap, blk)                  | MethodScope name => ToCL.trBlock (vMap, blk)
223                  | InitiallyScope => ToCL.trBlock (vMap, blk)                  | InitiallyScope => ToCL.trBlock (vMap, blk)
# Line 459  Line 457 
457                end                end
458    
459          fun genStrandTyDef (targetTy, Strand{state,...}, tyName) =          fun genStrandTyDef (targetTy, Strand{state,...}, tyName) =
460              (* the type declaration for the strand's state struct *)                  (case state
461                CL.D_StructDef(                     of [] => CL.D_Comment(["No Strand Defintiion Included"])
462                  revmap (fn x => (targetTy x, #var x)) state,                      | _ => CL.D_StructDef(revmap (fn x => (targetTy x, #var x)) state,
463                  tyName)                  tyName)
464                                     (* end case *))
465    
466    
467    
468       (* generates the globals buffers and arguments function *)       (* generates the globals buffers and arguments function *)
469          fun genConvertShadowTypes (Strand{name, tyName, state,...}) = let          fun genConvertShadowTypes (Strand{name, tyName, state,...}) = let
# Line 567  Line 568 
568                  CL.D_Func([],CL.voidTy,RN.globalsSetupName,params,CL.mkBlock(body))                  CL.D_Func([],CL.voidTy,RN.globalsSetupName,params,CL.mkBlock(body))
569                end                end
570    
571        (* generate the data and global parameters *)        (* generate the global image meta-data and data parameters *)
572          fun genKeneralGlobalParams ((name,tyname)::[],line) =          fun genKeneralGlobalParams ((name,tyname)::[],line) =
573                concat[line, "__global void *", RN.addBufferSuffixData name]                concat[line, "__global void *", RN.addBufferSuffixData name]
574            | genKeneralGlobalParams ([],line) = line            | genKeneralGlobalParams ([],line) = line
575            | genKeneralGlobalParams ((name,tyname)::rest, line) =            | genKeneralGlobalParams ((name,tyname)::rest, line) =
576                genKeneralGlobalParams(rest, concat[line, "__global void *", RN.addBufferSuffixData name, ","])                genKeneralGlobalParams(rest, concat[line, "__global void *", RN.addBufferSuffixData name, ":"])
577    
578          fun genUpdateMethod (Strand{name, tyName, state,...},imgGlobals) = let          fun genUpdateMethod (Strand{name, tyName, state,...},globals,imgGlobals) = let
579  (* FIXME: read the file using TextIO.inputAll *)  (* FIXME: read the file using TextIO.inputAll *)
580                fun readPlaceholders () = let                fun readPlaceholders () = let
581                      val infile = concat[Paths.diderotSrc, "/lib/cl-target/cl-kernels/update_cl.in"]                      val infile = concat[Paths.diderotSrc, "/lib/cl-target/cl-kernels/update_cl.in"]
# Line 594  Line 595 
595                          ])                          ])
596                          (!imgGlobals)                          (!imgGlobals)
597                val placeHolders = [(RN.place_holders, tyName),                val placeHolders = [(RN.place_holders, tyName),
598                                      (RN.p_addDatPtr, (case !imgGlobals
599                                                        of [] => ""
600                                                        |  _ => ","
601                                                       (*end of case*))),
602                                      (RN.p_addGlobals,(case !globals
603                                                        of [] => ""
604                                                        |  _ => ","
605                                                       (*end of case*))),
606                                      (RN.p_globals,(case !globals
607                                                        of [] => ""
608                                                        |  _ => "__global Diderot_Globals_t *diderotGlobals"
609                                                       (*end of case*))),
610                                    (RN.p_dataPtr, genKeneralGlobalParams (!imgGlobals, "")),                                    (RN.p_dataPtr, genKeneralGlobalParams (!imgGlobals, "")),
611                                    (RN.p_dataAssign, String.concat imageDataStms)]                                    (RN.p_dataAssign,  (case !imgGlobals
612                                                        of [] => ""
613                                                        |  _ => concat["Diderot_data_ptr_t diderotDataPtrs;",
614                                                         String.concat imageDataStms]
615                                                       (*end of case*)))]
616                in                in
617                  CL.verbatim updateFn placeHolders                  CL.verbatim updateFn placeHolders
618                end                end
619    
620    
 (* FIXME: we should figure out a way to avoid the complexity of building an AST for the scheduler  
  * code, since that will make it hard to maintain.  Perhaps we can do string substitution on a  
  * template?  
  *)  
       (* generate the main kernel function for the .cl file *)  
         fun genKernelFun (strand, nDims, globals, imgGlobals) = let  
               val Strand{name, tyName, state, output, code,...} = strand  
               val fName = RN.kernelFuncName;  
               val inState = "selfIn"  
               val outState = "selfOut"  
               val tempVar = "tmp"  
               val workerOffset = CL.mkApply(RN.getGroupId, [CL.mkInt 0])  
               val localOffset = CL.mkApply(RN.getLocalThreadId, [CL.mkInt 0])  
   
               val params = [  
                       globalParam(CL.T_Ptr(CL.T_Named tyName), "stateIn"),  
                       globalParam(CL.T_Ptr(CL.T_Named tyName), "stateOut"),  
                       globalParam(CL.T_Ptr(CL.intTy), "status"),  
                       globalParam(CL.T_Ptr(CL.T_Named (RN.schedTy)), "sched"),  
                       globalParam(CL.T_Ptr(CL.T_Named (RN.strandBlkTy)), "blocks"),  
                       globalParam(CL.T_Ptr(CL.intTy), "blockIndxs"),  
                       globalParam(CL.T_Ptr(CL.intTy), "queue"),  
                       globalParam(CL.T_Ptr(CL.intTy), "todoList"),  
                       localParam(CL.T_Ptr(CL.T_Named (RN.strandBlkTy)), "bp")  
                     ] @  
                     [globalParam(globPtrTy, RN.globalsVarName)]  
                     (* genKeneralGlobalParams(!imgGlobals) *)  
   
               val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)  
               val imageDataStms = List.map  
                     (fn (x,_) => CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),  
                                 CL.mkVar(RN.addBufferSuffixData x)))  
                       (!imgGlobals)  
   
   
              val idStm = CL.mkDecl(CL.intTy,"id", SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0]))))  
              val idxStm = CL.mkDecl(CL.intTy,"idx", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "blockIndxs",CL.mkBinOp(CL.mkBinOp(CL.mkIndirect(CL.mkVar "bp","blkIdx"),CL.#*,CL.mkVar "BLK_SZ"),CL.#+,CL.mkVar "id")))))  
              val updateStm = CL.mkDecl(CL.intTy,"sts", SOME(CL.I_Exp(CL.mkApply(RN.strandUpdate,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "stateIn",CL.mkVar "idx")),  
                                                          CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "stateOut",CL.mkVar "idx")),  
                                                          CL.mkVar (RN.globalsVarName),  
                                                          CL.mkVar (RN.globalImageDataName)]))))  
   
              val ifZeroThreadCond = CL.mkBinOp(CL.mkVar "id",CL.#==, CL.mkInt 0)  
              val ifBlockIsNullCond = CL.mkBinOp(CL.mkIndirect(CL.mkVar "bp","nActive"),CL.#!=,CL.mkInt ~1)  
              val ifIdisLessThenCond = CL.mkBinOp(CL.mkVar "id",CL.#<,CL.mkIndirect(CL.mkVar "bp","nActive"))  
              val ifTodoListCond = CL.mkBinOp(CL.mkBinOp(CL.mkIndirect(CL.mkVar "bp","nStabilizing"),CL.#+,CL.mkIndirect(CL.mkVar "bp","nDying")),  
                                              CL.#>,CL.mkInt 0)  
              val ifLastZeroThreadStm = CL.mkIfThen(ifZeroThreadCond, CL.mkBlock([CL.mkDecl(CL.intTy,"todoIdx", SOME(CL.I_Exp(CL.mkApply(RN.atom_inc,[CL.mkUnOp(CL.%&,CL.mkIndirect(CL.mkVar "sched","todoSize"))])))),  
                                            CL.mkAssign(CL.mkSubscript(CL.mkVar "todoList",CL.mkVar "todoIdx"),CL.mkIndirect(CL.mkVar "bp","blkIdx"))]))  
              val barrierStm = CL.mkCall(RN.barrier, [CL.mkVar (RN.local_fence)])  
              val ifDieCond = CL.mkBinOp(CL.mkVar "sts",CL.#==,CL.mkVar "DIDEROT_DIE")  
              val ifStabilizeCond = CL.mkBinOp(CL.mkVar "sts",CL.#==,CL.mkVar "DIDEROT_STABILIZE")  
              val ifActiveCond = CL.mkBinOp(CL.mkVar "sts",CL.#==,CL.mkVar "DIDEROT_ACTIVE")  
              val ifZeroInnerStm = CL.mkIfThen(ifBlockIsNullCond,CL.mkBlock([CL.mkAssign(CL.mkIndirect(CL.mkVar "bp","nStabilizing"),CL.mkInt 0),  
                                                                             CL.mkAssign(CL.mkIndirect(CL.mkVar "bp","nDying"),CL.mkInt 0)]))  
              val ifZeroThreadStm = CL.mkIfThen(  
                     ifZeroThreadCond,  
                     CL.mkBlock [  
                         CL.mkCall(RN.getBlockFuncName, [  
                             CL.mkVar "sched",  
                             CL.mkVar "blockIndxs",  
                             CL.mkVar "queue",  
                             CL.mkVar "blocks",  
                             CL.mkVar "bp"  
                           ]),  
                         ifZeroInnerStm  
                       ])  
             (* val ifLastZeroThreadStm= CL.mkIfThen(ifZeroThreadCond,CL.mkBlock([ifTodoStm])) *)  
   
   
              val ifDieStm = CL.mkIfThen(ifDieCond,CL.mkBlock([CL.mkCall(RN.atom_inc,[CL.mkUnOp(CL.%&,CL.mkSelect(CL.mkSubscript(CL.mkVar "blocks",CL.mkIndirect(CL.mkVar "bp", "blkIdx")), "nDying"))]),  
                                          CL.mkAssign(CL.mkSubscript(CL.mkVar "status",CL.mkVar "idx"),CL.mkVar "sts")  
                                          ]))  
              val ifStableStm = CL.mkIfThen(ifStabilizeCond,CL.mkBlock([CL.mkCall(RN.atom_inc,[CL.mkUnOp(CL.%&,CL.mkSelect(CL.mkSubscript(CL.mkVar "blocks",CL.mkIndirect(CL.mkVar "bp", "blkIdx")), "nStabilizing"))]),  
                                          CL.mkAssign(CL.mkSubscript(CL.mkVar "status",CL.mkVar "idx"),CL.mkVar "DIDEROT_STABLE"),  
                                        CL.mkCall(RN.strandCopy,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "stateOut",CL.mkVar"idx")),CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "stateIn", CL.mkVar "idx"))]),  
                                          CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkIndirect(CL.mkVar "sched","numAvailable"))])  
                                          ]))  
              val ifActiveStm = CL.mkIfThen(ifActiveCond,CL.mkBlock([CL.mkCall(RN.strandCopy,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "stateOut",CL.mkVar"idx")),CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "stateIn", CL.mkVar "idx"))])  
                                             ]))  
   
   
              val ifThreadActive = CL.mkIfThen(ifIdisLessThenCond,CL.mkBlock([updateStm,ifDieStm,ifStableStm,ifActiveStm]))  
   
              val ifBlockACtive = CL.mkIfThen(ifBlockIsNullCond,CL.mkBlock([idxStm,ifThreadActive,barrierStm,ifLastZeroThreadStm]))  
   
   
              val doLoopStm = CL.mkDoWhile(CL.mkBlock([ifZeroThreadStm,barrierStm,ifBlockACtive]),ifBlockIsNullCond)  
   
               val body = CL.mkBlock([imageDataDecl] @ imageDataStms  @ [idStm,doLoopStm])  
               in  
                 CL.D_Func(["__kernel","__attribute__((reqd_work_group_size(BLK_SZ, 1, 1)))"], CL.voidTy, fName, params, body)  
               end  
   
621          fun genStrandCopy(Strand{tyName,name,state,...}) = let          fun genStrandCopy(Strand{tyName,name,state,...}) = let
622                val params = [                val params = [
623                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),
# Line 712  Line 635 
635          fun genGlobalStruct (targetTy, globals, tyName) = let          fun genGlobalStruct (targetTy, globals, tyName) = let
636                val globs = List.map (fn (x : mirror_var) => (targetTy x, #var x)) globals                val globs = List.map (fn (x : mirror_var) => (targetTy x, #var x)) globals
637                in                in
638                  CL.D_StructDef(globs, tyName)                   (case globals
639                        of [] => CL.D_Comment(["No Global Definition"])
640                         |  _ => CL.D_StructDef(globs, tyName)
641                       (*end of case *))
642                end                end
643    
644        (* generate a global structure type definition from the image data of the image globals *)        (* generate a global structure type definition from the image data of the image globals *)
# Line 721  Line 647 
647                      (fn (x, _) => (globalPtr CL.voidTy, RN.imageDataName x))                      (fn (x, _) => (globalPtr CL.voidTy, RN.imageDataName x))
648                        imgGlobals                        imgGlobals
649                in                in
650                  CL.D_StructDef(globs, tyName)                   (case imgGlobals
651                        of [] => CL.D_Comment(["No Inage Data Ptrs Definition"])
652                         |  _ => CL.D_StructDef(globs, tyName)
653                       (*end of case *))
654    
655                end                end
656    
657          fun genGlobals (declFn, targetTy, globals) = let          fun genGlobals (declFn, targetTy, globals) = let
# Line 827  Line 757 
757                  clppDecl (genStrandTyDef(#gpuTy, strand,tyName));                  clppDecl (genStrandTyDef(#gpuTy, strand,tyName));
758                  List.app clppDecl (!code);                  List.app clppDecl (!code);
759                  clppDecl (genStrandCopy(strand));                  clppDecl (genStrandCopy(strand));
760                (*  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals)); *)                  clppDecl (genUpdateMethod(strand,globals,imgGlobals));
                 clppDecl (genUpdateMethod(strand,imgGlobals));  
761                (* Generate the Host C file *)                (* Generate the Host C file *)
762                  cppDecl (CL.D_Verbatim[                  cppDecl (CL.D_Verbatim[
763                      if double                      if double

Legend:
Removed from v.1640  
changed lines
  Added in v.1641

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