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 1261, Sat May 28 23:16:30 2011 UTC revision 1264, Thu Jun 2 06:08:07 2011 UTC
# Line 36  Line 36 
36          initially : CL.stm list ref,          initially : CL.stm list ref,
37          numDims: int ref,          numDims: int ref,
38          imgGlobals: (string * int) list ref,          imgGlobals: (string * int) list ref,
39          oneDim: CL.exp ref,                  prFn: CL.decl ref
         twoDim: CL.exp ref,  
         thirdDim: CL.exp ref  
40      }      }
41    
42      datatype env = ENV of {      datatype env = ENV of {
# Line 159  Line 157 
157                    initially = ref([CL.S_Comment["missing initially"]]),                    initially = ref([CL.S_Comment["missing initially"]]),
158                    numDims = ref(0),                    numDims = ref(0),
159                    imgGlobals = ref[],                    imgGlobals = ref[],
160                    oneDim = ref(CL.E_Str "did not initalize dim"),                                    prFn = ref(CL.D_Comment(["No Print Function"]))
                   twoDim = ref(CL.E_Str "did not initalize dim"),  
                   thirdDim = ref(CL.E_Str "did not initalize dim")  
161                  })                  })
162        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
163          fun globalIndirects (globals,stms) = let          fun globalIndirects (globals,stms) = let
# Line 202  Line 198 
198    
199        (* create and register the initially function for a program *)        (* create and register the initially function for a program *)
200          fun initially {          fun initially {
201                prog = Prog{strands, initially,numDims,oneDim,twoDim,thirdDim,...},                prog = Prog{strands, initially,numDims,...},
202                isArray : bool,                isArray : bool,
203                iterPrefix : stm list,                iterPrefix : stm list,
204                iters : (var * exp * exp) list,                iters : (var * exp * exp) list,
# Line 231  Line 227 
227                        CL.mkDecl(CL.int32,"numDims",SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nDims, CL.int32))))                        CL.mkDecl(CL.int32,"numDims",SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nDims, CL.int32))))
228                            ]                            ]
229    
             fun mkLoopNest ([],_,_,_,_) = ()  
           | mkLoopNest ((ToC.V(ty, param), lo, hi)::iters, oneDim,twoDim,thirdDim, 3) =  
                                 (oneDim := hi; mkLoopNest (iters,oneDim,twoDim,thirdDim, 2))  
           | mkLoopNest ((ToC.V(ty, param), lo, hi)::iters, oneDim,twoDim,thirdDim, 2) =  
                                 (twoDim := hi; mkLoopNest (iters,oneDim,twoDim,thirdDim, 1))  
           | mkLoopNest ((ToC.V(ty, param), lo, hi)::iters, oneDim,twoDim,thirdDim, 1) =  
                                  (thirdDim := hi; mkLoopNest (iters,oneDim,twoDim,thirdDim, 0))  
           | mkLoopNest ((ToC.V(ty, param), lo, hi)::iters,_,_,_,_) = ()  
   
   
   
230                    val numStrandsLoopBody = CL.mkExpStm(CL.mkAssignOp(CL.E_Var numStrandsVar, CL.*=,CL.mkSubscript(CL.E_Var "size",CL.E_Var "i")))                    val numStrandsLoopBody = CL.mkExpStm(CL.mkAssignOp(CL.E_Var numStrandsVar, CL.*=,CL.mkSubscript(CL.E_Var "size",CL.E_Var "i")))
231    
232    
# Line 250  Line 235 
235                                                                                     [CL.mkPostOp(CL.E_Var "i", CL.^++)], numStrandsLoopBody)                                                                                     [CL.mkPostOp(CL.E_Var "i", CL.^++)], numStrandsLoopBody)
236                in                in
237                    numDims := nDims;                    numDims := nDims;
238                    initially := allocCode @ [numStrandsLoop];                                  initially := allocCode @ [numStrandsLoop]
                   mkLoopNest (iters,oneDim, twoDim, thirdDim, nDims)  
239    
240                end                end
241    
242    
243        (***** OUTPUT *****)        (***** OUTPUT *****)
244      fun genStrand (Strand{name, tyName, state, output, code}) = let          fun genStrandPrint (Strand{name, tyName, state, output, code},nDims) = let
245              (* the print function *)              (* the print function *)
246                val prFnName = concat[name, "_print"]                val prFnName = concat[name, "_print"]
247    
248                val prFn = let                val prFn = let
249                      val params = [                      val params = [
250                            CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                            CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
251                              CL.PARAM([], CL.T_Ptr(CL.intTy), "sizes" ),
252                              CL.PARAM([], CL.intTy, "width"),
253                            CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")                            CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")
254                          ]                          ]
255    
256                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
257                      val outState = CL.mkIndirect(CL.mkVar "self", x)                     val outState = if nDims = 1 then
258                              CL.mkSelect(CL.mkSubscript(CL.mkVar "self",CL.E_Var "x"), x)
259                            else if nDims = 2 then
260                                    CL.mkSelect(CL.mkSubscript(CL.mkVar "self",
261                                       CL.mkBinOp(CL.mkBinOp(CL.E_Var "x",CL.#*,CL.E_Var "width"),CL.#+,CL.E_Var "y")), x)
262    
263                            else CL.mkSelect(CL.mkVar "self",x)
264    
265                      val prArgs = (case ty                      val prArgs = (case ty
266                             of Ty.IVecTy 1 => [CL.E_Str(!RN.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.E_Str(!RN.gIntFormat ^ "\n"), outState]
267                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
# Line 287  Line 283 
283                                  end                                  end
284                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)
285                            (* end case *))                            (* end case *))
286    
287                              val body = let
288    
289                                fun loopParams (3) =
290                                     "x"::"y"::"k"::[]
291                                  | loopParams (2) =
292                                     "x"::"y"::[]
293                                  | loopParams (1) =
294                                     "x"::[]
295                                  | loopParams (_) =
296                                    raise Fail("genStrandPrint: unsupported output type " ^ Ty.toString ty)
297    
298                               fun mkLoopNest ([],_) =
299                                                    CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs)
300                                    | mkLoopNest (param::rest,count) = let
301                                            val body = mkLoopNest (rest, count + 1)
302                                       in
303                                                    CL.mkFor(
304                                                            [(CL.intTy, param, CL.E_Int(0,CL.intTy))],
305                                                    CL.mkBinOp(CL.E_Var param, CL.#<=, CL.mkSubscript(CL.E_Var "sizes",CL.E_Int(count,CL.intTy))),
306                                                    [CL.mkPostOp(CL.E_Var param, CL.^++)],
307                                                    body)
308                                       end
309                            in
310                                    [mkLoopNest ((loopParams nDims),0)]
311                            end
312    
313                      in                      in
314                        CL.D_Func(["static"], CL.voidTy, prFnName, params,                        CL.D_Func(["static"], CL.voidTy, prFnName, params,CL.mkBlock(body))
                         CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs))  
315                      end                      end
316                in                in
317                                   List.rev (prFn :: !code)                                   prFn
318                end                end
319          fun genStrandTyDef (Strand{tyName, state,...}) =          fun genStrandTyDef (Strand{tyName, state,...}) =
320              (* the type declaration for the strand's state struct *)              (* the type declaration for the strand's state struct *)
# Line 359  Line 381 
381                  end                  end
382          in          in
383                  [globalBufferDecl] @ [globalBuffer] @ genDataBuffers(globals,count + 2,contextVar,errVar)                  [globalBufferDecl] @ [globalBuffer] @ genDataBuffers(globals,count + 2,contextVar,errVar)
   
384          end          end
385    
386    
387          (* generates the kernel arguments for the image data *)          (* generates the kernel arguments for the image data *)
388          fun genGlobalArguments(globals,count,kernelVar,errVar) = let          fun genGlobalArguments(globals,count,kernelVar,errVar) = let
389          val globalArgument = CL.mkAssign(CL.E_Var errVar,CL.mkApply("clSetKernelArg",          val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.E_Var errVar,CL.|=,CL.mkApply("clSetKernelArg",
390                                                                  [CL.E_Var kernelVar,                                                                  [CL.E_Var kernelVar,
391                                                                   CL.E_Int(count,CL.intTy),                                                                   CL.E_Int(count,CL.intTy),
392                                                                   CL.mkApply("sizeof",[CL.E_Var "cl_mem"]),                                                                   CL.mkApply("sizeof",[CL.E_Var "cl_mem"]),
393                                                                   CL.E_UnOp(CL.%&,CL.E_Var(concat[RN.globalsVarName,"_cl"]))]))                                                                   CL.E_UnOp(CL.%&,CL.E_Var(concat[RN.globalsVarName,"_cl"]))])))
394    
395          fun genDataArguments([],_,_,_) = []          fun genDataArguments([],_,_,_) = []
396            | genDataArguments((var,nDims)::globals,count,kernelVar,errVar) =            | genDataArguments((var,nDims)::globals,count,kernelVar,errVar) =
397    
398                  CL.mkAssign(CL.E_Var errVar,CL.mkApply("clSetKernelArg",                  CL.mkExpStm(CL.mkAssignOp(CL.E_Var errVar,CL.|=, CL.mkApply("clSetKernelArg",
399                                                                  [CL.E_Var kernelVar,                                                                  [CL.E_Var kernelVar,
400                                                                   CL.E_Int(count,CL.intTy),                                                                   CL.E_Int(count,CL.intTy),
401                                                                   CL.mkApply("sizeof",[CL.E_Var "cl_mem"]),                                                                   CL.mkApply("sizeof",[CL.E_Var "cl_mem"]),
402                                                                   CL.E_UnOp(CL.%&,CL.E_Var(concat[var,"_cl"]))]))::                                                                   CL.E_UnOp(CL.%&,CL.E_Var(RN.addBufferSuffix var))])))::
403    
404                          CL.mkAssign(CL.E_Var errVar,CL.mkApply("clSetKernelArg",                          CL.mkExpStm(CL.mkAssignOp(CL.E_Var errVar,CL.|=,CL.mkApply("clSetKernelArg",
405                                                                  [CL.E_Var kernelVar,                                                                  [CL.E_Var kernelVar,
406                                                                   CL.E_Int((count + 1),CL.intTy),                                                                   CL.E_Int((count + 1),CL.intTy),
407                                                                   CL.mkApply("sizeof",[CL.E_Var "cl_mem"]),                                                                   CL.mkApply("sizeof",[CL.E_Var "cl_mem"]),
408                                                                   CL.E_UnOp(CL.%&,CL.E_Var(concat[var,"_cl", IntegerLit.toString (count + 1)]))])):: genDataArguments (globals, count + 2,kernelVar,errVar)                                                                   CL.E_UnOp(CL.%&,CL.E_Var(RN.addBufferSuffixData var))]))):: genDataArguments (globals, count + 2,kernelVar,errVar)
409    
410          in          in
411    
412                  [globalArgument] @ genDataArguments(globals,count + 1,kernelVar,errVar)                  [globalArgument] @ genDataArguments(globals,count + 1,kernelVar,errVar)
413    
414          end          end
415    
416          (* generates the main function of host code *)          (* generates the main function of host code *)
417          fun genHostMain() = let          fun genHostMain() = let
418                  val setupCall = [CL.mkCall(RN.setupFName,[CL.E_Var RN.globalsVarName])]                  val setupCall = [CL.mkCall(RN.setupFName,[CL.E_Var RN.globalsVarName])]
# Line 405  Line 428 
428                  in                  in
429                    CL.D_Func([],CL.intTy,"main",params,body)                    CL.D_Func([],CL.intTy,"main",params,body)
430                  end                  end
431    
432          (* generates the host-side setup function *)          (* generates the host-side setup function *)
433          fun genHostSetupFunc(strand as Strand{name,tyName,...}, filename, nDims, initially, imgGlobals, oneDim, twoDim, thirdDim) = let          fun genHostSetupFunc(strand as Strand{name,tyName,...}, filename, nDims, initially, imgGlobals) = let
434                (* Declare opencl setup objects *)                  (*Delcare opencl setup objects *)
435                  val programVar= "program"                  val programVar= "program"
436                  val kernelVar = "kernel"                  val kernelVar = "kernel"
437                  val cmdVar = "queue"                  val cmdVar = "queue"
# Line 434  Line 458 
458                  val params = [                  val params = [
459                           CL.PARAM([],CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName)                           CL.PARAM([],CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName)
460                           ]                           ]
461                  val declarations = [CL.mkDecl(CL.clProgramTy, programVar, NONE),                  val delcarations = [CL.mkDecl(CL.clProgramTy, programVar, NONE),
462                            CL.mkDecl(CL.clKernelTy, kernelVar, NONE),                            CL.mkDecl(CL.clKernelTy, kernelVar, NONE),
463                            CL.mkDecl(CL.clCmdQueueTy, cmdVar, NONE),                            CL.mkDecl(CL.clCmdQueueTy, cmdVar, NONE),
464                            CL.mkDecl(CL.clContextTy, contextVar, NONE),                            CL.mkDecl(CL.clContextTy, contextVar, NONE),
465                            CL.mkDecl(CL.intTy, errVar, NONE),                            CL.mkDecl(CL.intTy, errVar, NONE),
466                            CL.mkDecl(CL.intTy, numStrandsVar, NONE),                            CL.mkDecl(CL.intTy, numStrandsVar, NONE),
                           CL.mkDecl(CL.intTy, numPlatformsVar, NONE),  
467                            CL.mkDecl(CL.intTy, stateSizeVar, NONE),                            CL.mkDecl(CL.intTy, stateSizeVar, NONE),
468                              CL.mkDecl(CL.intTy, "width", NONE),
469                            CL.mkDecl(CL.intTy, imgDataSizeVar, NONE),                            CL.mkDecl(CL.intTy, imgDataSizeVar, NONE),
470                            CL.mkDecl(CL.clDeviceIdTy, deviceVar, NONE),                            CL.mkDecl(CL.clDeviceIdTy, deviceVar, NONE),
471                            CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), inStateVar,NONE),                            CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), inStateVar,NONE),
# Line 454  Line 478 
478                            CL.mkDecl(CL.T_Array(CL.T_Named "size_t",SOME(nDims)),globalVar,NONE),                            CL.mkDecl(CL.T_Array(CL.T_Named "size_t",SOME(nDims)),globalVar,NONE),
479                            CL.mkDecl(CL.T_Array(CL.T_Named "size_t",SOME(nDims)),localVar,NONE),                            CL.mkDecl(CL.T_Array(CL.T_Named "size_t",SOME(nDims)),localVar,NONE),
480                            CL.mkDecl(CL.intTy,numDevicesVar,SOME(CL.I_Exp(CL.E_Int(~1,CL.intTy)))),                            CL.mkDecl(CL.intTy,numDevicesVar,SOME(CL.I_Exp(CL.E_Int(~1,CL.intTy)))),
481                            CL.mkDecl(CL.T_Array(CL.clDeviceIdTy, SOME(1)), platformsVar, NONE),                            CL.mkDecl(CL.T_Array(CL.T_Named "cl_platform_id", SOME(1)), platformsVar, NONE),
482                            CL.mkDecl(CL.intTy,"num_platforms",SOME(CL.I_Exp(CL.E_Int(~1,CL.intTy))))]                            CL.mkDecl(CL.intTy,"num_platforms",SOME(CL.I_Exp(CL.E_Int(~1,CL.intTy))))]
483    
484                  (* Retrieve the platforms *)                  (* Retrieve the platforms *)
485                  val platformStm = [CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetPlatformIDs",                  val platformStm = [CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetPlatformIDs",
486                                                    [CL.E_Int(10,CL.intTy),                                                    [CL.E_Int(10,CL.intTy),
487                                                     CL.E_UnOp(CL.%&,CL.E_Var platformsVar),                                                     CL.E_Var platformsVar,
488                                                     CL.E_UnOp(CL.%&,CL.E_Var numDevicesVar)])),                                                     CL.E_UnOp(CL.%&,CL.E_Var numPlatformsVar)])),
489                                                     assertStm]                                                     assertStm]
490    
491                  val devicesStm = [CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetDeviceIDs",                  val devicesStm = [CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetDeviceIDs",
# Line 490  Line 514 
514                                                    CL.E_UnOp(CL.%&,CL.E_Var errVar)])),                                                    CL.E_UnOp(CL.%&,CL.E_Var errVar)])),
515                                                    assertStm]                                                    assertStm]
516    
517    
518                    (*Create Program/Build/Kernel with Source statement *)
519                    val createProgStm = CL.mkAssign(CL.E_Var programVar, CL.mkApply("clCreateProgramWithSource",
520                                                                                                                    [CL.E_Var contextVar,
521                                                                                                                     CL.E_Int(2,CL.intTy),
522                                                                                                                     CL.E_Cast(CL.T_Ptr(CL.T_Named("const char *")),CL.E_UnOp(CL.%&,CL.E_Var sourcesVar)),
523                                                                                                                     CL.E_Var "NULL",
524                                                                                                                     CL.E_UnOp(CL.%&,CL.E_Var errVar)]))
525    
526                    (* FIXME: Remove after testing purposes, Build Log for OpenCL*)
527                    val buildLog = [CL.mkAssign(CL.E_Var errVar, CL.mkApply("clBuildProgram",
528                                                                                                                    [CL.E_Var programVar,
529                                                                                                                     CL.E_Int(0,CL.intTy),
530                                                                                                                     CL.E_Var "NULL",
531                                                                                                                     CL.E_Var "NULL",
532                                                                                                                     CL.E_Var "NULL",
533                                                                                                                     CL.E_Var "NULL"])),
534                                              CL.mkDecl(CL.T_Array(CL.charTy,SOME(2048)), "build", NONE),
535                                               CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetProgramBuildInfo",
536                                                                                                                    [CL.E_Var programVar,
537                                                                                                                    CL.E_Var deviceVar,
538                                                                                                                     CL.E_Var "CL_PROGRAM_BUILD_LOG",
539                                                                                                                     CL.E_Int (2048,CL.intTy),
540                                                                                                                     CL.E_Var "build",
541                                                                                                                     CL.E_Var "NULL"])),
542                                                    CL.mkCall("printf",[CL.E_Str ( "Build Log:" ^ "\n" ^ "%s" ^ "\n"), CL.E_Var "build"])]
543    
544    
545    
546    
547                    val createKernel = CL.mkAssign(CL.E_Var kernelVar, CL.mkApply("clCreateKernel",
548                                                                                                                    [CL.E_Var programVar,
549                                                                                                                     CL.E_Str RN.kernelFuncName,
550                                                                                                                     CL.E_UnOp(CL.%&,CL.E_Var errVar)]))
551    
552    
553                    val create_build_stms = [createProgStm,assertStm] @ buildLog @ [assertStm,createKernel,assertStm]
554    
555    
556    
557                  (* Create Memory Buffers for Strand States and Globals *)                  (* Create Memory Buffers for Strand States and Globals *)
558                  val strandSize = CL.mkAssign(CL.E_Var stateSizeVar,CL.mkBinOp(CL.mkApply("sizeof",                  val strandSize = CL.mkAssign(CL.E_Var stateSizeVar,CL.mkBinOp(CL.mkApply("sizeof",
559                                                                          [CL.E_Var tyName]), CL.#*,CL.E_Var numStrandsVar))                                                                          [CL.E_Var tyName]), CL.#*,CL.E_Var numStrandsVar))
# Line 562  Line 626 
626              (* Setup up selfOut variable *)              (* Setup up selfOut variable *)
627                val selfOutStm = CL.mkAssign(CL.E_Var outStateVar, CL.mkApply("malloc", [CL.mkBinOp(CL.E_Var numStrandsVar,                val selfOutStm = CL.mkAssign(CL.E_Var outStateVar, CL.mkApply("malloc", [CL.mkBinOp(CL.E_Var numStrandsVar,
628                                                                          CL.#*, CL.mkApply("sizeof",[CL.E_Var tyName]))]))                                                                          CL.#*, CL.mkApply("sizeof",[CL.E_Var tyName]))]))
629    
630                    (* Initialize Width Parameter *)
631                    val widthDel = if nDims = 2 then
632                              CL.mkAssign(CL.E_Var "width",CL.mkSubscript(CL.E_Var globalVar, CL.E_Int(1, CL.intTy)))
633                       else
634                              CL.mkAssign(CL.E_Var "width",CL.E_Int(0,CL.intTy))
635    
636              (* Setup Global and Local variables *)              (* Setup Global and Local variables *)
637                val globalAndlocalStms = if nDims = 1  
638                      then [CL.mkAssign(CL.mkSubscript(CL.E_Var globalVar, CL.E_Int(0,CL.intTy)),                  val globalAndlocalStms = if nDims = 1 then
639                            [CL.mkAssign(CL.mkSubscript(CL.E_Var globalVar, CL.E_Int(0,CL.intTy)),
640                                                                     CL.mkSubscript(CL.E_Var "size", CL.E_Int(0,CL.intTy))),                                                                     CL.mkSubscript(CL.E_Var "size", CL.E_Int(0,CL.intTy))),
641                           CL.mkAssign(CL.mkSubscript(CL.E_Var localVar, CL.E_Int(0,CL.intTy)),                           CL.mkAssign(CL.mkSubscript(CL.E_Var localVar, CL.E_Int(0,CL.intTy)),
642                                                                    CL.E_Var "16")]                                                                    CL.E_Var "16")]
# Line 574  Line 646 
646                          [CL.mkAssign(CL.mkSubscript(CL.E_Var globalVar, CL.E_Int(0,CL.intTy)),                          [CL.mkAssign(CL.mkSubscript(CL.E_Var globalVar, CL.E_Int(0,CL.intTy)),
647                                                                     CL.mkSubscript(CL.E_Var "size", CL.E_Int(0,CL.intTy))),                                                                     CL.mkSubscript(CL.E_Var "size", CL.E_Int(0,CL.intTy))),
648                          CL.mkAssign(CL.mkSubscript(CL.E_Var globalVar, CL.E_Int(1,CL.intTy)),                          CL.mkAssign(CL.mkSubscript(CL.E_Var globalVar, CL.E_Int(1,CL.intTy)),
649                                                                     CL.mkSubscript(CL.E_Var "sizes", CL.E_Int(1,CL.intTy))),                                                                     CL.mkSubscript(CL.E_Var "size", CL.E_Int(1,CL.intTy))),
650                          CL.mkAssign(CL.mkSubscript(CL.E_Var localVar, CL.E_Int(0,CL.intTy)),                          CL.mkAssign(CL.mkSubscript(CL.E_Var localVar, CL.E_Int(0,CL.intTy)),
651                                                                    CL.E_Var "16"),                                                                    CL.E_Var "16"),
652                          CL.mkAssign(CL.mkSubscript(CL.E_Var localVar, CL.E_Int(1,CL.intTy)),                          CL.mkAssign(CL.mkSubscript(CL.E_Var localVar, CL.E_Int(1,CL.intTy)),
# Line 613  Line 685 
685                                                                   CL.mkApply("sizeof",[CL.E_Var "int"]),                                                                   CL.mkApply("sizeof",[CL.E_Var "int"]),
686                                                                   CL.E_UnOp(CL.%&,CL.E_Var "width")])))]                                                                   CL.E_UnOp(CL.%&,CL.E_Var "width")])))]
687    
688                val clGlobalArguments = genGlobalArguments(!imgGlobals,3,kernelVar,errVar)             val clGlobalArguments = genGlobalArguments(!imgGlobals,3,kernelVar,errVar) @ [assertStm]
689    
690              (* Retrieve output *)              (* Retrieve output *)
691                val outputStm = CL.mkAssign(CL.E_Var errVar, CL.mkApply("clEnqueueReadBuffer",                  val outputStm = CL.mkAssign(CL.E_Var errVar,
692                                                            CL.mkApply("clEnqueueReadBuffer",
693                                          [CL.E_Var cmdVar,                                          [CL.E_Var cmdVar,
694                                           CL.E_Var clOutStateVar,                                           CL.E_Var clOutStateVar,
695                                           CL.E_Var "CL_TRUE",                                           CL.E_Var "CL_TRUE",
# Line 626  Line 699 
699                                           CL.E_Int(0,CL.intTy),                                           CL.E_Int(0,CL.intTy),
700                                           CL.E_Var "NULL",                                           CL.E_Var "NULL",
701                                           CL.E_Var "NULL"]))                                           CL.E_Var "NULL"]))
702    
703              (* Free all the objects *)              (* Free all the objects *)
704                val freeStms = [CL.mkCall("clReleaseKernel",[CL.E_Var kernelVar]),                val freeStms = [CL.mkCall("clReleaseKernel",[CL.E_Var kernelVar]),
705                                                  CL.mkCall("clReleaseProgram",[CL.E_Var programVar ]),                                                  CL.mkCall("clReleaseProgram",[CL.E_Var programVar ]),
# Line 633  Line 707 
707                                                  CL.mkCall("clReleaseContext",[CL.E_Var contextVar]),                                                  CL.mkCall("clReleaseContext",[CL.E_Var contextVar]),
708                                                  CL.mkCall("clReleaseMemObject",[CL.E_Var clInstateVar]),                                                  CL.mkCall("clReleaseMemObject",[CL.E_Var clInstateVar]),
709                                                  CL.mkCall("clReleaseMemObject",[CL.E_Var clOutStateVar])]                                                  CL.mkCall("clReleaseMemObject",[CL.E_Var clOutStateVar])]
710    
711    
712                    (*Setup Strand Print Function *)
713                    val outputData = [CL.mkDecl(CL.T_Ptr(CL.T_Named("FILE")), "outS", SOME(CL.I_Exp(CL.mkApply("fopen",
714                                                    [CL.E_Str "mip.txt",
715                                                    CL.E_Str "w"])))),
716                                                    CL.mkCall(concat[name, "_print"],
717                                                                            [CL.E_Var "outS",
718                                                                             CL.E_Var "size",
719                                                                             CL.E_Var "width",
720                                                                             CL.E_Var outStateVar])]
721    
722    
723              (* Body put all the statments together *)              (* Body put all the statments together *)
724                val body =  declarations @ platformStm @ devicesStm @ contextStm @ commandStm @ !initially @ [strandSize] @                  val body =  delcarations @ platformStm @ devicesStm @ contextStm @ commandStm @ !initially @ [strandSize] @
725                                     clStrandObjects @ clGlobalBuffers @ sourceStms  @ [selfOutStm] @ globalAndlocalStms @                                     clStrandObjects @ clGlobalBuffers @ sourceStms  @ [selfOutStm] @ create_build_stms @ globalAndlocalStms @ [widthDel] @
726                                     kernelArguments @ clGlobalArguments @ enqueueStm @  [outputStm] @ freeStms                                     kernelArguments @ clGlobalArguments @ enqueueStm @  [outputStm] @ freeStms @ outputData
727    
728                in                in
729    
730                  CL.D_Func([],CL.voidTy,RN.setupFName,params,CL.mkBlock(body))                  CL.D_Func([],CL.voidTy,RN.setupFName,params,CL.mkBlock(body))
               end  
731    
732                    end
733    (* generate the data and global parameters *)
734            fun genKeneralGlobalParams ((name,tyname)::rest) =
735                    CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named RN.globalsTy), concat[RN.globalsVarName]) ::
736                    CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named (RN.imageTy tyname)),RN.addBufferSuffix name) ::
737                    CL.PARAM(["__global"], CL.T_Ptr(CL.voidTy),RN.addBufferSuffixData name) ::
738                    genKeneralGlobalParams(rest)
739    
740              | genKeneralGlobalParams ([]) = []
741    
742            (*generate code for intilizing kernel global data *)
743            fun initKernelGlobals (globals,imgGlobals) = let
744                    fun initGlobalStruct (CL.D_Var(_, _ , name, _)::rest) =
745                                    CL.mkAssign(CL.E_Var name, CL.mkIndirect(CL.E_Var RN.globalsVarName, name)) ::
746                                    initGlobalStruct(rest)
747                      | initGlobalStruct ( _::rest) = initGlobalStruct(rest)
748                      | initGlobalStruct([]) = []
749    
750                    fun initGlobalImages((name,tyname)::rest) =
751                                    CL.mkAssign(CL.E_Var name, CL.E_Var (RN.addBufferSuffix name)) ::
752                                    CL.mkAssign(CL.mkIndirect(CL.E_Var name,"data"),CL.E_Var (RN.addBufferSuffixData name)) ::
753                                    initGlobalImages(rest)
754                      | initGlobalImages([]) = []
755                    in
756                      initGlobalStruct(globals) @ initGlobalImages(imgGlobals)
757                    end
758    
759          (* generate the main kernel function for the .cl file *)          (* generate the main kernel function for the .cl file *)
760          fun genKernelFun (Strand{name, tyName, state, output, code},nDims) = let          fun genKernelFun(Strand{name, tyName, state, output, code},nDims,globals,imgGlobals) = let
761                val fName = RN.kernelFuncName;                val fName = RN.kernelFuncName;
762                val inState = "strand_in"                val inState = "strand_in"
763                val outState = "strand_out"                val outState = "strand_out"
# Line 652  Line 765 
765                         CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),                         CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),
766                         CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfOut"),                         CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfOut"),
767                         CL.PARAM(["__global"], CL.intTy, "width")                         CL.PARAM(["__global"], CL.intTy, "width")
768                       ]                      ] @ genKeneralGlobalParams(!imgGlobals)
769                 val thread_ids = if nDims = 1                 val thread_ids = if nDims = 1
770                       then [CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.E_Int(0, CL.intTy)))),                       then [CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.E_Int(0, CL.intTy)))),
771                             CL.mkAssign(CL.E_Var "x",CL.mkApply(RN.getGlobalThreadId,[CL.E_Int(0,CL.intTy)]))]                             CL.mkAssign(CL.E_Var "x",CL.mkApply(RN.getGlobalThreadId,[CL.E_Int(0,CL.intTy)]))]
772                       else [CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.E_Int(0, CL.intTy)))),                          else
773                                    [CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.E_Int(0, CL.intTy)))),
774                             CL.mkDecl(CL.intTy, "y", SOME(CL.I_Exp(CL.E_Int(0, CL.intTy)))),                             CL.mkDecl(CL.intTy, "y", SOME(CL.I_Exp(CL.E_Int(0, CL.intTy)))),
775                             CL.mkAssign(CL.E_Var "x",  CL.mkApply(RN.getGlobalThreadId,[CL.E_Int(0,CL.intTy)])),                             CL.mkAssign(CL.E_Var "x",  CL.mkApply(RN.getGlobalThreadId,[CL.E_Int(0,CL.intTy)])),
776                             CL.mkAssign(CL.E_Var "y",CL.mkApply(RN.getGlobalThreadId,[CL.E_Int(1,CL.intTy)]))]                             CL.mkAssign(CL.E_Var "y",CL.mkApply(RN.getGlobalThreadId,[CL.E_Int(1,CL.intTy)]))]
777    
778                 val strandDecl = [CL.mkDecl(CL.T_Named tyName, inState, NONE),                 val strandDecl = [CL.mkDecl(CL.T_Named tyName, inState, NONE),
779                                   CL.mkDecl(CL.T_Named tyName, outState,NONE)]                                   CL.mkDecl(CL.T_Named tyName, outState,NONE)]
780                 val strandObjects  = if nDims = 1                 val strandObjects  = if nDims = 1
781                       then [CL.mkAssign(CL.mkSubscript(CL.E_Var "selfIn",CL.E_Str "x"), CL.E_Var inState),                          then [CL.mkAssign(CL.mkSubscript(CL.E_Var "selfIn",CL.E_Str "x"),
782                             CL.mkAssign(CL.mkSubscript(CL.E_Var "selfOut",CL.E_Str "x"), CL.E_Var outState)]                                                                           CL.E_Var inState),
783                                      CL.mkAssign(CL.mkSubscript(CL.E_Var "selfOut",CL.E_Str "x"),
784                                                                             CL.E_Var outState)]
785                       else let                       else let
786                         val index = CL.mkBinOp(CL.mkBinOp(CL.E_Var "y",CL.#*,CL.E_Var "width"),CL.#+,CL.E_Var "x")                                  val index = CL.mkBinOp(CL.mkBinOp(CL.E_Var "x",CL.#*,CL.E_Var "width"),CL.#+,CL.E_Var "y")
787                         in                         in
788                           [CL.mkAssign(CL.mkSubscript(CL.E_Var "selfIn",index), CL.E_Var inState),                                          [CL.mkAssign(CL.mkSubscript(CL.E_Var "selfIn",index),
789                            CL.mkAssign(CL.mkSubscript(CL.E_Var "selfOut",index), CL.E_Var outState)]                                                                          CL.E_Var inState),
790                                             CL.mkAssign(CL.mkSubscript(CL.E_Var "selfOut",index),
791                                                                            CL.E_Var outState)]
792                         end                         end
793    
794    
795                 val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.E_Int(0, CL.intTy))))                 val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.E_Int(0, CL.intTy))))
796                 val strand_init_function = CL.mkCall(RN.strandInit name, [CL.E_Var inState])                    val strand_init_function = CL.mkCall(RN.strandInit name, [CL.E_UnOp(CL.%&,CL.E_Var inState),CL.E_Var "x", CL.E_Var "y"])
797                 val local_vars =  thread_ids @ strandDecl @ strandObjects @ [status,strand_init_function]                    val local_vars =  thread_ids @ initKernelGlobals(!globals,!imgGlobals)  @ strandDecl @ strandObjects @ [status,strand_init_function]
798                 val while_exp = CL.mkBinOp(CL.E_Var "status",CL.#!=, CL.E_Var RN.kStabilize)                    val while_exp = CL.mkBinOp(CL.mkBinOp(CL.E_Var "status",CL.#!=, CL.E_Var RN.kStabilize),CL.#||,CL.mkBinOp(CL.E_Var "status", CL.#!=, CL.E_Var RN.kDie))
799                 val while_body = [CL.mkAssign(CL.E_Var "status", CL.mkApply(RN.strandUpdate name,[CL.E_Var inState,CL.E_Var outState])),                    val while_body = [CL.mkAssign(CL.E_Var "status", CL.mkApply(RN.strandUpdate name,[ CL.E_UnOp(CL.%&,CL.E_Var inState), CL.E_UnOp(CL.%&,CL.E_Var outState)])),
800                                                       CL.mkCall(RN.strandStabilize name,[CL.E_Var inState,CL.E_Var outState]),                                                          CL.mkCall(RN.strandStabilize name,[ CL.E_UnOp(CL.%&,CL.E_Var inState),  CL.E_UnOp(CL.%&,CL.E_Var outState)])]
                                                      CL.mkIfThen(CL.mkBinOp(CL.E_Var "status",CL.#==, CL.E_Var RN.kStabilize),CL.mkBreak)]  
801    
802                 val whileBlock = [CL.mkWhile(while_exp,CL.mkBlock while_body)]                 val whileBlock = [CL.mkWhile(while_exp,CL.mkBlock while_body)]
803    
804                 val body = CL.mkBlock(local_vars  @ whileBlock)                 val body = CL.mkBlock(local_vars  @ whileBlock)
805                 in                 in
806                    CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)                    CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)
# Line 692  Line 813 
813                in                in
814                  CL.D_StructDef(getGlobals(globals),RN.globalsTy)                  CL.D_StructDef(getGlobals(globals),RN.globalsTy)
815                end                end
816    
817        (* generate the table of strand descriptors *)        (* generate the table of strand descriptors *)
818          fun genStrandTable (ppStrm, strands) = let          fun genStrandTable (ppStrm, strands) = let
819                val nStrands = length strands                val nStrands = length strands
# Line 708  Line 830 
830                    SOME(CL.I_Array(genInits (0, strands)))))                    SOME(CL.I_Array(genInits (0, strands)))))
831                end                end
832    
833          fun genSrc (baseName, Prog{globals, topDecls, strands, initially,imgGlobals,numDims,oneDim,twoDim,thirdDim,...}) = let  
834            fun genSrc (baseName, Prog{double,globals, topDecls, strands, initially,imgGlobals,numDims,...}) = let
835                val clFileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "cl"}                val clFileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "cl"}
836                val cFileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}                val cFileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}
837                val clOutS = TextIO.openOut clFileName                val clOutS = TextIO.openOut clFileName
# Line 718  Line 841 
841                fun cppDecl dcl = PrintAsC.output(cppStrm, dcl)                fun cppDecl dcl = PrintAsC.output(cppStrm, dcl)
842                fun clppDecl dcl = PrintAsC.output(clppStrm, dcl)                fun clppDecl dcl = PrintAsC.output(clppStrm, dcl)
843                val strands = AtomTable.listItems strands                val strands = AtomTable.listItems strands
844                val singleStrand as Strand{name, tyName, code, ...} = hd(strands)                val single_strand as Strand{name, tyName, code, ...}= hd(strands)
845                in                in
846    
847                (* Generate the OpenCl file *)
848                List.app clppDecl (List.rev (!globals));
849                clppDecl (genGlobalStruct (!globals));
850                clppDecl (genStrandTyDef single_strand);
851                List.app clppDecl (!code);
852                clppDecl (genKernelFun (single_strand,!numDims,globals,imgGlobals));
853    
854    
855                (* Generate the Host file .c *)                (* Generate the Host file .c *)
856                  cppDecl (CL.D_Verbatim([                  cppDecl (CL.D_Verbatim([
857                            if double
858                              then "#define DIDEROT_DOUBLE_PRECISION"
859                              else "#define DIDEROT_SINGLE_PRECISION",
860                             "#include \"Diderot/diderot.h\"",
861                      "#include <OpenCL/OpenCL.h>",                      "#include <OpenCL/OpenCL.h>",
862                      "#include Diderot/diderot.h"                           "#include <sys/sysctl.h>",
863                             "#include <sys/stat.h>",
864                             "#include <assert.h>"
865                    ]));                    ]));
866    
867                (* cppDecl (CL.D_Verbatim([ "#include <OpenCL/OpenCL.h>",
868                                                                     "#include Diderot/diderot.h"])); *)
869                  List.app cppDecl (List.rev (!globals));                  List.app cppDecl (List.rev (!globals));
870                  cppDecl (genGlobalStruct (!globals));                  cppDecl (genGlobalStruct (!globals));
871                  cppDecl (genStrandTyDef singleStrand);              cppDecl (genStrandTyDef single_strand);
872                    cppDecl (genStrandPrint(single_strand,!numDims));
873                  cppDecl (genKernelLoader());                  cppDecl (genKernelLoader());
874                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
875                  cppDecl (genHostSetupFunc (              cppDecl (genHostSetupFunc (single_strand,clFileName,!numDims,initially,imgGlobals));
                     singleStrand, clFileName, !numDims, initially,  
                     imgGlobals, oneDim, twoDim, thirdDim));  
876                  cppDecl (genHostMain());                  cppDecl (genHostMain());
877    
878                (* Generate the OpenCl file *)  
                 clppDecl (genGlobalStruct (!globals));  
                 clppDecl (genStrandTyDef singleStrand);  
                 List.app clppDecl (!code);  
                 clppDecl (genKernelFun (singleStrand,!numDims));  
879    
880                  (*List.app (fn strand => List.app ppDecl (genStrand strand)) strands;                  (*List.app (fn strand => List.app ppDecl (genStrand strand)) strands;
881                   genStrandTable (ppStrm, strands);                   genStrandTable (ppStrm, strands);
# Line 779  Line 915 
915                  (*RunCC.compile (basename, cflags);                  (*RunCC.compile (basename, cflags);
916                  RunCC.link (basename, ldOpts)*)                  RunCC.link (basename, ldOpts)*)
917    
       end  
918    
919          end
920    (* strands *)    (* strands *)
921      structure Strand =      structure Strand =
922        struct        struct

Legend:
Removed from v.1261  
changed lines
  Added in v.1264

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