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 1358, Tue Jun 21 17:38:56 2011 UTC revision 1457, Fri Aug 5 07:23:07 2011 UTC
# Line 17  Line 17 
17    
18    (* translate TreeIL types to shadow types *)    (* translate TreeIL types to shadow types *)
19      fun shadowTy ty = (case ty      fun shadowTy ty = (case ty
20             of Ty.BoolTy => CLang.T_Named "cl_bool"             of Ty.BoolTy => CL.T_Named "cl_bool"
21              | Ty.StringTy => raise Fail "unexpected string type"              | Ty.StringTy => raise Fail "unexpected string type"
22              | Ty.IVecTy 1 => CL.T_Named(RN.shadowIntTy ())              | Ty.IVecTy 1 => CL.T_Named(RN.shadowIntTy ())
23              | Ty.IVecTy n => raise Fail "unexpected int vector type"              | Ty.IVecTy n => raise Fail "unexpected int vector type"
# Line 28  Line 28 
28              | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])              | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])
29            (* end case *))            (* end case *))
30    
31       (* translate TreeIL types to shadow types *)
32        fun convertToShadow (ty, name) = (case ty
33               of Ty.IVecTy 1 => CL.mkAssign(
34                    CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
35                    CL.mkIndirect(CL.mkVar(RN.globalsVarName), name))
36                | Ty.TensorTy[n]=> CL.mkCall(RN.convertToShadowVec n, [
37                      CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
38                      CL.mkIndirect(CL.mkVar(RN.globalsVarName), name)
39                    ])
40                | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.mkCall(RN.shadowImageFunc dim, [
41                      CL.mkVar "context",
42                      CL.mkUnOp(CL.%&,CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name)),
43                      CL.mkIndirect(CL.mkVar(RN.globalsVarName),name)
44                    ])
45                | Ty.TensorTy[n, m] => CL.mkCall(RN.convertToShadowMat(m,n), [
46                      CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
47                      CL.mkIndirect(CL.mkVar(RN.globalsVarName), name)
48                    ])
49                | _ => CL.mkAssign(
50                    CL.mkSelect(CL.mkVar(RN.shadowGlaobalsName),name),
51                    CL.mkIndirect(CL.mkVar(RN.globalsVarName), name))
52              (* end case *))
53    
54    (* helper functions for specifying parameters in various address spaces *)    (* helper functions for specifying parameters in various address spaces *)
55      fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)      fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)
56      fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)      fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)
# Line 35  Line 58 
58      fun localParam (ty, x) = CL.PARAM(["__local"], ty, x)      fun localParam (ty, x) = CL.PARAM(["__local"], ty, x)
59      fun privateParam (ty, x) = CL.PARAM(["__private"], ty, x)      fun privateParam (ty, x) = CL.PARAM(["__private"], ty, x)
60    
61      (* OpenCL global pointer type *)
62        fun globalPtr ty = CL.T_Qual("__global", CL.T_Ptr ty)
63    
64    (* C variable translation *)    (* C variable translation *)
65      structure TrCVar =      structure TrCVar =
66        struct        struct
# Line 76  Line 102 
102    
103    (* variable or field that is mirrored between host and GPU *)    (* variable or field that is mirrored between host and GPU *)
104      type mirror_var = {      type mirror_var = {
105    (* FIXME: perhaps it would be cleaner to just track the TreeIL type of the variable? *)
106              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)              hostTy : CL.ty,             (* variable type on Host (i.e., C type) *)
107              shadowTy : CL.ty,           (* host-side shadow type of GPU type *)              shadowTy : CL.ty,           (* host-side shadow type of GPU type *)
108              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)              gpuTy : CL.ty,              (* variable's type on GPU (i.e., OpenCL type) *)
109                hToS: stm,                  (* the statement that converts the variable to its *)
110                                            (* shadow representation *)
111              var : CL.var                (* variable name *)              var : CL.var                (* variable name *)
112            }            }
113    
# Line 120  Line 149 
149        | GlobalScope        | GlobalScope
150        | InitiallyScope        | InitiallyScope
151        | StrandScope of TreeIL.var list  (* strand initialization *)        | StrandScope of TreeIL.var list  (* strand initialization *)
152        | MethodScope of TreeIL.var list  (* method body; vars are state variables *)        | MethodScope of MethodName.name * TreeIL.var list  (* method body; vars are state variables *)
153    
154    (* the supprted widths of vectors of reals on the target. *)    (* the supprted widths of vectors of reals on the target. *)
155  (* FIXME: for OpenCL 1.1, 3 is also valid *)  (* FIXME: for OpenCL 1.1, 3 is also valid *)
# Line 157  Line 186 
186  (* NOTE: if we move strand initialization to the GPU, then we'll have to change the following code! *)  (* NOTE: if we move strand initialization to the GPU, then we'll have to change the following code! *)
187                   of StrandScope stateVars =>                   of StrandScope stateVars =>
188                        ToCL.trBlock (vMap, saveState "StrandScope" stateVars ToCL.trAssign, blk)                        ToCL.trBlock (vMap, saveState "StrandScope" stateVars ToCL.trAssign, blk)
189                    | MethodScope stateVars =>                    | MethodScope(name, stateVars) =>
190                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)
191                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)
192                    | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)
# Line 173  Line 202 
202                  hostTy = ToC.trType ty,                  hostTy = ToC.trType ty,
203                  shadowTy = shadowTy ty,                  shadowTy = shadowTy ty,
204                  gpuTy = ToCL.trType ty,                  gpuTy = ToCL.trType ty,
205                    hToS = convertToShadow(ty,name),
206                  var = name                  var = name
207                }                }
208          fun name (ToCL.V(_, name)) = name          fun name (ToCL.V(_, name)) = name
# Line 210  Line 240 
240          val scopeGlobal = setScope GlobalScope          val scopeGlobal = setScope GlobalScope
241          val scopeInitially = setScope InitiallyScope          val scopeInitially = setScope InitiallyScope
242          fun scopeStrand (env, svars) = setScope (StrandScope svars) env          fun scopeStrand (env, svars) = setScope (StrandScope svars) env
243          fun scopeMethod (env, svars) = setScope (MethodScope svars) env          fun scopeMethod (env, name, svars) = setScope (MethodScope(name, svars)) env
244        (* bind a TreeIL varaiable to a target variable *)        (* bind a TreeIL varaiable to a target variable *)
245          fun bind (ENV{info, vMap, scope}, x, x') = ENV{          fun bind (ENV{info, vMap, scope}, x, x') = ENV{
246                  info = info,                  info = info,
# Line 309  Line 339 
339                              CL.E_Var "size"                              CL.E_Var "size"
340                            ]))))                            ]))))
341                      ]                      ]
             (* create the loop nest for the initially iterations  
               val indexVar = "ix"  
               val strandTy = CL.T_Ptr(CL.T_Named(N.strandTy name))  
               fun mkLoopNest [] = CL.mkBlock(createPrefix @ [  
                       CL.mkDecl(strandTy, "sp",  
                         SOME(CL.I_Exp(  
                           CL.E_Cast(strandTy,  
                           CL.E_Apply(N.inState, [CL.E_Var "wrld", CL.E_Var indexVar]))))),  
                       CL.mkCall(N.strandInit name,  
                         CL.E_Var RN.globalsVarName :: CL.E_Var "sp" :: args),  
                       CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))  
                     ])  
                 | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let  
                     val body = mkLoopNest iters  
                     in  
                       CL.mkFor(  
                         [(ty, param, lo)],  
                         CL.mkBinOp(CL.E_Var param, CL.#<=, hi),  
                         [CL.mkPostOp(CL.E_Var param, CL.^++)],  
                         body)  
                     end  
               val iterCode = [  
                       CL.mkComment["initially"],  
                       CL.mkDecl(CL.uint32, indexVar, SOME(CL.I_Exp(CL.E_Int(0, CL.uint32)))),  
                       mkLoopNest iters  
                     ] *)  
342                val body = CL.mkBlock(                val body = CL.mkBlock(
343                      iterPrefix @                      iterPrefix @
344                      allocCode @                      allocCode @
# Line 346  Line 350 
350                end                end
351    
352        (***** OUTPUT *****)        (***** OUTPUT *****)
353    (* FIXME: I think that the iteration and test for stable strands can be moved into the runtime, which
354     * will make the print function compatible with the C target version.
355     *)
356          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let          fun genStrandPrint (Strand{name, tyName, state, output, code,...}) = let
357              (* the print function *)              (* the print function *)
358                val prFnName = concat[name, "_print"]                val prFnName = concat[name, "Print"]
359                val prFn = let                val prFn = let
360                      val params = [                      val params = [
361                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),                              CL.PARAM([], CL.T_Ptr(CL.T_Named "FILE"), "outS"),
                             CL.PARAM([], CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)),"status"),  
                             CL.PARAM([], CL.intTy,"numStrands"),  
362                              CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")                              CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")
363                            ]                            ]
364                      val SOME(ty, x) = !output                      val SOME(ty, x) = !output
365                      val outState = CL.mkSelect(CL.mkSubscript(CL.mkVar "self", CL.E_Var "i"), x)                      val outState = CL.mkIndirect(CL.mkVar "self", x)
366                      val prArgs = (case ty                      val prArgs = (case ty
367                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]                             of Ty.IVecTy 1 => [CL.E_Str(!N.gIntFormat ^ "\n"), outState]
368                              | Ty.IVecTy d => let                              | Ty.IVecTy d => let
369                                    fun sel i = CL.mkSubscript(CL.mkSelect(outState, "s"),
370                                          CL.mkInt(IntInf.fromInt i))
371                                  val fmt = CL.mkStr(                                  val fmt = CL.mkStr(
372                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))                                        String.concatWith " " (List.tabulate(d, fn _ => !N.gIntFormat))
373                                        ^ "\n")                                        ^ "\n")
374                                  val args = List.tabulate (d, fn i => ToC.ivecIndex(outState, d, i))                                  val args = List.tabulate (d, sel)
375                                  in                                  in
376                                    fmt :: args                                    fmt :: args
377                                  end                                  end
378                              | Ty.TensorTy[] => [CL.mkStr "%f\n", outState]                              | Ty.TensorTy[] => [CL.mkStr "%f\n", outState]
379                              | Ty.TensorTy[d] => let                              | Ty.TensorTy[d] => let
380                                    fun sel i = CL.mkSubscript(CL.mkSelect(outState, "s"),
381                                          CL.mkInt(IntInf.fromInt i))
382                                  val fmt = CL.mkStr(                                  val fmt = CL.mkStr(
383                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))                                        String.concatWith " " (List.tabulate(d, fn _ => "%f"))
384                                        ^ "\n")                                        ^ "\n")
385                                  val args = List.tabulate (d, fn i => ToC.vecIndex(outState, d, i))                                  val args = List.tabulate (d, sel)
386                                  in                                  in
387                                    fmt :: args                                    fmt :: args
388                                  end                                  end
389                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)                              | _ => raise Fail("genStrand: unsupported output type " ^ Ty.toString ty)
390                            (* end case *))                            (* end case *))
                     val forBody = CL.mkIfThen(  
                           CL.mkBinOp(CL.mkSubscript(CL.E_Var "status",CL.E_Var "i"), CL.#==, CL.E_Var "DIDEROT_STABILIZE"),  
                           CL.mkBlock([CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs)]))  
                     val body =  CL.mkFor(  
                         [(CL.intTy, "i", CL.mkInt 0)],  
                         CL.mkBinOp(CL.E_Var "i", CL.#<, CL.E_Var "numStrands"),  
                         [CL.mkPostOp(CL.E_Var "i", CL.^++)],  
                         forBody)  
391                      in                      in
392                        CL.D_Func(["static"], CL.voidTy, prFnName, params, body)                        CL.D_Func(["static"], CL.voidTy, prFnName, params,
393                            CL.mkCall("fprintf", CL.mkVar "outS" :: prArgs))
394                      end                      end
395                in                in
396                  prFn                  prFn
397                end                end
398    
399          fun genStrandTyDef (targetTy, Strand{tyName, state,...}) =          fun genStrandTyDef (targetTy, Strand{state,...},tyName) =
400              (* the type declaration for the strand's state struct *)              (* the type declaration for the strand's state struct *)
401                CL.D_StructDef(                CL.D_StructDef(
402                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),                  List.rev (List.map (fn x => (targetTy x, #var x)) (!state)),
403                  tyName)                  tyName)
404    
         fun genStrandCopy(Strand{tyName,name,state,...}) = let  
               val params = [  
                     CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),  
                     CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfOut")  
                   ]  
               val assignStms = List.rev(List.map(fn x => CL.mkAssign(CL.mkIndirect(CL.E_Var "selfOut", #var x),                                                                                                                          CL.mkIndirect(CL.E_Var "selfIn", #var x))) (!state))  
               in  
                 CL.D_Func([""], CL.voidTy, RN.strandCopy name, params,CL.mkBlock(assignStms))  
               end  
   
405        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
406          fun getGlobalDataBuffers (globals, contextVar, errVar) = let          fun getGlobalDataBuffers (globals, imgGlobals, contextVar, errVar) = let
407                val globalBuffErr = "error creating OpenCL global buffer"                val globalBuffErr = "error creating OpenCL global buffer\n"
408                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),
409                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),
410                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
411                  val shadowTypeDecl =
412                        CL.mkDecl(CL.T_Named(RN.shadowGlobalsTy), RN.shadowGlaobalsName, NONE)
413                  val globalToShadowStms = List.map (fn (x:mirror_var) => #hToS x ) globals
414                val globalBufferDecl = CL.mkDecl(clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)                val globalBufferDecl = CL.mkDecl(clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)
415                val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]),                val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]),
416                      CL.mkApply("clCreateBuffer", [                      CL.mkApply("clCreateBuffer", [
417                          CL.mkVar contextVar,                          CL.mkVar contextVar,
418                          CL.mkVar "CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR",                          CL.mkBinOp(CL.mkVar "CL_MEM_READ_ONLY", CL.#|, CL.mkVar "CL_MEM_COPY_HOST_PTR"),
419                          CL.mkSizeof(CL.T_Named RN.globalsTy),                          CL.mkSizeof(CL.T_Named RN.shadowGlobalsTy),
420                          CL.mkVar RN.globalsVarName,                          CL.mkUnOp(CL.%&,CL.mkVar RN.shadowGlaobalsName),
421                          CL.mkUnOp(CL.%&,CL.mkVar errVar)                          CL.mkUnOp(CL.%&,CL.mkVar errVar)
422                        ]))                        ]))
423                fun genDataBuffers ([],_,_,_) = []                fun genDataBuffers ([],_,_,_) = []
424                  | genDataBuffers ((var,nDims)::globals, contextVar, errVar,errFn) = let                  | genDataBuffers ((var,nDims)::globals, contextVar, errVar,errFn) = let
425                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)
426  (* FIXME: use CL constructors to build expressions (not strings) *)                      val size = CL.mkIndirect(hostVar, "dataSzb")
                     fun sizeExp i = CL.mkSubscript(CL.mkIndirect(hostVar, "size"), CL.mkInt i)  
 (* FIXME: there is no reason that images have to be restricted to float elements! *)  
                     val size = CL.mkBinOp(CL.mkSizeof(CL.float), CL.#*, sizeExp 0)  
                     val size = if (nDims > 1)  
                           then CL.mkBinOp(size, CL.#*, sizeExp 1)  
                           else size  
                     val size = if (nDims > 2)  
                           then CL.mkBinOp(size, CL.#*, sizeExp 2)  
                           else size  
427                      in                      in
                       CL.mkDecl(clMemoryTy, RN.addBufferSuffix var ,NONE)::  
428                        CL.mkDecl(clMemoryTy, RN.addBufferSuffixData var ,NONE)::                        CL.mkDecl(clMemoryTy, RN.addBufferSuffixData var ,NONE)::
                       CL.mkAssign(CL.mkVar(RN.addBufferSuffix var),  
                         CL.mkApply("clCreateBuffer", [  
                             CL.mkVar contextVar,  
                             CL.mkVar "CL_MEM_COPY_HOST_PTR",  
                             CL.mkSizeof(CL.T_Named(RN.imageTy nDims)),  
                             hostVar,  
                             CL.mkUnOp(CL.%&,CL.mkVar errVar)  
                           ])) ::  
                       errFn(concat["error in creating ",RN.addBufferSuffix var, " global buffer"]) ::  
429                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),
430                          CL.mkApply("clCreateBuffer", [                          CL.mkApply("clCreateBuffer", [
431                              CL.mkVar contextVar,                              CL.mkVar contextVar,
432                              CL.mkVar "CL_MEM_COPY_HOST_PTR",                              CL.mkVar "CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR",
433                              size,                              size,
434                              CL.mkIndirect(hostVar, "data"),                              CL.mkIndirect(hostVar, "data"),
435                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
436                            ])) ::                            ])) ::
437                          errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer"]) ::                          errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer\n"]) ::
438                          genDataBuffers(globals,contextVar,errVar,errFn)                          genDataBuffers(globals,contextVar,errVar,errFn)
439                      end                      end
440                in                in
441                  globalBufferDecl                  [shadowTypeDecl] @ globalToShadowStms
442                  :: globalBuffer                  @ [globalBufferDecl, globalBuffer,errorFn(globalBuffErr)]
443                  :: errorFn(globalBuffErr)                  @ genDataBuffers(imgGlobals,contextVar,errVar,errorFn)
                 :: genDataBuffers(globals,contextVar,errVar,errorFn)  
444                end                end
445    
446        (* generates the kernel arguments for the image data *)        (* generates the kernel arguments for the image data *)
447          fun genGlobalArguments (globals, count, kernelVar, errVar) = let          fun genGlobalArguments (globals, count, kernelVar, errVar) = let
448                val globalArgErr = "error creating OpenCL global argument"                val globalArgErr = "error creating OpenCL global argument\n"
449                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),                fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),
450                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),                      CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),
451                      CL.mkCall("exit",[CL.mkInt 1])]))                      CL.mkCall("exit",[CL.mkInt 1])]))
452                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.&=,
453                      CL.mkApply("clSetKernelArg",                      CL.mkApply("clSetKernelArg",
454                        [CL.mkVar kernelVar,                        [CL.mkVar kernelVar,
455                         CL.mkPostOp(CL.E_Var count, CL.^++),                         CL.mkPostOp(CL.E_Var count, CL.^++),
# Line 487  Line 462 
462                          [CL.mkVar kernelVar,                          [CL.mkVar kernelVar,
463                           CL.mkPostOp(CL.E_Var count, CL.^++),                           CL.mkPostOp(CL.E_Var count, CL.^++),
464                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
                          CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffix var))]))) ::  
                          errFn(concat["error in creating ",RN.addBufferSuffix var, " argument"]) ::  
                     CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.$=,  
                       CL.mkApply("clSetKernelArg",  
                         [CL.mkVar kernelVar,  
                          CL.mkPostOp(CL.E_Var count, CL.^++),  
                          CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),  
465                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::
466                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument"]) ::                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument\n"]) ::
467                      genDataArguments (globals,count,kernelVar,errVar,errFn)                      genDataArguments (globals,count,kernelVar,errVar,errFn)
468                in                in
469                 [globalArgument,errorFn(globalArgErr)] @ genDataArguments(globals, count, kernelVar, errVar,errorFn)                  globalArgument :: errorFn globalArgErr ::
470                      genDataArguments(globals, count, kernelVar, errVar,errorFn)
471                end                end
472    
473        (* generates the globals buffers and arguments function *)        (* generates the globals buffers and arguments function *)
474          fun genGlobalBuffersArgs imgGlobals = let          fun genGlobalBuffersArgs (globals,imgGlobals) = let
475              (* Delcare opencl setup objects *)              (* Delcare opencl setup objects *)
476                val errVar = "err"                val errVar = "err"
477                val imgDataSizeVar = "image_dataSize"                val imgDataSizeVar = "image_dataSize"
# Line 512  Line 481 
481                        CL.PARAM([],CL.T_Named("cl_command_queue"), "cmdQ"),                        CL.PARAM([],CL.T_Named("cl_command_queue"), "cmdQ"),
482                        CL.PARAM([],CL.T_Named("int"), "argStart")                        CL.PARAM([],CL.T_Named("int"), "argStart")
483                      ]                      ]
484                val clGlobalBuffers = getGlobalDataBuffers(!imgGlobals, "context", errVar)                val clGlobalBuffers = getGlobalDataBuffers(globals,!imgGlobals, "context", errVar)
485                val clGlobalArguments = genGlobalArguments(!imgGlobals, "argStart", "kernel", errVar)                val clGlobalArguments = genGlobalArguments(!imgGlobals, "argStart", "kernel", errVar)
486              (* Body put all the statments together *)              (* Body put all the statments together *)
487                val body = CL.mkDecl(clIntTy, errVar, SOME(CL.I_Exp(CL.mkInt 0)))                val body = CL.mkDecl(clIntTy, errVar, SOME(CL.I_Exp(CL.mkInt 0)))
# Line 523  Line 492 
492    
493        (* generate the data and global parameters *)        (* generate the data and global parameters *)
494          fun genKeneralGlobalParams ((name,tyname)::rest) =          fun genKeneralGlobalParams ((name,tyname)::rest) =
               globalParam (CL.T_Ptr(CL.T_Named (RN.imageTy tyname)), RN.addBufferSuffix name) ::  
495                globalParam (CL.T_Ptr(CL.voidTy), RN.addBufferSuffixData name) ::                globalParam (CL.T_Ptr(CL.voidTy), RN.addBufferSuffixData name) ::
496                genKeneralGlobalParams rest                genKeneralGlobalParams rest
497            | genKeneralGlobalParams [] = []            | genKeneralGlobalParams [] = []
498    
       (*generate code for intilizing kernel global data *)  
 (* FIXME: should use List.map here *)  
         fun initGlobalImages ((name, tyname)::rest) =  
               CL.mkAssign(  
                 CL.mkIndirect(CL.E_Var RN.globalsVarName, name),  
                 CL.mkVar (RN.addBufferSuffix name)) ::  
               CL.mkAssign(  
                 CL.mkIndirect(CL.mkIndirect(CL.E_Var RN.globalsVarName, name), "data"),  
                 CL.mkVar (RN.addBufferSuffixData name)) ::  
               initGlobalImages rest  
           | initGlobalImages [] = []  
   
499        (* generate the main kernel function for the .cl file *)        (* generate the main kernel function for the .cl file *)
500          fun genKernelFun (strand, nDims, globals, imgGlobals) = let          fun genKernelFun (strand, nDims, globals, imgGlobals) = let
501                val Strand{name, tyName, state, output, code,...} = strand                val Strand{name, tyName, state, output, code,...} = strand
# Line 547  Line 503 
503                val inState = "strand_in"                val inState = "strand_in"
504                val outState = "strand_out"                val outState = "strand_out"
505                val tempVar = "tmp"                val tempVar = "tmp"
506                  val localPoolNextStrand = "localPoolNextStrand"
507                  val localPoolStrandCount = "localPoolStrandCount"
508                  val sizeParams = if nDims = 1 then
509                            []
510                        else if nDims = 2 then
511                            [CL.PARAM([], CL.intTy, "width")]
512                        else
513                            [CL.PARAM([], CL.intTy, "width"),CL.PARAM([], CL.intTy, "height")]
514                val params = [                val params = [
515                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam(CL.T_Ptr(CL.T_Named tyName), "strands"),
516                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam(CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus"),
517                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Num(RawTypes.RT_UInt8)), "strandStatus"),                        globalParam(CL.T_Ptr(CL.intTy),RN.globalPoolName),
518                        CL.PARAM(["__global"], CL.intTy, "width"),                        clParam("",CL.intTy,"numStrands"),
519                        CL.PARAM(["__global"], globPtrTy, RN.globalsVarName)                        localParam(CL.T_Ptr(CL.T_Named RN.workerTy), "workers")] @
520                      ] @ genKeneralGlobalParams(!imgGlobals)                        sizeParams @
521                          [globalParam(globPtrTy, RN.globalsVarName)] @
522                          genKeneralGlobalParams(!imgGlobals)
523    
524    
525                val thread_ids = if nDims = 1                val thread_ids = if nDims = 1
526                        then [                        then [
527                            CL.mkDecl(CL.intTy, "x",                            CL.mkDecl(CL.intTy, "globalId_x",
528                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0]))))                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),
529                              CL.mkDecl(CL.intTy, "localId_x",
530                                SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0])))),
531                              CL.mkDecl(CL.intTy, "local_size",
532                                SOME(CL.I_Exp(CL.mkApply(RN.getLocalSize,[CL.mkInt 0])))),
533                              CL.mkDecl(CL.intTy, "index",
534                                SOME(CL.I_Exp(CL.mkVar "localId_x"))),
535                              CL.mkDecl(CL.intTy, "globalIndex",
536                                SOME(CL.I_Exp(CL.mkVar "globalId_x")))
537                          ]                          ]
538                      else if nDims = 2                      else if nDims = 2
539                        then [                        then [
540                            CL.mkDecl(CL.intTy, "x",                            CL.mkDecl(CL.intTy, "globalId_x",
541                                SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),
542                              CL.mkDecl(CL.intTy, "localId_x",
543                                SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0])))),
544                              CL.mkDecl(CL.intTy, "globalId_y",
545                                SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1])))),
546                              CL.mkDecl(CL.intTy, "localId_y",
547                                SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 1])))),
548                              CL.mkDecl(CL.intTy, "local_size",
549                                SOME(CL.I_Exp(CL.mkBinOp(CL.mkApply(RN.getLocalSize,[CL.mkInt 0]),CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 1]))))),
550                              CL.mkDecl(CL.intTy, "index",
551                                SOME(CL.I_Exp(CL.mkBinOp(CL.mkBinOp(CL.mkVar "localId_y",CL.#*, CL.mkApply(RN.getLocalSize,[CL.mkInt 1])),CL.#+,CL.mkVar "localId_x")))),
552                              CL.mkDecl(CL.intTy, "globalIndex",
553                                SOME(CL.I_Exp(CL.mkBinOp(CL.mkBinOp(CL.mkVar "globalId_y",CL.#*, CL.mkVar "width"),CL.#+,CL.mkVar "globalId_x"))))
554                            ]
555                          else [
556                              CL.mkDecl(CL.intTy, "globalId_x",
557                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),
558                            CL.mkDecl(CL.intTy, "y",                            CL.mkDecl(CL.intTy, "globalId_y",
559                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1]))))                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1])))),
560                              CL.mkDecl(CL.intTy, "globalId_z",
561                                SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 2])))),
562                              CL.mkDecl(CL.intTy, "localId_x",
563                                SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 0])))),
564                              CL.mkDecl(CL.intTy, "localId_y",
565                                SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 1])))),
566                              CL.mkDecl(CL.intTy, "localId_z",
567                                SOME(CL.I_Exp(CL.mkApply(RN.getLocalThreadId,[CL.mkInt 2]))))
568                          ]                          ]
569                      else raise Fail "nDims > 2"  
570                val strandDecl = [                val strandDecl = [
571                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), inState, NONE),                        CL.mkDecl(CL.T_Named tyName, "in", NONE),
572                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), outState, NONE),                        CL.mkDecl(CL.T_Named tyName, "out", NONE),
573                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), tempVar, NONE)                        CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), inState, SOME(CL.I_Exp(CL.mkUnOp(CL.%&,CL.mkVar "in")))),
574                          CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), outState, SOME(CL.I_Exp(CL.mkUnOp(CL.%&,CL.mkVar "out")))),
575                          CL.mkDecl(CL.T_Ptr(CL.T_Named tyName), tempVar, NONE)
576                      ]                      ]
577                val barrierCode = CL.mkCall(RN.strandCopy name, [CL.E_Var outState, CL.E_Var inState])                val imageDataDecl = CL.mkDecl(CL.T_Named(RN.imageDataType),RN.globalImageDataName,NONE)
578                val barrierStm = CL.mkCall("barrier",[CL.E_Var "CLK_LOCAL_MEM_FENCE"])                val imageDataStms = List.map (fn (x,_) =>
579                      CL.mkAssign(CL.mkSelect(CL.mkVar(RN.globalImageDataName),RN.imageDataName x),
580                                  CL.mkVar(RN.addBufferSuffixData x))) (!imgGlobals)
581    
582                val args = (case nDims
583                         of 1 => [CL.mkVar "globalId_x"]
584                          | 2 => [CL.mkVar "globalId_x", CL.mkVar "globalId_y"]
585                          | 3 => [CL.mkVar "globalId_x", CL.mkVar "globalId_y", CL.mkVar "globalId_z"]
586                        (* end case *))
587    
588                val barrierCode = CL.mkIfThen(CL.mkBinOp(CL.mkVar "globalIndex" ,CL.#<=,CL.mkVar "numStrands"),
589                                     CL.mkBlock ([CL.mkCall (RN.strandInit name,
590                                                             CL.mkVar RN.globalsVarName :: CL.mkBinOp(CL.mkVar "strands", CL.#+, CL.mkVar "globalIndex") :: args)]))
591    
592               fun workerField (index,field) = CL.mkSelect(CL.mkSubscript(CL.mkVar "workers", CL.mkVar index),field)
593               fun barrierStm flags = CL.mkCall(RN.barrier,flags)
594    
595                  val barrierLocalStm = CL.mkCall(RN.barrier,[CL.E_Var "CLK_LOCAL_MEM_FENCE"])
596                  val barrierGlobalStm = CL.mkCall(RN.barrier,[CL.E_Var "CLK_GLOBAL_MEM_FENCE"])
597    
598                val index = if nDims = 1 then                val index = if nDims = 1 then
599                          CL.mkStr "x"                          CL.mkVar "x"
600                      else                      else if nDims = 2 then
601                          CL.mkBinOp(                          CL.mkBinOp(
602                              CL.mkBinOp(CL.mkVar "x", CL.#*, CL.mkVar "width"), CL.#+, CL.mkVar "y")                              CL.mkBinOp(CL.mkVar "y", CL.#*, CL.mkVar "width"), CL.#+, CL.mkVar "x")
603                        else
604                val strandObjects =                         CL.mkBinOp(CL.mkBinOp(CL.mkBinOp(
605                       [ CL.mkAssign(CL.mkVar inState,  CL.mkBinOp(CL.mkVar "selfIn",CL.#+,index)),                              CL.mkBinOp(CL.mkVar "z", CL.#*, CL.mkVar "width"),CL.#*, CL.mkVar "height"), CL.#+,
606                         CL.mkAssign(CL.mkVar outState, CL.mkBinOp(CL.mkVar "selfOut",CL.#+,index))                              CL.mkBinOp(CL.mkVar "y",CL.#*,CL.mkVar "height")),CL.#+,CL.mkVar "x")
607    
608                  val initCode = [
609                          CL.mkAttrDecl(["__local", "volatile"], CL.intTy, "localPoolNextStrand", NONE),
610                          CL.mkAttrDecl(["__local", "volatile"], CL.intTy, "localPoolStrandCount", NONE),
611                          CL.mkAttrDecl(["__local", "volatile"], CL.intTy, "idle_workers", NONE),
612                          CL.mkAssign(workerField("index","status"),CL.mkVar "WORKER_IDLE"),
613                          CL.mkAssign(CL.mkVar localPoolNextStrand , CL.mkInt 0),
614                          CL.mkAssign(CL.mkVar localPoolStrandCount , CL.mkInt 0),
615                          barrierStm([CL.mkVar "CLK_LOCAL_MEM_FENCE"])
616                       ]                       ]
617    
618                  val stabalizeStm = CL.mkAssign(CL.mkSubscript(CL.mkVar "strandStatus",index),                val status = [CL.mkDecl(CL.intTy, "status", NONE), CL.mkDecl(CL.intTy, "numAvail", NONE)]
619                                                                          CL.E_Var "status")  
620                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkSubscript(CL.mkVar "strandStatus",index))))  
621                val strandInitStm = CL.mkCall(RN.strandInit name, [                (* NOTE ADD THIS LINE : localPoolStrandCount = (numAvail >= 0) ? B : abs(numAvail); *)
622                        CL.E_Var RN.globalsVarName,                val avaliableIf = CL.mkIfThenElse(CL.mkBinOp(CL.mkVar localPoolNextStrand, CL.#>, CL.mkVar "numStrands"),
623                        CL.E_Var outState,                                                  CL.mkBlock([CL.mkAssign(CL.mkVar localPoolStrandCount, CL.mkInt 0)]),
624                        CL.E_Var "x",                                                  CL.mkBlock([CL.mkAssign(CL.mkVar "numAvail", CL.mkBinOp(CL.mkVar "numStrands", CL.#-, CL.mkBinOp(CL.mkVar localPoolNextStrand, CL.#+, CL.mkVar "B")))]))
625  (* FIXME: if nDims = 1, then "y" is not defined! the arguments to this call should really come from  
626   * the initially code!                val poolCountIf = CL.mkIfThen(CL.mkBinOp(CL.mkBinOp(CL.mkVar localPoolStrandCount, CL.#==, CL.mkInt 0), CL.#&&,CL.mkBinOp(CL.mkVar localPoolNextStrand, CL.#<, CL.mkVar "numStrands")),
627   *)                                      CL.mkBlock([CL.mkAssign(CL.mkVar localPoolNextStrand, CL.mkApply(RN.cl_atom_add,[CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "globalPoolNextStrand",CL.mkInt 0)),
628                        CL.E_Var "y"])                                                                                                                       CL.mkVar "B"])), avaliableIf]))
629    
630    
631                 (* Refacotring from my previous work because what I originially had isn't correct. I tried it with my experiment test case with a bigger NDRange and it failed. Now I'm rethinking my
632                    approach
633    
634                  val forStablize = CL.mkFor([(CL.intTy,"idx",CL.mkInt 0)], CL.mkBinOp(CL.mkVar "idx", CL.#<, CL.mkVar "local_size"), [CL.mkPostOp(CL.mkVar "idx", CL.^++)],  *)
635    
636    
637                  val threadZeroBlock = CL.mkIfThen(CL.mkBinOp(CL.mkBinOp(CL.mkVar "localId_x", CL.#==, CL.mkInt 0), CL.#&&, CL.mkBinOp(CL.mkVar "localId_y", CL.#==, CL.mkInt 0)),
638                                        CL.mkBlock([poolCountIf]))
639    
640    
641    
642    
643    
644                val local_vars = thread_ids                val local_vars = thread_ids
645                      @ initGlobalImages(!imgGlobals)                      @ [imageDataDecl]
646                        @ imageDataStms
647                      @ strandDecl                      @ strandDecl
648                      @ strandObjects                      @ status
649                      @ [strandInitStm,status]                val while_exp = CL.mkBinOp(CL.mkVar "idle_workers",CL.#!=, CL.mkVar "local_size")
650                val while_exp = CL.mkBinOp(CL.mkVar "status",CL.#==, CL.mkVar RN.kActive)                val whileBody = CL.mkBlock ([
               val whileBody = CL.mkBlock ([barrierCode,barrierStm] @ [  
651                        CL.mkAssign(CL.mkVar "status",                        CL.mkAssign(CL.mkVar "status",
652                          CL.mkApply(RN.strandUpdate name,                          CL.mkApply(RN.strandUpdate name,
653                            [CL.mkVar inState, CL.mkVar outState,CL.E_Var RN.globalsVarName]))] )                            [CL.mkVar inState,
654                               CL.mkVar outState,
655                               CL.mkVar RN.globalsVarName,
656                               CL.mkVar RN.globalImageDataName]))])
657                val whileBlock = [CL.mkWhile(while_exp, whileBody)]                val whileBlock = [CL.mkWhile(while_exp, whileBody)]
658                val body = CL.mkBlock(local_vars @ whileBlock @ [stabalizeStm])                val body = CL.mkBlock(local_vars @ whileBlock)
659                in                in
660                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)                  CL.D_Func(["__kernel"], CL.voidTy, fName, params, body)
661                end                end
# Line 619  Line 667 
667                  CL.D_StructDef(globs, tyName)                  CL.D_StructDef(globs, tyName)
668                end                end
669    
670          (* generate a global structure type definition from the image data of the image globals *)
671            fun genImageDataStruct (imgGlobals, tyName) = let
672                  val globs = List.map
673                        (fn (x, _) => (globalPtr CL.voidTy, RN.imageDataName x))
674                          imgGlobals
675                  in
676                    CL.D_StructDef(globs, tyName)
677                  end
678    
679          fun genGlobals (declFn, targetTy, globals) = let          fun genGlobals (declFn, targetTy, globals) = let
680                fun doVar (x : mirror_var) = declFn (CL.D_Var([], targetTy x, #var x, NONE))                fun doVar (x : mirror_var) = declFn (CL.D_Var([], targetTy x, #var x, NONE))
681                in                in
# Line 633  Line 690 
690                      in                      in
691                        CL.I_Struct[                        CL.I_Struct[
692                            ("name", CL.I_Exp(CL.mkStr name)),                            ("name", CL.I_Exp(CL.mkStr name)),
693                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(N.strandTy name)))),                            ("stateSzb", CL.I_Exp(CL.mkSizeof(CL.T_Named(RN.strandTy name)))),
694  (*  (*
695                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),                            ("outputSzb", CL.I_Exp(CL.mkSizeof(ToC.trTy outTy))),
696  *)  *)
697                            ("update", fnPtr("update_method_t", "0")),                            ("update", fnPtr("update_method_t", "0")),
698                            ("print", fnPtr("print_method_cl_t", name ^ "_print"))                            ("print", fnPtr("print_method_t", name ^ "Print"))
699                          ]                          ]
700                      end                      end
701                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 684  Line 741 
741                      "#include \"Diderot/cl-diderot.h\""                      "#include \"Diderot/cl-diderot.h\""
742                    ]));                    ]));
743                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));                  clppDecl (genGlobalStruct (#gpuTy, !globals, RN.globalsTy));
744                  clppDecl (genStrandTyDef(#gpuTy, strand));                  clppDecl (genImageDataStruct(!imgGlobals,RN.imageDataType));
745                    clppDecl (genStrandTyDef(#gpuTy, strand,tyName));
746                  clppDecl  (!init_code);                  clppDecl  (!init_code);
                 clppDecl  (genStrandCopy(strand));  
747                  List.app clppDecl (!code);                  List.app clppDecl (!code);
748                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));                  clppDecl (genKernelFun (strand, !numDims, globals, imgGlobals));
749                (* Generate the Host C file *)                (* Generate the Host C file *)
# Line 703  Line 760 
760                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));                  cppDecl (genGlobalStruct (#shadowTy, !globals, RN.shadowGlobalsTy));
761  (* FIXME: does this really need to be a global? *)  (* FIXME: does this really need to be a global? *)
762                  cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));                  cppDecl (CL.D_Var(["static"], globPtrTy, RN.globalsVarName, NONE));
763                  cppDecl (genStrandTyDef (#hostTy, strand));                  cppDecl (genStrandTyDef (#shadowTy, strand, tyName));
764                  cppDecl (genStrandPrint strand);                  cppDecl (genStrandPrint strand);
765                  List.app cppDecl (List.rev (!topDecls));                  List.app cppDecl (List.rev (!topDecls));
766                  cppDecl (genGlobalBuffersArgs imgGlobals);                  cppDecl (genGlobalBuffersArgs (!globals,imgGlobals));
767                  List.app (fn strand => cppDecl (genStrandDesc strand)) strands;                  List.app (fn strand => cppDecl (genStrandDesc strand)) strands;
768                  genStrandTable (cppDecl, strands);                  genStrandTable (cppDecl, strands);
769                  cppDecl (!initially);                  cppDecl (!initially);
# Line 742  Line 799 
799                  RunCC.link (basename, ldOpts)                  RunCC.link (basename, ldOpts)
800                end                end
801    
802        end        end (* Program *)
803    
804    (* strands *)    (* strands *)
805      structure Strand =      structure Strand =
# Line 781  Line 838 
838    
839        (* register a strand method *)        (* register a strand method *)
840          fun method (Strand{name, tyName, code,...}, methName, body) = let          fun method (Strand{name, tyName, code,...}, methName, body) = let
841                val fName = concat[name, "_", methName]                val fName = concat[name, "_", MethodName.toString methName]
842                val params = [                val params = [
843                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),
844                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),
845                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName)                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName),
846                          CL.PARAM([],CL.T_Named(RN.imageDataType),RN.globalImageDataName)
847                      ]                      ]
848                val methFn = CL.D_Func([], CL.int32, fName, params, body)                val resTy = (case methName
849                         of MethodName.Update => CL.T_Named "StrandStatus_t"
850                          | MethodName.Stabilize => CL.voidTy
851                        (* end case *))
852                  val methFn = CL.D_Func([], resTy, fName, params, body)
853                in                in
854                  code := methFn :: !code                  code := methFn :: !code
855                end                end

Legend:
Removed from v.1358  
changed lines
  Added in v.1457

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