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 1270, Sun Jun 5 12:01:52 2011 UTC revision 1271, Mon Jun 6 02:45:57 2011 UTC
# Line 23  Line 23 
23          tyName : string,          tyName : string,
24          state : var list ref,          state : var list ref,
25          output : (Ty.ty * CL.var) option ref,   (* the strand's output variable (only one for now) *)          output : (Ty.ty * CL.var) option ref,   (* the strand's output variable (only one for now) *)
26          code : CL.decl list ref          code : CL.decl list ref,
27                      init_code: CL.decl ref
28        }        }
29    
30      datatype program = Prog of {      datatype program = Prog of {
# Line 145  Line 146 
146                RN.initTargetSpec double;                RN.initTargetSpec double;
147                Prog{                Prog{
148                    double = double, parallel = parallel, debug = debug,                    double = double, parallel = parallel, debug = debug,
149                    globals = ref [                    globals = ref [],
                     CL.D_Verbatim[  
                         if double  
                           then "#define DIDEROT_DOUBLE_PRECISION"  
                           else "#define DIDEROT_SINGLE_PRECISION",  
                         "#include \"Diderot/opencl_types.h\""  
                       ]],  
150                    topDecls = ref [],                    topDecls = ref [],
151                    strands = AtomTable.mkTable (16, Fail "strand table"),                    strands = AtomTable.mkTable (16, Fail "strand table"),
152                    initially = ref([CL.S_Comment["missing initially"]]),                    initially = ref([CL.S_Comment["missing initially"]]),
# Line 241  Line 236 
236    
237    
238        (***** OUTPUT *****)        (***** OUTPUT *****)
239          fun genStrandPrint (Strand{name, tyName, state, output, code},nDims) = let          fun genStrandInit(Strand{name,tyName,state,output,code,...},nDims) = let
240                    val params = [
241                              CL.PARAM([], CL.T_Ptr(CL.uint32), "sizes" ),
242                              CL.PARAM([], CL.intTy, "width"),
243                              CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "strands")
244                            ]
245    
246                    val body = let
247                                fun loopParams (3) =
248                                     "x"::"y"::"k"::[]
249                                  | loopParams (2) =
250                                     "x"::"y"::[]
251                                  | loopParams (1) =
252                                     "x"::[]
253                                  | loopParams (_) =
254                                    raise Fail("genStrandInit: missing size dim")
255                               fun mkLoopNest ([],_,nDims) =  if nDims = 1 then
256    
257                                            CL.mkBlock ([CL.mkCall(RN.strandInit name, [CL.E_UnOp(CL.%&,CL.mkSubscript(CL.E_Var "strands",CL.E_Str "x")),
258                                                    CL.E_Var "x"])])
259                                            else let
260                                                    val index = CL.mkBinOp(CL.mkBinOp(CL.E_Var "x",CL.#*,CL.E_Var "width"),CL.#+,CL.E_Var "y")
261                                            in
262                                                    CL.mkBlock([CL.mkCall(RN.strandInit name, [CL.E_UnOp(CL.%&,CL.mkSubscript(CL.E_Var "strands",index)),
263                                                    CL.E_Var "x", CL.E_Var"y"])])
264                                            end
265    
266                                    | mkLoopNest (param::rest,count,nDims) = let
267                                            val body = mkLoopNest (rest, count + 1,nDims)
268                                       in
269                                            CL.mkFor(
270                                                            [(CL.intTy, param, CL.E_Int(0,CL.intTy))],
271                                                    CL.mkBinOp(CL.E_Var param, CL.#<, CL.mkSubscript(CL.E_Var "sizes",CL.E_Int(count,CL.intTy))),
272                                                    [CL.mkPostOp(CL.E_Var param, CL.^++)],
273                                                    body)
274                                       end
275                            in
276                                    [mkLoopNest ((loopParams nDims),0,nDims)]
277                            end
278                    in
279                            CL.D_Func(["static"], CL.voidTy, RN.strandInitSetup, params,CL.mkBlock(body))
280                    end
281            fun genStrandPrint (Strand{name, tyName, state, output, code,...},nDims) = let
282              (* the print function *)              (* the print function *)
283                val prFnName = concat[name, "_print"]                val prFnName = concat[name, "_print"]
284    
285                val prFn = let                val prFn = let
286                      val params = [                      val params = [
287                            CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                            CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
288                            CL.PARAM([], CL.T_Ptr(CL.intTy), "sizes" ),                            CL.PARAM([], CL.T_Ptr(CL.uint32), "sizes" ),
289                            CL.PARAM([], CL.intTy, "width"),                            CL.PARAM([], CL.intTy, "width"),
290                            CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")                            CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")
291                          ]                          ]
# Line 302  Line 339 
339                                     in                                     in
340                                                  CL.mkFor(                                                  CL.mkFor(
341                                                          [(CL.intTy, param, CL.E_Int(0,CL.intTy))],                                                          [(CL.intTy, param, CL.E_Int(0,CL.intTy))],
342                                                  CL.mkBinOp(CL.E_Var param, CL.#<=, CL.mkSubscript(CL.E_Var "sizes",CL.E_Int(count,CL.intTy))),                                                  CL.mkBinOp(CL.E_Var param, CL.#<, CL.mkSubscript(CL.E_Var "sizes",CL.E_Int(count,CL.intTy))),
343                                                  [CL.mkPostOp(CL.E_Var param, CL.^++)],                                                  [CL.mkPostOp(CL.E_Var param, CL.^++)],
344                                                  body)                                                  body)
345                                     end                                     end
# Line 345  Line 382 
382                  val globalBufferDecl =  CL.mkDecl(CL.clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)                  val globalBufferDecl =  CL.mkDecl(CL.clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)
383                  val globalBuffer = CL.mkAssign(CL.E_Var(concat[RN.globalsVarName,"_cl"]), CL.mkApply("clCreateBuffer",                  val globalBuffer = CL.mkAssign(CL.E_Var(concat[RN.globalsVarName,"_cl"]), CL.mkApply("clCreateBuffer",
384                                                                  [CL.E_Var contextVar,                                                                  [CL.E_Var contextVar,
385                                                                  CL.E_Var "CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR",                                                                  CL.E_Var "CL_MEM_COPY_HOST_PTR",
386                                                                  CL.mkApply("sizeof",[CL.E_Var RN.globalsTy]),                                                                  CL.mkApply("sizeof",[CL.E_Var RN.globalsTy]),
387                                                                  CL.E_Var RN.globalsVarName,                                                                  CL.E_Var RN.globalsVarName,
388                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)]))                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)]))
# Line 368  Line 405 
405                     CL.mkDecl(CL.clMemoryTy,RN.addBufferSuffixData var ,NONE)::                     CL.mkDecl(CL.clMemoryTy,RN.addBufferSuffixData var ,NONE)::
406                     CL.mkAssign(CL.E_Var(RN.addBufferSuffix var), CL.mkApply("clCreateBuffer",                     CL.mkAssign(CL.E_Var(RN.addBufferSuffix var), CL.mkApply("clCreateBuffer",
407                                                                  [CL.E_Var contextVar,                                                                  [CL.E_Var contextVar,
408                                                                  CL.E_Var "CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR",                                                                  CL.E_Var "CL_MEM_COPY_HOST_PTR",
409                                                                  CL.mkApply("sizeof",[CL.E_Var (RN.imageTy nDims)]),                                                                  CL.mkApply("sizeof",[CL.E_Var (RN.imageTy nDims)]),
410                                                                  CL.E_Var var,                                                                  CL.E_Var var,
411                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)])) ::                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)])) ::
412                          CL.mkAssign(CL.E_Var(RN.addBufferSuffixData var), CL.mkApply("clCreateBuffer",                          CL.mkAssign(CL.E_Var(RN.addBufferSuffixData var), CL.mkApply("clCreateBuffer",
413                                                                  [CL.E_Var contextVar,                                                                  [CL.E_Var contextVar,
414                                                                  CL.E_Var "CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR",                                                                   CL.E_Var "CL_MEM_COPY_HOST_PTR",
415                                                                  size,                                                                  size,
416                                                                  CL.mkIndirect(CL.E_Var var,"data"),                                                                  CL.mkIndirect(CL.E_Var var,"data"),
417                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)])):: genDataBuffers(globals,count + 2,contextVar,errVar)                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)])):: genDataBuffers(globals,count + 2,contextVar,errVar)
# Line 456  Line 493 
493                  val numDevicesVar = "num_devices"                  val numDevicesVar = "num_devices"
494                  val assertStm = CL.mkCall("assert",[CL.mkBinOp(CL.E_Var errVar, CL.#==, CL.E_Var "CL_SUCCESS")])                  val assertStm = CL.mkCall("assert",[CL.mkBinOp(CL.E_Var errVar, CL.#==, CL.E_Var "CL_SUCCESS")])
495                  val params = [                  val params = [
496                           CL.PARAM([],CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName)                           CL.PARAM([],CL.T_Named("cl_device_id"), deviceVar)
497                           ]                           ]
498                  val delcarations = [CL.mkDecl(CL.clProgramTy, programVar, NONE),                  val delcarations = [CL.mkDecl(CL.clProgramTy, programVar, NONE),
499                            CL.mkDecl(CL.clKernelTy, kernelVar, NONE),                            CL.mkDecl(CL.clKernelTy, kernelVar, NONE),
500                            CL.mkDecl(CL.clCmdQueueTy, cmdVar, NONE),                            CL.mkDecl(CL.clCmdQueueTy, cmdVar, NONE),
501                            CL.mkDecl(CL.clContextTy, contextVar, NONE),                            CL.mkDecl(CL.clContextTy, contextVar, NONE),
502                            CL.mkDecl(CL.intTy, errVar, NONE),                            CL.mkDecl(CL.intTy, errVar, NONE),
503                            CL.mkDecl(CL.intTy, numStrandsVar, NONE),                            CL.mkDecl(CL.intTy, numStrandsVar, SOME(CL.I_Exp(CL.E_Int(1,CL.intTy)))),
504                            CL.mkDecl(CL.intTy, stateSizeVar, NONE),                            CL.mkDecl(CL.intTy, stateSizeVar, NONE),
505                            CL.mkDecl(CL.intTy, "width", NONE),                            CL.mkDecl(CL.intTy, "width", NONE),
506                            CL.mkDecl(CL.intTy, imgDataSizeVar, NONE),                            CL.mkDecl(CL.intTy, imgDataSizeVar, NONE),
507                            CL.mkDecl(CL.clDeviceIdTy, deviceVar, NONE),                            (*CL.mkDecl(CL.clDeviceIdTy, deviceVar, NONE), *)
508                            CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), inStateVar,NONE),                            CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), inStateVar,NONE),
509                            CL.mkDecl(CL.clMemoryTy,clInstateVar,NONE),                            CL.mkDecl(CL.clMemoryTy,clInstateVar,NONE),
510                            CL.mkDecl(CL.clMemoryTy,clOutStateVar,NONE),                            CL.mkDecl(CL.clMemoryTy,clOutStateVar,NONE),
511                            CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), outStateVar,NONE),                            CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), outStateVar,NONE),
512                            CL.mkDecl(CL.charPtr, clFNVar,SOME(CL.I_Exp(CL.E_Str filename))),                            CL.mkDecl(CL.charPtr, clFNVar,SOME(CL.I_Exp(CL.E_Str filename))),
513                            CL.mkDecl(CL.charPtr, headerFNVar,SOME(CL.I_Exp(CL.E_Str "Diderot/opencl_types.h"))),                            CL.mkDecl(CL.charPtr, headerFNVar,SOME(CL.I_Exp(CL.E_Str "../src/include/Diderot/opencl_types.h"))),
514                            CL.mkDecl(CL.T_Array(CL.charPtr,SOME(2)),sourcesVar,NONE),                            CL.mkDecl(CL.T_Array(CL.charPtr,SOME(2)),sourcesVar,NONE),
515                            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),
516                            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),
# Line 481  Line 518 
518                            CL.mkDecl(CL.T_Array(CL.T_Named "cl_platform_id", SOME(1)), platformsVar, NONE),                            CL.mkDecl(CL.T_Array(CL.T_Named "cl_platform_id", SOME(1)), platformsVar, NONE),
519                            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))))]
520    
521                  (* Retrieve the platforms *)                  (*Setup Global Variables *)
522                    val globalsDecl = CL.mkDecl(CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName,SOME(CL.I_Exp(CL.mkApply("malloc",
523                                                                            [CL.mkApply("sizeof",[CL.E_Var RN.globalsTy])]))))
524                    val initGlobalsCall = CL.mkCall(RN.initGlobals,[CL.E_Var RN.globalsVarName])
525    
526                    (* Retrieve the platforms
527                  val platformStm = [CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetPlatformIDs",                  val platformStm = [CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetPlatformIDs",
528                                                    [CL.E_Int(10,CL.intTy),                                                    [CL.E_Int(10,CL.intTy),
529                                                     CL.E_Var platformsVar,                                                     CL.E_Var platformsVar,
# Line 494  Line 536 
536                                                     CL.E_Int(1,CL.intTy),                                                     CL.E_Int(1,CL.intTy),
537                                                     CL.E_UnOp(CL.%&,CL.E_Var deviceVar),                                                     CL.E_UnOp(CL.%&,CL.E_Var deviceVar),
538                                                     CL.E_UnOp(CL.%&,CL.E_Var numDevicesVar)])),                                                     CL.E_UnOp(CL.%&,CL.E_Var numDevicesVar)])),
539                                                     assertStm]                                                     assertStm] *)
540    
541                  (* Create Context *)                  (* Create Context *)
542                  val contextStm = [CL.mkAssign(CL.E_Var contextVar, CL.mkApply("clCreateContext",                  val contextStm = [CL.mkAssign(CL.E_Var contextVar, CL.mkApply("clCreateContext",
# Line 531  Line 573 
573                                                                                                                   CL.E_Var "NULL",                                                                                                                   CL.E_Var "NULL",
574                                                                                                                   CL.E_Var "NULL",                                                                                                                   CL.E_Var "NULL",
575                                                                                                                   CL.E_Var "NULL"])),                                                                                                                   CL.E_Var "NULL"])),
576                                            CL.mkDecl(CL.T_Array(CL.charTy,SOME(2048)), "build", NONE),                                            CL.mkDecl(CL.charPtr, "build", NONE),
577                                              CL.mkDecl(CL.T_Named("size_t"),"ret_val_size",NONE),
578                                               CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetProgramBuildInfo",
579                                                                                                                    [CL.E_Var programVar,
580                                                                                                                    CL.E_Var deviceVar,
581                                                                                                                     CL.E_Var "CL_PROGRAM_BUILD_LOG",
582                                                                                                                     CL.E_Int(0,CL.intTy),
583                                                                                                                     CL.E_Var "NULL",
584                                                                                                                     CL.E_UnOp(CL.%&,CL.E_Var "ret_val_size")])),
585                                              CL.mkAssign(CL.E_Var "build", CL.mkApply("malloc", [CL.E_Var "ret_val_size"])),
586                                             CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetProgramBuildInfo",                                             CL.mkAssign(CL.E_Var errVar, CL.mkApply("clGetProgramBuildInfo",
587                                                                                                                  [CL.E_Var programVar,                                                                                                                  [CL.E_Var programVar,
588                                                                                                                  CL.E_Var deviceVar,                                                                                                                  CL.E_Var deviceVar,
589                                                                                                                   CL.E_Var "CL_PROGRAM_BUILD_LOG",                                                                                                                   CL.E_Var "CL_PROGRAM_BUILD_LOG",
590                                                                                                                   CL.E_Int (2048,CL.intTy),                                                                                                                   CL.E_Var "ret_val_size",
591                                                                                                                   CL.E_Var "build",                                                                                                                   CL.E_Var "build",
592                                                                                                                   CL.E_Var "NULL"])),                                                                                                                   CL.E_Var "NULL"])),
593                                                    CL.mkAssign(CL.mkSubscript(CL.E_Var "build",CL.E_Var "ret_val_size"),CL.E_Var ("'\\" ^ "0'")),
594                                                  CL.mkCall("printf",[CL.E_Str ( "Build Log:" ^ "\n" ^ "%s" ^ "\n"), CL.E_Var "build"])]                                                  CL.mkCall("printf",[CL.E_Str ( "Build Log:" ^ "\n" ^ "%s" ^ "\n"), CL.E_Var "build"])]
595    
596    
# Line 557  Line 609 
609                  (* Create Memory Buffers for Strand States and Globals *)                  (* Create Memory Buffers for Strand States and Globals *)
610                  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",
611                                                                          [CL.E_Var tyName]), CL.#*,CL.E_Var numStrandsVar))                                                                          [CL.E_Var tyName]), CL.#*,CL.E_Var numStrandsVar))
                 val strandObjects = [CL.mkAssign(CL.E_Var inStateVar, CL.mkApply("malloc",  
                                                                                 [CL.E_Var stateSizeVar])),  
                                                         CL.mkAssign(CL.E_Var outStateVar, CL.mkApply("malloc",  
                                                                                 [CL.E_Var stateSizeVar]))]  
612    
613                  val clStrandObjects = [CL.mkAssign(CL.E_Var clInstateVar, CL.mkApply("clCreateBuffer",                  val clStrandObjects = [CL.mkAssign(CL.E_Var clInstateVar, CL.mkApply("clCreateBuffer",
614                                                                  [CL.E_Var contextVar,                                                                  [CL.E_Var contextVar,
615                                                                  CL.E_Var "CL_MEM_READ_WRITE",                                                                  CL.E_Var "CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR",
616                                                                  CL.E_Var stateSizeVar,                                                                  CL.E_Var stateSizeVar,
617                                                                  CL.E_Var "NULL",                                                                  CL.E_Var "NULL",
618                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)])),                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)])),
# Line 575  Line 623 
623                                                                  CL.E_Var "NULL",                                                                  CL.E_Var "NULL",
624                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)]))]                                                                  CL.E_UnOp(CL.%&,CL.E_Var errVar)]))]
625    
626    
627                    (* Setup up selfOut variable *)
628                    val strandsArrays = [CL.mkAssign(CL.E_Var outStateVar, CL.mkApply("malloc", [CL.mkBinOp(CL.E_Var numStrandsVar,
629                                                                            CL.#*, CL.mkApply("sizeof",[CL.E_Var tyName]))])),
630                                                                    CL.mkAssign(CL.E_Var inStateVar, CL.mkApply("malloc", [CL.mkBinOp(CL.E_Var numStrandsVar,
631                                                                            CL.#*, CL.mkApply("sizeof",[CL.E_Var tyName]))]))]
632    
633    
634                    (* Initialize Width Parameter *)
635                    val widthDel = if nDims = 2 then
636                              CL.mkAssign(CL.E_Var "width",CL.mkSubscript(CL.E_Var globalVar, CL.E_Int(1, CL.intTy)))
637                       else
638                              CL.mkAssign(CL.E_Var "width",CL.E_Int(0,CL.intTy))
639    
640    
641                    val strands_init =      CL.mkCall(RN.strandInitSetup,
642                                                                             [CL.E_Var "size",
643                                                                             CL.E_Var "width",
644                                                                             CL.E_Var inStateVar])
645    
646              val clGlobalBuffers = getGlobalDataBuffers(!imgGlobals,3,contextVar,errVar)              val clGlobalBuffers = getGlobalDataBuffers(!imgGlobals,3,contextVar,errVar)
647    
648    
649                  (* Load the Kernel and Header Files *)                  (* Load the Kernel and Header Files *)
650                  val sourceStms = [CL.mkAssign(CL.mkSubscript(CL.E_Var sourcesVar,CL.E_Int(0,CL.intTy)),                  val sourceStms = [CL.mkAssign(CL.mkSubscript(CL.E_Var sourcesVar,CL.E_Int(1,CL.intTy)),
651                                                                            CL.mkApply(RN.clLoaderFN, [CL.E_Var clFNVar])),                                                                            CL.mkApply(RN.clLoaderFN, [CL.E_Var clFNVar])),
652                                                    CL.mkAssign(CL.mkSubscript(CL.E_Var sourcesVar,CL.E_Int(1,CL.intTy)),             CL.mkAssign(CL.mkSubscript(CL.E_Var sourcesVar,CL.E_Int(0,CL.intTy)),
653                                                                            CL.mkApply(RN.clLoaderFN, [CL.E_Var headerFNVar]))]                                                                            CL.mkApply(RN.clLoaderFN, [CL.E_Var headerFNVar]))]
654    
655                    (* val sourceStms = [CL.mkAssign(CL.mkSubscript(CL.E_Var sourcesVar,CL.E_Int(1,CL.intTy)),
656                                                                              CL.mkApply(RN.clLoaderFN, [CL.E_Var clFNVar]))] *)
657    
658    
659                  (* Created Enqueue Statements *)                  (* Created Enqueue Statements *)
660  (* FIXME: simplify this code by function abstraction *)  (* FIXME: simplify this code by function abstraction *)
661          val enqueueStm = if nDims = 1          val enqueueStm = if nDims = 1
# Line 623  Line 695 
695                                                                                                   CL.E_Var "NULL",                                                                                                   CL.E_Var "NULL",
696                                                                                                   CL.E_Var "NULL"])),CL.mkCall("clFinish",[CL.E_Var cmdVar])]                                                                                                   CL.E_Var "NULL"])),CL.mkCall("clFinish",[CL.E_Var cmdVar])]
697    
                 (* Setup up selfOut variable *)  
                 val selfOutStm = CL.mkAssign(CL.E_Var outStateVar, CL.mkApply("malloc", [CL.mkBinOp(CL.E_Var numStrandsVar,  
                                                                         CL.#*, CL.mkApply("sizeof",[CL.E_Var tyName]))]))  
698    
                 (* Initialize Width Parameter *)  
                 val widthDel = if nDims = 2 then  
                           CL.mkAssign(CL.E_Var "width",CL.mkSubscript(CL.E_Var globalVar, CL.E_Int(1, CL.intTy)))  
                    else  
                           CL.mkAssign(CL.E_Var "width",CL.E_Int(0,CL.intTy))  
699    
700                  (* Setup Global and Local variables *)                  (* Setup Global and Local variables *)
701    
# Line 720  Line 784 
784                                                                           CL.E_Var outStateVar])]                                                                           CL.E_Var outStateVar])]
785    
786    
787    
788                  (* Body put all the statments together *)                  (* Body put all the statments together *)
789                  val body =  delcarations @ platformStm @ devicesStm @ contextStm @ commandStm @ !initially @ [strandSize] @                  val body =  delcarations @ [globalsDecl,initGlobalsCall] (*@ platformStm @ devicesStm *) @ contextStm @ commandStm @ !initially @ [strandSize] @
790                                     clStrandObjects @ clGlobalBuffers @ sourceStms  @ [selfOutStm] @ create_build_stms @ globalAndlocalStms @ [widthDel] @                                     strandsArrays @ globalAndlocalStms @ [widthDel,strands_init]  @ clStrandObjects @ clGlobalBuffers @ sourceStms  @ create_build_stms  (*@
791                                     kernelArguments @ clGlobalArguments @ enqueueStm @  [outputStm] @ freeStms @ outputData                                     kernelArguments @ clGlobalArguments @ enqueueStm @  [outputStm] @ freeStms @ outputData *)
792    
793                  in                  in
794    
# Line 732  Line 797 
797                  end                  end
798  (* generate the data and global parameters *)  (* generate the data and global parameters *)
799          fun genKeneralGlobalParams ((name,tyname)::rest) =          fun genKeneralGlobalParams ((name,tyname)::rest) =
800                  CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named RN.globalsTy), concat[RN.globalsVarName]) ::                  CL.PARAM([], CL.T_Ptr(CL.T_Named RN.globalsTy), concat[RN.globalsVarName]) ::
801                  CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named (RN.imageTy tyname)),RN.addBufferSuffix name) ::                  CL.PARAM([], CL.T_Ptr(CL.T_Named (RN.imageTy tyname)),RN.addBufferSuffix name) ::
802                  CL.PARAM(["__global"], CL.T_Ptr(CL.voidTy),RN.addBufferSuffixData name) ::                  CL.PARAM([], CL.T_Ptr(CL.voidTy),RN.addBufferSuffixData name) ::
803                  genKeneralGlobalParams(rest)                  genKeneralGlobalParams(rest)
804    
805            | genKeneralGlobalParams ([]) = []            | genKeneralGlobalParams ([]) = []
# Line 757  Line 822 
822                  end                  end
823    
824          (* generate the main kernel function for the .cl file *)          (* generate the main kernel function for the .cl file *)
825          fun genKernelFun(Strand{name, tyName, state, output, code},nDims,globals,imgGlobals) = let          fun genKernelFun(Strand{name, tyName, state, output, code,...},nDims,globals,imgGlobals) = let
826                   val fName = RN.kernelFuncName;                   val fName = RN.kernelFuncName;
827                   val inState = "strand_in"                   val inState = "strand_in"
828                   val outState = "strand_out"                   val outState = "strand_out"
# Line 793  Line 858 
858    
859    
860                    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))))
861                    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"])                    val local_vars =  thread_ids @ initKernelGlobals(!globals,!imgGlobals)  @ strandDecl @ strandObjects @ [status]
                   val local_vars =  thread_ids @ initKernelGlobals(!globals,!imgGlobals)  @ strandDecl @ strandObjects @ [status,strand_init_function]  
862                    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))                    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))
863                    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)])),                    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)])),
864                                                          CL.mkCall(RN.strandStabilize name,[ CL.E_UnOp(CL.%&,CL.E_Var inState),  CL.E_UnOp(CL.%&,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)])]
# Line 841  Line 905 
905                fun cppDecl dcl = PrintAsC.output(cppStrm, dcl)                fun cppDecl dcl = PrintAsC.output(cppStrm, dcl)
906                fun clppDecl dcl = PrintAsC.output(clppStrm, dcl)                fun clppDecl dcl = PrintAsC.output(clppStrm, dcl)
907                val strands = AtomTable.listItems strands                val strands = AtomTable.listItems strands
908                val single_strand as Strand{name, tyName, code, ...}= hd(strands)                val single_strand as Strand{name, tyName, code,init_code, ...}= hd(strands)
909                in                in
910    
911              (* Generate the OpenCl file *)              (* Generate the OpenCl file *)
# Line 859  Line 923 
923                            else "#define DIDEROT_SINGLE_PRECISION",                            else "#define DIDEROT_SINGLE_PRECISION",
924                           "#include \"Diderot/diderot.h\"",                           "#include \"Diderot/diderot.h\"",
925                           "#include <OpenCL/OpenCL.h>",                           "#include <OpenCL/OpenCL.h>",
                          "#include <sys/sysctl.h>",  
                          "#include <sys/stat.h>",  
926                           "#include <assert.h>"                           "#include <assert.h>"
927                        ]));                        ]));
928    
# Line 869  Line 931 
931                  List.app cppDecl (List.rev (!globals));                  List.app cppDecl (List.rev (!globals));
932              cppDecl (genGlobalStruct (!globals));              cppDecl (genGlobalStruct (!globals));
933              cppDecl (genStrandTyDef single_strand);              cppDecl (genStrandTyDef single_strand);
934                     cppDecl  (!init_code);
935                     cppDecl (genStrandInit(single_strand,!numDims));
936                  cppDecl (genStrandPrint(single_strand,!numDims));                  cppDecl (genStrandPrint(single_strand,!numDims));
937              cppDecl (genKernelLoader());             (* cppDecl (genKernelLoader());*)
938              List.app cppDecl (List.rev (!topDecls));              List.app cppDecl (List.rev (!topDecls));
939              cppDecl (genHostSetupFunc (single_strand,clFileName,!numDims,initially,imgGlobals));              cppDecl (genHostSetupFunc (single_strand,clFileName,!numDims,initially,imgGlobals));
             cppDecl (genHostMain());  
   
   
940    
941                  (*List.app (fn strand => List.app ppDecl (genStrand strand)) strands;                  (*List.app (fn strand => List.app ppDecl (genStrand strand)) strands;
942                   genStrandTable (ppStrm, strands);                   genStrandTable (ppStrm, strands);
# Line 903  Line 964 
964              (* generate the loader flags *)              (* generate the loader flags *)
965                val extraLibs = condCons (parallel, #pthread Paths.extraLibs, [])                val extraLibs = condCons (parallel, #pthread Paths.extraLibs, [])
966                val extraLibs = Paths.teemLinkFlags @  #base Paths.extraLibs :: extraLibs                val extraLibs = Paths.teemLinkFlags @  #base Paths.extraLibs :: extraLibs
967                       val extraLibs =  #cl Paths.extraLibs :: extraLibs
968                val rtLib = TargetUtil.runtimeName {                val rtLib = TargetUtil.runtimeName {
969                        target = TargetUtil.TARGET_CL,                        target = TargetUtil.TARGET_CL,
970                        parallel = parallel, double = double, debug = debug                        parallel = parallel, double = double, debug = debug
971                      }                      }
972                val ldOpts = rtLib :: extraLibs                val ldOpts = rtLib :: extraLibs
973                in                in
974                  genSrc (basename, prog)                  genSrc (basename, prog);
975                    RunCC.compile (basename, cflags);
976                    RunCC.link (basename, ldOpts)
977                  end                  end
978    
                 (*RunCC.compile (basename, cflags);  
                 RunCC.link (basename, ldOpts)*)  
979    
980    
981        end        end
# Line 927  Line 989 
989                        tyName = RN.strandTy name,                        tyName = RN.strandTy name,
990                        state = ref [],                        state = ref [],
991                        output = ref NONE,                        output = ref NONE,
992                        code = ref []                        code = ref [],
993                                                             init_code = ref (CL.D_Comment(["no init code"]))
994                      }                      }
995                in                in
996                  AtomTable.insert strands (strandId, strand);                  AtomTable.insert strands (strandId, strand);
# Line 940  Line 1003 
1003        (* register the strand-state initialization code.  The variables are the strand        (* register the strand-state initialization code.  The variables are the strand
1004         * parameters.         * parameters.
1005         *)         *)
1006          fun init (Strand{name, tyName, code, ...}, params, init) = let          fun init (Strand{name, tyName, code,init_code, ...}, params, init) = let
1007                val fName = RN.strandInit name                val fName = RN.strandInit name
1008                val params =                val params =
1009                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
1010                        List.map (fn (ToC.V(ty, x)) => CL.PARAM([], ty, x)) params                        List.map (fn (ToC.V(ty, x)) => CL.PARAM([], ty, x)) params
1011                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)
1012                in                in
1013                  code := initFn :: !code                          init_code := initFn
1014                end                end
1015    
1016        (* register a strand method *)        (* register a strand method *)

Legend:
Removed from v.1270  
changed lines
  Added in v.1271

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