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 1382, Thu Jun 23 20:03:05 2011 UTC revision 1406, Wed Jun 29 18:55:12 2011 UTC
# Line 400  Line 400 
400                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),
401                  tyName)                  tyName)
402    
         fun genStrandCopy(Strand{tyName,name,state,...}) = let  
               val params = [  
                     CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),  
                     CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfOut")  
                   ]  
               val assignStms = List.rev(List.map(fn x => CL.mkAssign(CL.mkIndirect(CL.E_Var "selfOut", #var x),                                                                                                                          CL.mkIndirect(CL.E_Var "selfIn", #var x))) (!state))  
               in  
                 CL.D_Func([""], CL.voidTy, RN.strandCopy name, params,CL.mkBlock(assignStms))  
               end  
   
403        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
404          fun getGlobalDataBuffers (globals, contextVar, errVar) = let          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let
405                val globalBuffErr = "error creating OpenCL global buffer"                val globalBuffErr = "error creating OpenCL global buffer"
406                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"),
407                      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]),
408                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
409                  val shadowTypeDecl =
410                        CL.mkDecl(CL.T_Named(RN.shadowGlobalsTy), RN.shadowGlaobalsName, NONE)
411                  val globalImagesToShadowStms = List.map (fn (var,nDims) =>
412                        CL.mkCall((RN.shadowImageFunc nDims), [
413                             CL.mkVar contextVar,
414                             CL.mkUnOp(CL.%&,CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),var)),
415    (* FIXME: for vectors and matrices, we need to invoke the appropriate shadow function from shadow-types.h *)
416                             CL.mkIndirect(CL.mkVar(RN.globalsVarName),var)
417                             ])) imgGlobals
418                (* Converts only the non-image-field types into their corresponding global shadow types *)
419                  fun convertToShadow ((global:mirror_var)::rest,(imgGlobal,nDim)::restImages) =
420    (* FIXME: for vectors and matrices, we need to invoke the appropriate shadow function from shadow-types.h.
421     * also, we should be able to combine this case and the following one to reduce redundancy.
422     *)
423                        if (#var global) = imgGlobal
424                          then convertToShadow(rest,restImages)
425                          else CL.mkAssign(CL.mkSelect(CL.mkVar RN.shadowGlaobalsName, #var global),
426                              CL.mkIndirect(CL.mkVar(RN.globalsVarName), #var global)) ::
427                            convertToShadow(rest,(imgGlobal,nDim)::restImages)
428                    | convertToShadow ((global:mirror_var)::rest, []) =
429                        CL.mkAssign(CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),#var global),
430                            CL.mkIndirect(CL.mkVar(RN.globalsVarName), #var global)) ::
431                        convertToShadow(rest,[])
432    (* FIXME: what if the second argument is non-nil? *)
433                    | convertToShadow ([], _) = []
434                  val globalToShadowStms = convertToShadow(globals,imgGlobals)
435                val globalBufferDecl = CL.mkDecl(clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)                val globalBufferDecl = CL.mkDecl(clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)
436                val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]),                val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]),
437                      CL.mkApply("clCreateBuffer", [                      CL.mkApply("clCreateBuffer", [
438                          CL.mkVar contextVar,                          CL.mkVar contextVar,
439                          CL.mkVar "CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR",                          CL.mkVar "CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR",
440                          CL.mkSizeof(CL.T_Named RN.globalsTy),                          CL.mkSizeof(CL.T_Named RN.shadowGlobalsTy),
441                          CL.mkVar RN.globalsVarName,                          CL.mkUnOp(CL.%&,CL.mkVar RN.shadowGlaobalsName),
442                          CL.mkUnOp(CL.%&,CL.mkVar errVar)                          CL.mkUnOp(CL.%&,CL.mkVar errVar)
443                        ]))                        ]))
444                fun genDataBuffers ([],_,_,_) = []                fun genDataBuffers ([],_,_,_) = []
445                  | genDataBuffers ((var,nDims)::globals, contextVar, errVar,errFn) = let                  | genDataBuffers ((var,nDims)::globals, contextVar, errVar,errFn) = let
446                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)
447  (* FIXME: use CL constructors to build expressions (not strings) *)                      val size = CL.mkIndirect(hostVar, "dataSzb")
                     fun sizeExp i = CL.mkSubscript(CL.mkIndirect(hostVar, "size"), CL.mkInt i)  
 (* FIXME: there is no reason that images have to be restricted to float elements! *)  
                     val size = CL.mkBinOp(CL.mkSizeof(CL.float), CL.#*, sizeExp 0)  
                     val size = if (nDims > 1)  
                           then CL.mkBinOp(size, CL.#*, sizeExp 1)  
                           else size  
                     val size = if (nDims > 2)  
                           then CL.mkBinOp(size, CL.#*, sizeExp 2)  
                           else size  
448                      in                      in
                       CL.mkDecl(clMemoryTy, RN.addBufferSuffix var ,NONE)::  
449                        CL.mkDecl(clMemoryTy, RN.addBufferSuffixData var ,NONE)::                        CL.mkDecl(clMemoryTy, RN.addBufferSuffixData var ,NONE)::
                       CL.mkAssign(CL.mkVar(RN.addBufferSuffix var),  
                         CL.mkApply("clCreateBuffer", [  
                             CL.mkVar contextVar,  
                             CL.mkVar "CL_MEM_COPY_HOST_PTR",  
                             CL.mkSizeof(CL.T_Named(RN.imageTy nDims)),  
                             hostVar,  
                             CL.mkUnOp(CL.%&,CL.mkVar errVar)  
                           ])) ::  
                       errFn(concat["error in creating ",RN.addBufferSuffix var, " global buffer"]) ::  
450                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),
451                          CL.mkApply("clCreateBuffer", [                          CL.mkApply("clCreateBuffer", [
452                              CL.mkVar contextVar,                              CL.mkVar contextVar,
453                              CL.mkVar "CL_MEM_COPY_HOST_PTR",                              CL.mkVar "CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR",
454                              size,                              size,
455                              CL.mkIndirect(hostVar, "data"),                              CL.mkIndirect(hostVar, "data"),
456                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
# Line 462  Line 459 
459                          genDataBuffers(globals,contextVar,errVar,errFn)                          genDataBuffers(globals,contextVar,errVar,errFn)
460                      end                      end
461                in                in
462                  globalBufferDecl                  [shadowTypeDecl] @ globalImagesToShadowStms @ globalToShadowStms
463                  :: globalBuffer                  @ [globalBufferDecl, globalBuffer,errorFn(globalBuffErr)]
464                  :: errorFn(globalBuffErr)                  @ genDataBuffers(imgGlobals,contextVar,errVar,errorFn)
                 :: genDataBuffers(globals,contextVar,errVar,errorFn)  
465                end                end
466    
467        (* generates the kernel arguments for the image data *)        (* generates the kernel arguments for the image data *)
# Line 474  Line 470 
470                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"),
471                      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]),
472                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
473                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.&=,
474                      CL.mkApply("clSetKernelArg",                      CL.mkApply("clSetKernelArg",
475                        [CL.mkVar kernelVar,                        [CL.mkVar kernelVar,
476                         CL.mkPostOp(CL.E_Var count, CL.^++),                         CL.mkPostOp(CL.E_Var count, CL.^++),
# Line 487  Line 483 
483                          [CL.mkVar kernelVar,                          [CL.mkVar kernelVar,
484                           CL.mkPostOp(CL.E_Var count, CL.^++),                           CL.mkPostOp(CL.E_Var count, CL.^++),
485                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
                          CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffix var))]))) ::  
                          errFn(concat["error in creating ",RN.addBufferSuffix var, " argument"]) ::  
                     CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.$=,  
                       CL.mkApply("clSetKernelArg",  
                         [CL.mkVar kernelVar,  
                          CL.mkPostOp(CL.E_Var count, CL.^++),  
                          CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),  
486                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::
487                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument"]) ::                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument"]) ::
488                      genDataArguments (globals,count,kernelVar,errVar,errFn)                      genDataArguments (globals,count,kernelVar,errVar,errFn)
# Line 502  Line 491 
491                end                end
492    
493        (* generates the globals buffers and arguments function *)        (* generates the globals buffers and arguments function *)
494          fun genGlobalBuffersArgs imgGlobals = let          fun genGlobalBuffersArgs (globals,imgGlobals) = let
495              (* Delcare opencl setup objects *)              (* Delcare opencl setup objects *)
496                val errVar = "err"                val errVar = "err"
497                val imgDataSizeVar = "image_dataSize"                val imgDataSizeVar = "image_dataSize"
# Line 512  Line 501 
501                        CL.PARAM([],CL.T_Named("cl_command_queue"), "cmdQ"),                        CL.PARAM([],CL.T_Named("cl_command_queue"), "cmdQ"),
502                        CL.PARAM([],CL.T_Named("int"), "argStart")                        CL.PARAM([],CL.T_Named("int"), "argStart")
503                      ]                      ]
504                val clGlobalBuffers = getGlobalDataBuffers(!imgGlobals, "context", errVar)                val clGlobalBuffers = getGlobalDataBuffers(globals,!imgGlobals, "context", errVar)
505                val clGlobalArguments = genGlobalArguments(!imgGlobals, "argStart", "kernel", errVar)                val clGlobalArguments = genGlobalArguments(!imgGlobals, "argStart", "kernel", errVar)
506              (* Body put all the statments together *)              (* Body put all the statments together *)
507                val body = CL.mkDecl(clIntTy, errVar, SOME(CL.I_Exp(CL.mkInt 0)))                val body = CL.mkDecl(clIntTy, errVar, SOME(CL.I_Exp(CL.mkInt 0)))
# Line 523  Line 512 
512    
513        (* generate the data and global parameters *)        (* generate the data and global parameters *)
514          fun genKeneralGlobalParams ((name,tyname)::rest) =          fun genKeneralGlobalParams ((name,tyname)::rest) =
               globalParam (CL.T_Ptr(CL.T_Named (RN.imageTy tyname)), RN.addBufferSuffix name) ::  
515                globalParam (CL.T_Ptr(CL.voidTy), RN.addBufferSuffixData name) ::                globalParam (CL.T_Ptr(CL.voidTy), RN.addBufferSuffixData name) ::
516                genKeneralGlobalParams rest                genKeneralGlobalParams rest
517            | genKeneralGlobalParams [] = []            | genKeneralGlobalParams [] = []
518    
       (*generate code for intilizing kernel global data *)  
 (* FIXME: should use List.map here *)  
         fun initGlobalImages ((name, tyname)::rest) =  
               CL.mkAssign(  
                 CL.mkIndirect(CL.E_Var RN.globalsVarName, name),  
                 CL.mkVar (RN.addBufferSuffix name)) ::  
               CL.mkAssign(  
                 CL.mkIndirect(CL.mkIndirect(CL.E_Var RN.globalsVarName, name), "data"),  
                 CL.mkVar (RN.addBufferSuffixData name)) ::  
               initGlobalImages rest  
           | initGlobalImages [] = []  
   
519        (* generate the main kernel function for the .cl file *)        (* generate the main kernel function for the .cl file *)
520          fun genKernelFun (strand, nDims, globals, imgGlobals) = let          fun genKernelFun (strand, nDims, globals, imgGlobals) = let
521                val Strand{name, tyName, state, output, code,...} = strand                val Strand{name, tyName, state, output, code,...} = strand
# Line 572  Line 548 
548                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), outState, NONE),                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), outState, NONE),
549                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), tempVar, NONE)                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), tempVar, NONE)
550                      ]                      ]
551                val barrierCode = CL.mkCall(RN.strandCopy name, [CL.E_Var outState, CL.E_Var inState])                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)
552                  val imageDataStms = List.map (fn (x,_) =>
553                      CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),
554                                  CL.mkVar(RN.addBufferSuffixData x))) (!imgGlobals)
555                  val barrierCode = CL.mkIfThen(CL.mkBinOp(CL.E_Var "status",CL.#==,CL.E_Var "DIDEROT_ACTIVE"),
556                                     CL.mkBlock ([CL.mkAssign(CL.E_Var tempVar, CL.E_Var inState),
557                                     CL.mkAssign(CL.E_Var inState, CL.E_Var outState),
558                                     CL.mkAssign(CL.E_Var outState, CL.E_Var tempVar)]))
559                val barrierStm = CL.mkCall("barrier",[CL.E_Var "CLK_LOCAL_MEM_FENCE"])                val barrierStm = CL.mkCall("barrier",[CL.E_Var "CLK_LOCAL_MEM_FENCE"])
560                val index = if nDims = 1 then                val index = if nDims = 1 then
561                          CL.mkStr "x"                          CL.mkStr "x"
# Line 589  Line 572 
572                                                                          CL.E_Var "status")                                                                          CL.E_Var "status")
573                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "strandStatus",index))))                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "strandStatus",index))))
574                val strandInitStm = CL.mkCall(RN.strandInit name, [                val strandInitStm = CL.mkCall(RN.strandInit name, [
575                        CL.E_Var RN.globalsVarName,                        CL.mkVar RN.globalsVarName,
576                        CL.E_Var outState,                        CL.mkVar inState,
577                        CL.E_Var "x",                        CL.mkVar "x",
578  (* FIXME: if nDims = 1, then "y" is not defined! the arguments to this call should really come from  (* FIXME: if nDims = 1, then "y" is not defined! the arguments to this call should really come from
579   * the initially code!   * the initially code!
580   *)   *)
581                        CL.E_Var "y"])                        CL.mkVar "y"])
582                val local_vars = thread_ids                val local_vars = thread_ids
583                      @ initGlobalImages(!imgGlobals)                      @ [imageDataDecl]
584                        @ imageDataStms
585                      @ strandDecl                      @ strandDecl
586                      @ strandObjects                      @ strandObjects
587                      @ [strandInitStm,status]                      @ [strandInitStm,status]
588                val while_exp = CL.mkBinOp(CL.mkVar "status",CL.#==, CL.mkVar RN.kActive)                val while_exp = CL.mkBinOp(CL.mkVar "status",CL.#==, CL.mkVar RN.kActive)
589                val whileBody = CL.mkBlock ([barrierCode,barrierStm] @ [                val whileBody = CL.mkBlock ([
590                        CL.mkAssign(CL.mkVar "status",                        CL.mkAssign(CL.mkVar "status",
591                          CL.mkApply(RN.strandUpdate name,                          CL.mkApply(RN.strandUpdate name,
592                            [CL.mkVar inState, CL.mkVar outState,CL.E_Var RN.globalsVarName]))] )                            [CL.mkVar inState,
593                               CL.mkVar outState,
594                               CL.mkVar RN.globalsVarName,
595                               CL.mkVar RN.globalImageDataName]))] @ [barrierCode,barrierStm] )
596                val whileBlock = [CL.mkWhile(while_exp, whileBody)]                val whileBlock = [CL.mkWhile(while_exp, whileBody)]
597                val body = CL.mkBlock(local_vars @ whileBlock @ [stabalizeStm])                val body = CL.mkBlock(local_vars @ whileBlock @ [stabalizeStm])
598                in                in
# Line 619  Line 606 
606                  CL.D_StructDef(globs, tyName)                  CL.D_StructDef(globs, tyName)
607                end                end
608    
609          (* generate a global structure type definition from the image data of the image globals *)
610            fun genImageDataStruct (imgGlobals, tyName) = let
611                  val globs = List.map (fn (x,_) => (CL.T_Ptr(CL.imageDataTy "__global"),(RN.imageDataName x))) imgGlobals
612                  in
613                    CL.D_StructDef(globs, tyName)
614                  end
615    
616          fun genGlobals (declFn, targetTy, globals) = let          fun genGlobals (declFn, targetTy, globals) = let
617                fun doVar (x : mirror_var) = declFn (CL.D_Var([], targetTy x, #var x, NONE))                fun doVar (x : mirror_var) = declFn (CL.D_Var([], targetTy x, #var x, NONE))
618                in                in
# Line 684  Line 678 
678                      "#include \"Diderot/cl-diderot.h\""                      "#include \"Diderot/cl-diderot.h\""
679                    ]));                    ]));
680                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));
681                    clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));
682                  clppDecl (genStrandTyDef(#gpuTy, strand));                  clppDecl (genStrandTyDef(#gpuTy, strand));
683                  clppDecl  (!init_code);                  clppDecl  (!init_code);
                 clppDecl  (genStrandCopy(strand));  
684                  List.app clppDecl (!code);                  List.app clppDecl (!code);
685                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));
686                (* Generate the Host C file *)                (* Generate the Host C file *)
# Line 706  Line 700 
700                  cppDecl (genStrandTyDef (#hostTy, strand));                  cppDecl (genStrandTyDef (#hostTy, strand));
701                  cppDecl (genStrandPrint strand);                  cppDecl (genStrandPrint strand);
702                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
703                  cppDecl (genGlobalBuffersArgs imgGlobals);                  cppDecl (genGlobalBuffersArgs (!globals,imgGlobals));
704                  List.app (fn strand => cppDecl (genStrandDesc strand)) strands;                  List.app (fn strand => cppDecl (genStrandDesc strand)) strands;
705                  genStrandTable (cppDecl, strands);                  genStrandTable (cppDecl, strands);
706                  cppDecl (!initially);                  cppDecl (!initially);
# Line 785  Line 779 
779                val params = [                val params = [
780                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),
781                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),
782                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName)                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName),
783                          CL.PARAM([],CL.T_Named(RN.imageDataType),RN.globalImageDataName)
784                      ]                      ]
785                val methFn = CL.D_Func([], CL.int32, fName, params, body)                val methFn = CL.D_Func([], CL.int32, fName, params, body)
786                in                in

Legend:
Removed from v.1382  
changed lines
  Added in v.1406

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