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 1307, Sat Jun 11 13:58:02 2011 UTC revision 1314, Sat Jun 11 17:02:26 2011 UTC
# Line 64  Line 64 
64      type stm = CL.stm      type stm = CL.stm
65    
66    (* OpenCL specific types *)    (* OpenCL specific types *)
67        val clIntTy = CL.T_Named "cl_int"
68      val clProgramTy = CL.T_Named "cl_program"      val clProgramTy = CL.T_Named "cl_program"
69      val clKernelTy  = CL.T_Named "cl_kernel"      val clKernelTy  = CL.T_Named "cl_kernel"
70      val clCmdQueueTy = CL.T_Named "cl_command_queue"      val clCmdQueueTy = CL.T_Named "cl_command_queue"
# Line 71  Line 72 
72      val clDeviceIdTy = CL.T_Named "cl_device_id"      val clDeviceIdTy = CL.T_Named "cl_device_id"
73      val clPlatformIdTy = CL.T_Named "cl_platform_id"      val clPlatformIdTy = CL.T_Named "cl_platform_id"
74      val clMemoryTy = CL.T_Named "cl_mem"      val clMemoryTy = CL.T_Named "cl_mem"
75        val globPtrTy = CL.T_Ptr(CL.T_Named RN.globalsTy)
76    
77    (* variable or field that is mirrored between host and GPU *)    (* variable or field that is mirrored between host and GPU *)
78      type mirror_var = {      type mirror_var = {
# Line 130  Line 132 
132    (* TreeIL to target translations *)    (* TreeIL to target translations *)
133      structure Tr =      structure Tr =
134        struct        struct
       (* this function is used for the initially clause, so it generates OpenCL *)  
135          fun fragment (ENV{info, vMap, scope}, blk) = let          fun fragment (ENV{info, vMap, scope}, blk) = let
136                val (vMap, stms) = ToCL.trFragment (vMap, blk)                val (vMap, stms) = (case scope
137                         of GlobalScope => ToC.trFragment (vMap, blk)
138                          | _ => ToCL.trFragment (vMap, blk)
139                        (* end case *))
140                in                in
141                  (ENV{info=info, vMap=vMap, scope=scope}, stms)                  (ENV{info=info, vMap=vMap, scope=scope}, stms)
142                end                end
# Line 145  Line 149 
149                  print(concat["saveState ", cxt, ": length mismatch; ", Int.toString(List.length args), " args\n"]);                  print(concat["saveState ", cxt, ": length mismatch; ", Int.toString(List.length args), " args\n"]);
150                  raise Fail(concat["saveState ", cxt, ": length mismatch"]))                  raise Fail(concat["saveState ", cxt, ": length mismatch"]))
151          fun block (ENV{vMap, scope, ...}, blk) = (case scope          fun block (ENV{vMap, scope, ...}, blk) = (case scope
152                 of StrandScope stateVars => ToCL.trBlock (vMap, saveState "StrandScope" stateVars, blk)  (* NOTE: if we move strand initialization to the GPU, then we'll have to change the following line! *)
153                   of StrandScope stateVars => ToC.trBlock (vMap, saveState "StrandScope" stateVars, blk)
154                  | MethodScope stateVars => ToCL.trBlock (vMap, saveState "MethodScope" stateVars, blk)                  | MethodScope stateVars => ToCL.trBlock (vMap, saveState "MethodScope" stateVars, blk)
155                  | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)                  | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)
156                  | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)                  | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)
# Line 218  Line 223 
223                    prFn = ref(CL.D_Comment(["No Print Function"]))                    prFn = ref(CL.D_Comment(["No Print Function"]))
224                  })                  })
225        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
226    (* FIXME: unused code; can this be removed??
227            fun globalIndirects (globals,stms) = let            fun globalIndirects (globals,stms) = let
228                  fun getGlobals ({name,target as TargetUtil.TARGET_CL}::rest) =                  fun getGlobals ({name,target as TargetUtil.TARGET_CL}::rest) =
229                        CL.mkAssign(CL.mkIndirect(CL.mkVar RN.globalsVarName,name),CL.mkVar name)                        CL.mkAssign(CL.mkIndirect(CL.mkVar RN.globalsVarName,name),CL.mkVar name)
# Line 227  Line 233 
233                  in                  in
234                    stms @ getGlobals globals                    stms @ getGlobals globals
235                  end                  end
236    *)
237        (* register the code that is used to register command-line options for input variables *)        (* register the code that is used to register command-line options for input variables *)
238          fun inputs (Prog{topDecls, ...}, stm) = let          fun inputs (Prog{topDecls, ...}, stm) = let
239                val inputsFn = CL.D_Func(                val inputsFn = CL.D_Func(
# Line 240  Line 246 
246    
247        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
248          fun init (Prog{topDecls, ...}, init) = let          fun init (Prog{topDecls, ...}, init) = let
               val globPtrTy = CL.T_Ptr(CL.T_Named RN.globalsTy)  
249                val initFn = CL.D_Func(                val initFn = CL.D_Func(
250                      [], CL.voidTy, RN.initGlobals, [CL.PARAM([], globPtrTy, RN.globalsVarName)],                      [], CL.voidTy, RN.initGlobals, [CL.PARAM([], globPtrTy, RN.globalsVarName)],
251                      init)                      init)
# Line 372  Line 377 
377                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),
378                  tyName)                  tyName)
379    
   
380          (* generates the load kernel function *)          (* generates the load kernel function *)
381    
382        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
# Line 386  Line 390 
390                          CL.mkVar RN.globalsVarName,                          CL.mkVar RN.globalsVarName,
391                          CL.mkUnOp(CL.%&,CL.mkVar errVar)                          CL.mkUnOp(CL.%&,CL.mkVar errVar)
392                        ]))                        ]))
   
393          fun genDataBuffers([],_,_) = []          fun genDataBuffers([],_,_) = []
394            | genDataBuffers((var,nDims)::globals,contextVar,errVar) = let            | genDataBuffers((var,nDims)::globals,contextVar,errVar) = let
395  (* FIXME: use CL constructors to  build expressions (not strings) *)  (* FIXME: use CL constructors to  build expressions (not strings) *)
396                val size = if nDims = 1                val size = if nDims = 1
397                      then CL.mkBinOp(CL.mkApply("sizeof",[CL.mkVar "float"]), CL.#*,                      then CL.mkBinOp(CL.mkApply("sizeof",[CL.mkVar "float"]), CL.#*,
398                                           CL.mkIndirect(CL.mkVar var, "size[0]"))                                           CL.mkIndirect(CL.mkVar var, "size[0]"))
399                                          else if nDims = 2 then                            else if nDims = 2
400                                          CL.mkBinOp(CL.mkApply("sizeof",[CL.mkVar "float"]), CL.#*,                              then CL.mkBinOp(CL.mkApply("sizeof",[CL.mkVar "float"]), CL.#*,
401                                            CL.mkIndirect(CL.mkVar var, concat["size[0]", " * ", var, "->size[1]"]))                                            CL.mkIndirect(CL.mkVar var, concat["size[0]", " * ", var, "->size[1]"]))
402                                          else                              else CL.mkBinOp(CL.mkApply("sizeof",[CL.mkVar "float"]), CL.#*,
                                          CL.mkBinOp(CL.mkApply("sizeof",[CL.mkVar "float"]), CL.#*,  
403                                            CL.mkIndirect(CL.mkVar var,concat["size[0]", " * ", var, "->size[1] * ", var, "->size[2]"]))                                            CL.mkIndirect(CL.mkVar var,concat["size[0]", " * ", var, "->size[1] * ", var, "->size[2]"]))
   
404                   in                   in
405                     CL.mkDecl(clMemoryTy, RN.addBufferSuffix var ,NONE)::                     CL.mkDecl(clMemoryTy, RN.addBufferSuffix var ,NONE)::
406                     CL.mkDecl(clMemoryTy, RN.addBufferSuffixData var ,NONE)::                     CL.mkDecl(clMemoryTy, RN.addBufferSuffixData var ,NONE)::
# Line 417  Line 418 
418                                                                  CL.mkUnOp(CL.%&,CL.mkVar errVar)])):: genDataBuffers(globals,contextVar,errVar)                                                                  CL.mkUnOp(CL.%&,CL.mkVar errVar)])):: genDataBuffers(globals,contextVar,errVar)
419                  end                  end
420                in                in
421                  [globalBufferDecl] @ [globalBuffer] @ genDataBuffers(globals,contextVar,errVar)                  globalBufferDecl :: globalBuffer :: genDataBuffers(globals,contextVar,errVar)
422                end                end
423    
   
424  (* generates the kernel arguments for the image data *)  (* generates the kernel arguments for the image data *)
425          fun genGlobalArguments(globals,count,kernelVar,errVar) = let          fun genGlobalArguments(globals,count,kernelVar,errVar) = let
426          val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,CL.mkApply("clSetKernelArg",                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,
427                        CL.mkApply("clSetKernelArg",
428                                                                  [CL.mkVar kernelVar,                                                                  [CL.mkVar kernelVar,
429                                                                   CL.mkPostOp(CL.E_Var count, CL.^++),                                                                   CL.mkPostOp(CL.E_Var count, CL.^++),
430                                                                   CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                                                                   CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
431                                                                   CL.mkUnOp(CL.%&,CL.mkVar(concat[RN.globalsVarName,"_cl"]))])))                                                                   CL.mkUnOp(CL.%&,CL.mkVar(concat[RN.globalsVarName,"_cl"]))])))
   
432          fun genDataArguments([],_,_,_) = []          fun genDataArguments([],_,_,_) = []
433            | genDataArguments((var,nDims)::globals,count,kernelVar,errVar) =            | genDataArguments((var,nDims)::globals,count,kernelVar,errVar) =
434                        CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,
435                  CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=, CL.mkApply("clSetKernelArg",                        CL.mkApply("clSetKernelArg",
436                                  [CL.mkVar kernelVar,                                  [CL.mkVar kernelVar,
437                                   CL.mkPostOp(CL.E_Var count, CL.^++),                                   CL.mkPostOp(CL.E_Var count, CL.^++),
438                                   CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                                   CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
439                                   CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffix var))])))::                                   CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffix var))])))::
440                        CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,
441                          CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,CL.mkApply("clSetKernelArg",                        CL.mkApply("clSetKernelArg",
442                                  [CL.mkVar kernelVar,                                  [CL.mkVar kernelVar,
443                                   CL.mkPostOp(CL.E_Var count, CL.^++),                                   CL.mkPostOp(CL.E_Var count, CL.^++),
444                                   CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                                   CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
445                                   CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))):: genDataArguments (globals,count,kernelVar,errVar)                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::
446                        genDataArguments (globals,count,kernelVar,errVar)
447          in          in
448                    globalArgument :: genDataArguments(globals, count, kernelVar, errVar)
                 [globalArgument] @ genDataArguments(globals,count,kernelVar,errVar)  
   
449          end          end
450    
451        (* generates the globals buffers and arguments function *)        (* generates the globals buffers and arguments function *)
# Line 460  Line 458 
458                        CL.PARAM([],CL.T_Named("cl_kernel"), "kernel"),                        CL.PARAM([],CL.T_Named("cl_kernel"), "kernel"),
459                        CL.PARAM([],CL.T_Named("int"), "argStart")                        CL.PARAM([],CL.T_Named("int"), "argStart")
460                      ]                      ]
461                val clGlobalBuffers = getGlobalDataBuffers(!imgGlobals, "context", "err")                val clGlobalBuffers = getGlobalDataBuffers(!imgGlobals, "context", errVar)
462                val clGlobalArguments = genGlobalArguments(!imgGlobals, "argStart", "kernel", "err")                val clGlobalArguments = genGlobalArguments(!imgGlobals, "argStart", "kernel", errVar)
463              (* Body put all the statments together *)              (* Body put all the statments together *)
464                val body =  clGlobalBuffers @ clGlobalArguments                val body = CL.mkDecl(clIntTy, errVar, SOME(CL.I_Exp(CL.mkInt 0)))
465                        :: clGlobalBuffers @ clGlobalArguments
466                in                in
467    (* FIXME: we ought to check the error condition! *)
468                  CL.D_Func([],CL.voidTy,RN.globalsSetupName,params,CL.mkBlock(body))                  CL.D_Func([],CL.voidTy,RN.globalsSetupName,params,CL.mkBlock(body))
469                end                end
470    
# Line 505  Line 505 
505                      ] @ genKeneralGlobalParams(!imgGlobals)                      ] @ genKeneralGlobalParams(!imgGlobals)
506                val thread_ids = if nDims = 1                val thread_ids = if nDims = 1
507                      then [                      then [
508                          CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.mkInt(0, CL.intTy)))),                          CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.mkInt 0))),
509                          CL.mkAssign(CL.mkVar "x",CL.mkApply(RN.getGlobalThreadId,[CL.mkInt(0,CL.intTy)]))                          CL.mkAssign(CL.mkVar "x",CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0]))
510                        ]                        ]
511                      else [                      else [
512                          CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.mkInt(0, CL.intTy)))),                          CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.mkInt 0))),
513                          CL.mkDecl(CL.intTy, "y", SOME(CL.I_Exp(CL.mkInt(0, CL.intTy)))),                          CL.mkDecl(CL.intTy, "y", SOME(CL.I_Exp(CL.mkInt 0))),
514                          CL.mkAssign(CL.mkVar "x",  CL.mkApply(RN.getGlobalThreadId,[CL.mkInt(0,CL.intTy)])),                          CL.mkAssign(CL.mkVar "x",  CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])),
515                          CL.mkAssign(CL.mkVar "y",CL.mkApply(RN.getGlobalThreadId,[CL.mkInt(1,CL.intTy)]))                          CL.mkAssign(CL.mkVar "y",CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1]))
516                        ]                        ]
517                val strandDecl = [                val strandDecl = [
518                      CL.mkDecl(CL.T_Named tyName, inState, NONE),                      CL.mkDecl(CL.T_Named tyName, inState, NONE),
# Line 524  Line 524 
524                            ]                            ]
525                          else let                          else let
526                                  val index = CL.mkBinOp(CL.mkBinOp(CL.mkVar "x",CL.#*,CL.mkVar "width"),CL.#+,CL.mkVar "y")                                  val index = CL.mkBinOp(CL.mkBinOp(CL.mkVar "x",CL.#*,CL.mkVar "width"),CL.#+,CL.mkVar "y")
527                                  in                        in [
528                                          [CL.mkAssign(CL.mkVar inState, CL.mkSubscript(CL.mkVar "selfIn",index)),                          CL.mkAssign(CL.mkVar inState, CL.mkSubscript(CL.mkVar "selfIn",index)),
529                                           CL.mkAssign(CL.mkVar outState,CL.mkSubscript(CL.mkVar "selfOut",index))]                          CL.mkAssign(CL.mkVar outState,CL.mkSubscript(CL.mkVar "selfOut",index))
530                                  end                        ] end
531                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkInt(0, CL.intTy))))                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkInt 0)))
532                val local_vars =  thread_ids @ initKernelGlobals(!globals,!imgGlobals)  @ strandDecl @ strandObjects @ [status]                val local_vars =  thread_ids @ initKernelGlobals(!globals,!imgGlobals)  @ strandDecl @ strandObjects @ [status]
533                val while_exp = CL.mkBinOp(CL.mkBinOp(CL.mkVar "status",CL.#!=, CL.mkVar RN.kStabilize),CL.#||,CL.mkBinOp(CL.mkVar "status", CL.#!=, CL.mkVar RN.kDie))                val while_exp = CL.mkBinOp(
534                        CL.mkBinOp(CL.mkVar "status",CL.#!=, CL.mkVar RN.kStabilize),
535                        CL.#||,
536                        CL.mkBinOp(CL.mkVar "status", CL.#!=, CL.mkVar RN.kDie))
537                val whileBody = CL.mkBlock [                val whileBody = CL.mkBlock [
538                        CL.mkAssign(CL.mkVar "status",                        CL.mkAssign(CL.mkVar "status",
539                          CL.mkApply(RN.strandUpdate name,                          CL.mkApply(RN.strandUpdate name,
# Line 555  Line 558 
558                  List.app doVar globals                  List.app doVar globals
559                end                end
560    
561          fun genSrc (baseName, Prog{double,globals, topDecls, strands, initially,imgGlobals,numDims,...}) = let          fun genSrc (baseName, prog) = let
562                  val Prog{double, globals, topDecls, strands, initially, imgGlobals, numDims, ...} = prog
563                val clFileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "cl"}                val clFileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "cl"}
564                val cFileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}                val cFileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}
565                val clOutS = TextIO.openOut clFileName                val clOutS = TextIO.openOut clFileName
566                val cOutS = TextIO.openOut cFileName                val cOutS = TextIO.openOut cFileName
 (* FIXME: need to use PrintAsC and PrintAsCL *)  
567                val clppStrm = PrintAsCL.new clOutS                val clppStrm = PrintAsCL.new clOutS
568                val cppStrm = PrintAsC.new cOutS                val cppStrm = PrintAsC.new cOutS
569                fun cppDecl dcl = PrintAsC.output(cppStrm, dcl)                fun cppDecl dcl = PrintAsC.output(cppStrm, dcl)
# Line 581  Line 584 
584                  clppDecl (genStrandTyDef(#gpuTy, strand));                  clppDecl (genStrandTyDef(#gpuTy, strand));
585                  List.app clppDecl (!code);                  List.app clppDecl (!code);
586                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));
   
587                (* Generate the Host C file *)                (* Generate the Host C file *)
588                  cppDecl (CL.D_Verbatim([                  cppDecl (CL.D_Verbatim([
589                      if double                      if double
# Line 592  Line 594 
594                    ]));                    ]));
595                  genGlobals (cppDecl, #hostTy, !globals);                  genGlobals (cppDecl, #hostTy, !globals);
596                  cppDecl (genGlobalStruct (#hostTy, !globals));                  cppDecl (genGlobalStruct (#hostTy, !globals));
597                  cppDecl (genStrandTyDef (#gpuTy, strand));                  cppDecl (genStrandTyDef (#hostTy, strand));
598                  cppDecl  (!init_code);                  cppDecl  (!init_code);
599                  cppDecl (genStrandPrint strand);                  cppDecl (genStrandPrint strand);
600                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
# Line 661  Line 663 
663          fun init (Strand{name, tyName, code,init_code, ...}, params, init) = let          fun init (Strand{name, tyName, code,init_code, ...}, params, init) = let
664                val fName = RN.strandInit name                val fName = RN.strandInit name
665                val params =                val params =
666                        CL.PARAM([], globPtrTy, RN.globalsVarName) ::
667                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
668                        List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params                        List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params
669                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)

Legend:
Removed from v.1307  
changed lines
  Added in v.1314

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