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 1462, Tue Aug 9 07:22:45 2011 UTC revision 1463, Tue Aug 9 12:48:06 2011 UTC
# Line 15  Line 15 
15      structure ToCL = TreeToCL      structure ToCL = TreeToCL
16      structure N = CNames      structure N = CNames
17    
18      (* revmap f l == List.rev(List.map f l) *)
19        fun revmap f = let
20              fun rmap ([], l) = l
21                | rmap (x::r, l) = rmap (r, f x :: l)
22              in
23                fn l => rmap (l, [])
24              end
25    
26      (* common arithmetic *)
27        fun #+# (a, b) = CL.mkBinOp(a, CL.#+, b)
28        fun #*# (a, b) = CL.mkBinOp(a, CL.#*, b)
29        infix 5 #+#
30        infix 6 #*#
31    
32    (* translate TreeIL types to shadow types *)    (* translate TreeIL types to shadow types *)
33      fun shadowTy ty = (case ty      fun shadowTy ty = (case ty
34             of Ty.BoolTy => CL.T_Named "cl_bool"             of Ty.BoolTy => CL.T_Named "cl_bool"
# Line 223  Line 237 
237                  hostTy = ToC.trType ty,                  hostTy = ToC.trType ty,
238                  shadowTy = shadowTy ty,                  shadowTy = shadowTy ty,
239                  gpuTy = ToCL.trType ty,                  gpuTy = ToCL.trType ty,
240                  hToS = if globalShadowEnv = shadowEnv then                  hToS = if globalShadowEnv = shadowEnv
241                            convertToShadow(ty,name)                    then convertToShadow(ty,name)
242                         else                    else convertStrandToShadow(ty,name,"selfIn", "selfOut"),
                           convertStrandToShadow(ty,name,"selfIn", "selfOut"),  
   
243                  var = name                  var = name
244                }                }
245          fun name (ToCL.V(_, name)) = name          fun name (ToCL.V(_, name)) = name
# Line 304  Line 316 
316    
317        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
318          fun init (Prog{topDecls, ...}, init) = let          fun init (Prog{topDecls, ...}, init) = let
319                val globalsDecl = CL.mkAssign(CL.E_Var RN.globalsVarName,                val globalsDecl = CL.mkAssign(CL.mkVar RN.globalsVarName,
320                      CL.mkApply("malloc", [CL.mkSizeof(CL.T_Named RN.globalsTy)]))                      CL.mkApply("malloc", [CL.mkSizeof(CL.T_Named RN.globalsTy)]))
321                val initFn = CL.D_Func(                val initFn = CL.D_Func(
322                      [], CL.voidTy, RN.initGlobals, [],                      [], CL.voidTy, RN.initGlobals, [],
# Line 346  Line 358 
358                val baseInit = mapi (fn (i, (_, e, _)) => (i, CL.I_Exp e)) iters                val baseInit = mapi (fn (i, (_, e, _)) => (i, CL.I_Exp e)) iters
359                val sizeInit = mapi                val sizeInit = mapi
360                      (fn (i, (CL.V(ty, _), lo, hi)) =>                      (fn (i, (CL.V(ty, _), lo, hi)) =>
361                          (i, CL.I_Exp(CL.mkBinOp(CL.mkBinOp(hi, CL.#-, lo), CL.#+, CL.E_Int(1, ty))))                          (i, CL.I_Exp(CL.mkBinOp(hi, CL.#-, lo) #+# CL.mkIntTy(1, ty)))
362                      ) iters                      ) iters
363              (* code to allocate the world and initial strands *)              (* code to allocate the world and initial strands *)
364                val wrld = "wrld"                val wrld = "wrld"
# Line 355  Line 367 
367                        CL.mkDecl(CL.T_Array(CL.int32, SOME nDims), "base", SOME(CL.I_Array baseInit)),                        CL.mkDecl(CL.T_Array(CL.int32, SOME nDims), "base", SOME(CL.I_Array baseInit)),
368                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "size", SOME(CL.I_Array sizeInit)),                        CL.mkDecl(CL.T_Array(CL.uint32, SOME nDims), "size", SOME(CL.I_Array sizeInit)),
369                        CL.mkDecl(worldTy, wrld,                        CL.mkDecl(worldTy, wrld,
370                          SOME(CL.I_Exp(CL.E_Apply(N.allocInitially, [                          SOME(CL.I_Exp(CL.mkApply(N.allocInitially, [
371                              CL.mkVar "ProgramName",                              CL.mkVar "ProgramName",
372                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),                              CL.mkUnOp(CL.%&, CL.mkVar(N.strandDesc name)),
373                              CL.E_Bool isArray,                              CL.mkBool isArray,
374                              CL.E_Int(IntInf.fromInt nDims, CL.int32),                              CL.mkIntTy(IntInf.fromInt nDims, CL.int32),
375                              CL.E_Var "base",                              CL.mkVar "base",
376                              CL.E_Var "size"                              CL.mkVar "size"
377                            ]))))                            ]))))
378                      ]                      ]
379              (* create the loop nest for the initially iterations *)              (* create the loop nest for the initially iterations *)
# Line 370  Line 382 
382                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [
383                        CL.mkDecl(strandTy, "sp",                        CL.mkDecl(strandTy, "sp",
384                          SOME(CL.I_Exp(                          SOME(CL.I_Exp(
385                            CL.E_Cast(strandTy,                            CL.mkCast(strandTy,
386                            CL.E_Apply(N.inState, [CL.E_Var "wrld", CL.mkBinOp(CL.mkVar indexVar, CL.#*, CL.mkSizeof(CL.T_Named (N.strandTy name)))]))))),                            CL.mkApply(N.inState, [
387                        CL.mkCall(N.strandInit name, CL.E_Var "sp" :: args),                                CL.mkVar "wrld",
388                        CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))                                CL.mkBinOp(CL.mkVar indexVar, CL.#*, CL.mkSizeof(CL.T_Named (N.strandTy name)))
389                                ]))))),
390                          CL.mkCall(N.strandInit name, CL.mkVar "sp" :: args),
391                          CL.mkAssign(CL.mkVar indexVar, CL.mkBinOp(CL.mkVar indexVar, CL.#+, CL.mkIntTy(1, CL.uint32)))
392                      ])                      ])
393                  | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let                  | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let
394                      val body = mkLoopNest iters                      val body = mkLoopNest iters
395                      in                      in
396                        CL.mkFor(                        CL.mkFor(
397                          [(ty, param, lo)],                          [(ty, param, lo)],
398                          CL.mkBinOp(CL.E_Var param, CL.#<=, hi),                          CL.mkBinOp(CL.mkVar param, CL.#<=, hi),
399                          [CL.mkPostOp(CL.E_Var param, CL.^++)],                          [CL.mkPostOp(CL.mkVar param, CL.^++)],
400                          body)                          body)
401                      end                      end
402                val iterCode = [                val iterCode = [
403                        CL.mkComment["initially"],                        CL.mkComment["initially"],
404                        CL.mkDecl(CL.uint32, indexVar, SOME(CL.I_Exp(CL.E_Int(0, CL.uint32)))),                        CL.mkDecl(CL.uint32, indexVar, SOME(CL.I_Exp(CL.mkIntTy(0, CL.uint32)))),
405                        mkLoopNest iters                        mkLoopNest iters
406                      ]                      ]
407                val body = CL.mkBlock(                val body = CL.mkBlock(
408                      iterPrefix @                      iterPrefix @
409                      allocCode @                      allocCode @
410                      iterCode @                      iterCode @
411                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])                      [CL.mkReturn(SOME(CL.mkVar "wrld"))])
412                val initFn = CL.D_Func([], worldTy, N.initially, [], body)                val initFn = CL.D_Func([], worldTy, N.initially, [], body)
413                in                in
414                  numDims := nDims;                  numDims := nDims;
# Line 407  Line 422 
422   *)   *)
423          fun genStrandPrint (Strand{name, tyName, state, output, code, ...}) = let          fun genStrandPrint (Strand{name, tyName, state, output, code, ...}) = let
424          (* the print function *)          (* the print function *)
425                val prFnName = concat[name, "_print"]                val prFnName = concat[name, "Print"]
426                val prFn = let                val prFn = let
427                      val params = [                      val params = [
428                            CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                            CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
# Line 416  Line 431 
431                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
432                      val outState = CL.mkIndirect(CL.mkVar "self", x)                      val outState = CL.mkIndirect(CL.mkVar "self", x)
433                      val prArgs = (case ty                      val prArgs = (case ty
434                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.mkStr(!N.gIntFormat ^ "\n"), outState]
435                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
436                                  val fmt = CL.E_Str(                                  fun sel i = CL.mkApply(
437                                          "VSUBP",
438                                          [outState, CL.mkInt(IntInf.fromInt i)])
439                                    val fmt = CL.mkStr(
440                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))
441                                        ^ "\n")                                        ^ "\n")
442                                  val args = List.tabulate (d, fn i => CL.mkApply("VSUBP",[outState, CL.mkInt (IntInf.fromInt i)] ))                                  val args = List.tabulate (d, sel)
443                                  in                                  in
444                                    fmt :: args                                    fmt :: args
445                                  end                                  end
446                              | Ty.TensorTy[] => [CL.E_Str "%f\n", outState]                              | Ty.TensorTy[] => [CL.mkStr "%f\n", outState]
447                              | Ty.TensorTy[d] => let                              | Ty.TensorTy[d] => let
448                                  val fmt = CL.E_Str(                                  fun sel i = CL.mkApply(
449                                            "VSUBP",
450                                            [outState, CL.mkInt(IntInf.fromInt i)])
451                                    val fmt = CL.mkStr(
452                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))
453                                        ^ "\n")                                        ^ "\n")
454                                  val args = List.tabulate (d, fn i => CL.mkApply("VSUBP",[outState, CL.mkInt (IntInf.fromInt i)]))                                  val args = List.tabulate (d, sel)
455                                  in                                  in
456                                    fmt :: args                                    fmt :: args
457                                  end                                  end
# Line 447  Line 468 
468          fun genStrandTyDef (targetTy, Strand{state,...},tyName) =          fun genStrandTyDef (targetTy, Strand{state,...},tyName) =
469              (* the type declaration for the strand's state struct *)              (* the type declaration for the strand's state struct *)
470                CL.D_StructDef(                CL.D_StructDef(
471                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  revmap (fn x => (targetTy x, #var x)) (!state),
472                  tyName)                  tyName)
473    
474       (* generates the globals buffers and arguments function *)       (* generates the globals buffers and arguments function *)
# Line 463  Line 484 
484                in                in
485                  CL.D_Func([],CL.voidTy,RN.strandConvertName,params,CL.mkBlock(body))                  CL.D_Func([],CL.voidTy,RN.strandConvertName,params,CL.mkBlock(body))
486                end                end
487    
488        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
489          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let
490                val globalBuffErr = "error creating OpenCL global buffer\n"                val globalBuffErr = "error creating OpenCL global buffer\n"
491                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.mkVar errVar, CL.#!=, CL.mkVar "CL_SUCCESS"),
492                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),                      CL.mkBlock([CL.mkCall("fprintf",[CL.mkVar "stderr", CL.mkStr msg]),
493                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
494                val shadowTypeDecl =                val shadowTypeDecl =
495                      CL.mkDecl(CL.T_Named(RN.shadowGlobalsTy), RN.shadowGlaobalsName, NONE)                      CL.mkDecl(CL.T_Named(RN.shadowGlobalsTy), RN.shadowGlaobalsName, NONE)
# Line 507  Line 529 
529        (* generates the kernel arguments for the image data *)        (* generates the kernel arguments for the image data *)
530          fun genGlobalArguments (globals, count, kernelVar, errVar) = let          fun genGlobalArguments (globals, count, kernelVar, errVar) = let
531                val globalArgErr = "error creating OpenCL global argument\n"                val globalArgErr = "error creating OpenCL global argument\n"
532                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.mkVar errVar, CL.#!=, CL.mkVar "CL_SUCCESS"),
533                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),                      CL.mkBlock([CL.mkCall("fprintf",[CL.mkVar "stderr", CL.mkStr msg]),
534                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
535                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.&=,                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.&=,
536                      CL.mkApply("clSetKernelArg",                      CL.mkApply("clSetKernelArg",
537                        [CL.mkVar kernelVar,                        [CL.mkVar kernelVar,
538                         CL.mkPostOp(CL.E_Var count, CL.^++),                         CL.mkPostOp(CL.mkVar count, CL.^++),
539                         CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                         CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
540                         CL.mkUnOp(CL.%&,CL.mkVar(concat[RN.globalsVarName,"_cl"]))])))                         CL.mkUnOp(CL.%&,CL.mkVar(concat[RN.globalsVarName,"_cl"]))])))
541                fun genDataArguments ([],_,_,_,_) = []                fun genDataArguments ([],_,_,_,_) = []
# Line 521  Line 543 
543                      CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.$=,                      CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.$=,
544                        CL.mkApply("clSetKernelArg",                        CL.mkApply("clSetKernelArg",
545                          [CL.mkVar kernelVar,                          [CL.mkVar kernelVar,
546                           CL.mkPostOp(CL.E_Var count, CL.^++),                           CL.mkPostOp(CL.mkVar count, CL.^++),
547                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
548                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::
549                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument\n"]) ::                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument\n"]) ::
# Line 564  Line 586 
586                val inState = "selfIn"                val inState = "selfIn"
587                val outState = "selfOut"                val outState = "selfOut"
588                val tempVar = "tmp"                val tempVar = "tmp"
589    (* FIXME: please add a comment to describe what is going on here *)
590                val (workerOffset,localOffset) = if nDims = 1 then                val (workerOffset, localOffset) = let
591                          ( CL.mkApply(RN.getGroupId,[CL.mkInt 0]), CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0]) )                      fun grpId i = CL.mkApply(RN.getGroupId, [CL.mkInt i])
592                         else if nDims = 2 then                      fun localId i = CL.mkApply(RN.getLocalThreadId, [CL.mkInt i])
593                       (CL.mkBinOp(CL.mkBinOp(CL.mkApply(RN.getGroupId,[CL.mkInt 0]),CL.#*, CL.mkApply(RN.getNumGroups,[CL.mkInt 1])),CL.#+,CL.mkApply(RN.getGroupId,[CL.mkInt 1])),                      fun localSz i = CL.mkApply(RN.getLocalSize, [CL.mkInt i])
594                              CL.mkBinOp(CL.mkBinOp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0]),CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 1])),CL.#+,CL.mkApply(RN.getLocalThreadId,[CL.mkInt 1])))                      fun numGrps i = CL.mkApply(RN.getNumGroups,[CL.mkInt i])
595                  else                      in
596                            ( CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(                        case nDims
597                              CL.mkBinOp(CL.mkApply(RN.getGroupId,[CL.mkInt 0]), CL.#*, CL.mkApply(RN.getNumGroups,[CL.mkInt 1])),CL.#*, CL.mkApply(RN.getNumGroups,[CL.mkInt 2])), CL.#+,                         of 1 => (grpId 0, localId 0)
598                              CL.mkBinOp(CL.mkApply(RN.getGroupId,[CL.mkInt 1]),CL.#*,CL.mkApply(RN.getNumGroups,[CL.mkInt 1]))),CL.#+,CL.mkApply(RN.getGroupId,[CL.mkInt 2])),                          | 2 => (
599                             CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(                              grpId 0 #*# numGrps 1 #+# grpId 1,
600                              CL.mkBinOp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0]), CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 1])),CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 2])), CL.#+,                              localId 0 #*# localSz 1 #+# localId 1
601                              CL.mkBinOp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 1]),CL.#*,CL.mkApply(RN.getLocalSize,[CL.mkInt 1]))),CL.#+,CL.mkApply(RN.getLocalThreadId,[CL.mkInt 2])) )                            )
602                            | 3 => (
603                                grpId 0 #*# numGrps 1 #*# numGrps 2 #+# grpId 1 #*# numGrps 1 #+# grpId 2,
604              val copyInStm =  List.rev(List.map(fn x => CL.mkAssign(CL.mkSelect(CL.mkVar "selfIn", #var x),                              localId 0 #*# localSz 1 #*# localSz 2 #+# localId 1 #*# localSz 1 #+# localId 2
605                                                                                                         CL.mkIndirect(CL.mkGrp(CL.mkBinOp(CL.mkVar "strands",CL.#+, CL.mkVar "strandIndex")), #var x))) (!state))                            )
606                            | _ => raise Fail "bogus number of dimensions"
607              val copyOutStm =  List.rev(List.map(fn x => CL.mkAssign(CL.mkIndirect(CL.mkGrp(CL.mkBinOp(CL.mkVar "strands",CL.#+, CL.mkVar "strandIndex")), #var x), CL.mkSelect(CL.mkVar "selfOut", #var x))) (!state))                        (* end case *)
608                        end
609                  val copyInStm =  revmap
610                        (fn x => CL.mkAssign(
611                            CL.mkSelect(CL.mkVar "selfIn", #var x),
612                            CL.mkIndirect(CL.mkVar "strands" #+# CL.mkVar "strandIndex", #var x)))
613                          (!state)
614                  val copyOutStm = revmap
615                        (fn x => CL.mkAssign(
616                            CL.mkIndirect(CL.mkVar "strands" #+# CL.mkVar "strandIndex", #var x),
617                            CL.mkSelect(CL.mkVar "selfOut", #var x)))
618                          (!state)
619              val params = [              val params = [
620                        globalParam(CL.T_Ptr(CL.T_Named tyName), "strands"),                        globalParam(CL.T_Ptr(CL.T_Named tyName), "strands"),
621                        globalParam(CL.T_Ptr(CL.intTy), "strandStatus"),                        globalParam(CL.T_Ptr(CL.intTy), "strandStatus"),
622                        globalParam(CL.T_Ptr(CL.intTy), "workQueue"),                        globalParam(CL.T_Ptr(CL.intTy), "workQueue"),
623                        globalParam(CL.T_Ptr(CL.intTy),"numAvail"),                        globalParam(CL.T_Ptr(CL.intTy),"numAvail"),
624                        clParam("",CL.intTy,"numStrands"),                        clParam("",CL.intTy,"numStrands"),
625                        clParam("",CL.intTy,"limit")] @                        clParam("",CL.intTy,"limit")
626                        ] @
627                        [globalParam(globPtrTy, RN.globalsVarName)] @                        [globalParam(globPtrTy, RN.globalsVarName)] @
628                        genKeneralGlobalParams(!imgGlobals)                        genKeneralGlobalParams(!imgGlobals)
   
629              val index_ids = [              val index_ids = [
630                            CL.mkDecl(CL.intTy, "workerIndex",                            CL.mkDecl(CL.intTy, "workerIndex",
631                              SOME(CL.I_Exp(workerOffset))),                              SOME(CL.I_Exp(workerOffset))),
632                            CL.mkDecl(CL.intTy, "strandIndex",                            CL.mkDecl(CL.intTy, "strandIndex",
633                              SOME(CL.I_Exp(CL.mkBinOp(CL.mkSubscript(CL.mkVar "workQueue",CL.mkVar "workerIndex"),CL.#+,CL.mkBinOp(localOffset,CL.#*,CL.mkVar "limit")))))                          SOME(CL.I_Exp(
634                              CL.mkSubscript(CL.mkVar "workQueue",CL.mkVar "workerIndex")
635                              #+#
636                              localOffset #*# CL.mkVar "limit")))
637                          ]                          ]
   
638              val strandDecl = [              val strandDecl = [
639                        CL.mkDecl(CL.T_Named tyName, "selfIn", NONE),                        CL.mkDecl(CL.T_Named tyName, "selfIn", NONE),
640                        CL.mkDecl(CL.T_Named tyName, "selfOut", NONE)                        CL.mkDecl(CL.T_Named tyName, "selfOut", NONE)
641                      ]                      ]
642                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)
643                val imageDataStms = List.map (fn (x,_) =>                val imageDataStms = List.map
644                    CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),                      (fn (x,_) =>  CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),
645                                CL.mkVar(RN.addBufferSuffixData x))) (!imgGlobals)                                  CL.mkVar(RN.addBufferSuffixData x)))
646                          (!imgGlobals)
647              val status = [CL.mkDecl(CL.intTy, "status", NONE)]              val status = [CL.mkDecl(CL.intTy, "status", NONE)]
   
   
648         val updateStm =  CL.mkAssign(CL.mkVar "status",         val updateStm =  CL.mkAssign(CL.mkVar "status",
649                          CL.mkApply(RN.strandUpdate name,                      CL.mkApply(RN.strandUpdate name, [
650                            [CL.mkUnOp(CL.%&,CL.mkVar inState),                           CL.mkUnOp(CL.%&,CL.mkVar inState),
651                             CL.mkUnOp(CL.%&,CL.mkVar outState),                             CL.mkUnOp(CL.%&,CL.mkVar outState),
652                             CL.mkVar RN.globalsVarName,                             CL.mkVar RN.globalsVarName,
653                             CL.mkVar RN.globalImageDataName]))                           CL.mkVar RN.globalImageDataName
654                          ]))
655         val statusIf = CL.mkIfThenElse(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kStabilize),                val statusIf = CL.mkIfThenElse(CL.mkBinOp(CL.mkVar "status", CL.#==, CL.mkVar RN.kStabilize),
656                      CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kStable)] @                        CL.mkBlock(
657                            CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kStable) ::
658                                  copyOutStm @                                  copyOutStm @
659                                  [CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])]),                                  [CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])]),
660                      CL.mkBlock([CL.mkIfThen(CL.mkBinOp(CL.E_Var "status", CL.#==, CL.E_Var RN.kDie),                        CL.mkBlock[
661                                  CL.mkBlock([CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kDie)] @                          CL.mkIfThen(CL.mkBinOp(CL.mkVar "status", CL.#==, CL.mkVar RN.kDie),
662                              CL.mkBlock(
663                                CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",CL.mkVar "strandIndex"),CL.mkVar RN.kDie) ::
664                                  copyOutStm @                                  copyOutStm @
665                                  [CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])]))]))                              [CL.mkCall(RN.atom_dec,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "numAvail",CL.mkInt 0))])]))])
   
666         val incStrand = CL.mkExpStm(CL.mkPostOp(CL.mkVar "strandIndex",CL.^++))         val incStrand = CL.mkExpStm(CL.mkPostOp(CL.mkVar "strandIndex",CL.^++))
667                  val forStablize = CL.mkFor(
668          val forStablize = CL.mkFor( [(CL.intTy,"idx",CL.mkInt 0)], CL.mkBinOp(CL.mkBinOp(CL.mkVar "idx", CL.#<, CL.mkVar "limit"),CL.#&&,                      [(CL.intTy,"idx",CL.mkInt 0)],
669                        CL.mkBinOp(
670                          CL.mkBinOp(CL.mkVar "idx", CL.#<, CL.mkVar "limit"),
671                          CL.#&&,
672                                                                       CL.mkBinOp(CL.mkVar "strandIndex", CL.#<, CL.mkVar "numStrands")),                                                                       CL.mkBinOp(CL.mkVar "strandIndex", CL.#<, CL.mkVar "numStrands")),
673                                         [CL.mkPostOp(CL.mkVar "idx", CL.^++)], CL.mkBlock(                      [CL.mkPostOp(CL.mkVar "idx", CL.^++)],
674                        CL.mkBlock(copyInStm @ [updateStm, statusIf, incStrand]))
                                          copyInStm @  
                                         [ updateStm,  
                                          statusIf,  
                                          incStrand  
                                        ]))  
   
675                val local_vars = index_ids                val local_vars = index_ids
676                      @ [imageDataDecl]                      @ [imageDataDecl]
677                      @ imageDataStms                      @ imageDataStms
678                      @ strandDecl                      @ strandDecl
679                      @ status                      @ status
   
680                val body = CL.mkBlock(local_vars @ [forStablize])                val body = CL.mkBlock(local_vars @ [forStablize])
681                in                in
682                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)
# Line 689  Line 719 
719  *)  *)
720                            ("update", fnPtr("update_method_t", "0")),                            ("update", fnPtr("update_method_t", "0")),
721                            ("strandCopy",  fnPtr("convert_method_t", "Diderot_Strand_Covert_To_Shadow")),                            ("strandCopy",  fnPtr("convert_method_t", "Diderot_Strand_Covert_To_Shadow")),
722                            ("print", fnPtr("print_method_t", name ^ "_print"))                            ("print", fnPtr("print_method_t", name ^ "Print"))
723                          ]                          ]
724                      end                      end
725                val desc = CL.D_Var([], CL.T_Named N.strandDescTy, N.strandDesc name, SOME descI)                val desc = CL.D_Var([], CL.T_Named N.strandDescTy, N.strandDesc name, SOME descI)
# Line 700  Line 730 
730        (* generate the table of strand descriptors *)        (* generate the table of strand descriptors *)
731          fun genStrandTable (declFn, strands) = let          fun genStrandTable (declFn, strands) = let
732                val nStrands = length strands                val nStrands = length strands
733                fun genInit (Strand{name, ...}) = CL.I_Exp(CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)))                fun genInit (Strand{name, ...}) = CL.I_Exp(CL.mkUnOp(CL.%&, CL.mkVar(N.strandDesc name)))
734                fun genInits (_, []) = []                fun genInits (_, []) = []
735                  | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)                  | genInits (i, s::ss) = (i, genInit s) :: genInits(i+1, ss)
736                in                in
737                  declFn (CL.D_Var([], CL.int32, N.numStrands,                  declFn (CL.D_Var([], CL.int32, N.numStrands,
738                    SOME(CL.I_Exp(CL.E_Int(IntInf.fromInt nStrands, CL.int32)))));                    SOME(CL.I_Exp(CL.mkIntTy(IntInf.fromInt nStrands, CL.int32)))));
739                  declFn (CL.D_Var([],                  declFn (CL.D_Var([],
740                    CL.T_Array(CL.T_Ptr(CL.T_Named N.strandDescTy), SOME nStrands),                    CL.T_Array(CL.T_Ptr(CL.T_Named N.strandDescTy), SOME nStrands),
741                    N.strands,                    N.strands,

Legend:
Removed from v.1462  
changed lines
  Added in v.1463

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