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 1321, Sun Jun 12 14:50:26 2011 UTC revision 1344, Tue Jun 14 16:18:09 2011 UTC
# Line 15  Line 15 
15      structure ToCL = TreeToCL      structure ToCL = TreeToCL
16      structure N = CNames      structure N = CNames
17    
18      (* helper functions for specifying parameters in various address spaces *)
19        fun clParam (spc, ty, x) = CL.PARAM([spc], ty, x)
20        fun globalParam (ty, x) = CL.PARAM(["__global"], ty, x)
21        fun constantParam (ty, x) = CL.PARAM(["__constant"], ty, x)
22        fun localParam (ty, x) = CL.PARAM(["__local"], ty, x)
23        fun privateParam (ty, x) = CL.PARAM(["__private"], ty, x)
24    
25    (* C variable translation *)    (* C variable translation *)
26      structure TrCVar =      structure TrCVar =
27        struct        struct
# Line 79  Line 86 
86          topDecls : CL.decl list ref,          topDecls : CL.decl list ref,
87          strands : strand AtomTable.hash_table,          strands : strand AtomTable.hash_table,
88          initially :  CL.decl ref,          initially :  CL.decl ref,
89          numDims: int ref,          numDims: int ref,               (* number of dimensions in initially iteration *)
90          imgGlobals: (string * int) list ref,          imgGlobals: (string * int) list ref,
91          prFn: CL.decl ref          prFn: CL.decl ref
92        }        }
# Line 135  Line 142 
142                  case scope                  case scope
143  (* 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! *)
144                   of StrandScope stateVars =>                   of StrandScope stateVars =>
145                        ToC.trBlock (vMap, saveState "StrandScope" stateVars ToC.trAssign, blk)                        ToCL.trBlock (vMap, saveState "StrandScope" stateVars ToC.trAssign, blk)
146                    | MethodScope stateVars =>                    | MethodScope stateVars =>
147                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)                        ToCL.trBlock (vMap, saveState "MethodScope" stateVars ToCL.trAssign, blk)
148                    | InitiallyScope => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | InitiallyScope => ToCL.trBlock (vMap, fn (_, _, stm) => [stm], blk)
149                    | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)                    | _ => ToC.trBlock (vMap, fn (_, _, stm) => [stm], blk)
150                  (* end case *)                  (* end case *)
151                end                end
# Line 205  Line 212 
212                    topDecls = ref [],                    topDecls = ref [],
213                    strands = AtomTable.mkTable (16, Fail "strand table"),                    strands = AtomTable.mkTable (16, Fail "strand table"),
214                    initially = ref(CL.D_Comment["missing initially"]),                    initially = ref(CL.D_Comment["missing initially"]),
215                    numDims = ref(0),                    numDims = ref 0,
216                    imgGlobals = ref[],                    imgGlobals = ref[],
217                    prFn = ref(CL.D_Comment(["No Print Function"]))                    prFn = ref(CL.D_Comment(["No Print Function"]))
218                  })                  })
# Line 235  Line 242 
242          fun init (Prog{topDecls, ...}, init) = let          fun init (Prog{topDecls, ...}, init) = let
243                                    val globalsDecl = CL.mkAssign(CL.E_Var RN.globalsVarName,                                    val globalsDecl = CL.mkAssign(CL.E_Var RN.globalsVarName,
244                      CL.mkApply("malloc", [CL.mkApply("sizeof",[CL.mkVar RN.globalsTy])]))                      CL.mkApply("malloc", [CL.mkApply("sizeof",[CL.mkVar RN.globalsTy])]))
   
245                val initGlobalsCall = CL.mkCall(RN.initGlobalsHelper,[])                val initGlobalsCall = CL.mkCall(RN.initGlobalsHelper,[])
   
246                                          val initFn = CL.D_Func(                                          val initFn = CL.D_Func(
247                      [], CL.voidTy, RN.initGlobals, [],                      [], CL.voidTy, RN.initGlobals, [],
248                      CL.mkBlock([globalsDecl,initGlobalsCall]))                      CL.mkBlock([globalsDecl,initGlobalsCall]))
# Line 253  Line 258 
258                end                end
259           (* create and register the initially function for a program *)           (* create and register the initially function for a program *)
260          fun initially {          fun initially {
261                prog = Prog{name=progName, strands, initially, ...},                prog = Prog{name=progName, strands, initially, numDims, ...},
262                isArray : bool,                isArray : bool,
263                iterPrefix : stm list,                iterPrefix : stm list,
264                iters : (var * exp * exp) list,                iters : (var * exp * exp) list,
# Line 282  Line 287 
287                        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)),
288                        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)),
289                        CL.mkDecl(worldTy, wrld,                        CL.mkDecl(worldTy, wrld,
290                          SOME(CL.I_Exp(CL.E_Apply(N.allocInitially, [                          SOME(CL.I_Exp(CL.E_Apply(RN.allocInitially, [
291                              CL.mkVar "ProgramName",                              CL.mkVar "ProgramName",
292                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),                              CL.mkUnOp(CL.%&, CL.E_Var(N.strandDesc name)),
293                                CL.mkApply("sizeof",[CL.E_Var (N.strandTy name)]),
294                              CL.E_Bool isArray,                              CL.E_Bool isArray,
295                              CL.E_Int(IntInf.fromInt nDims, CL.int32),                              CL.E_Int(IntInf.fromInt nDims, CL.int32),
296                              CL.E_Var "base",                              CL.E_Var "base",
# Line 323  Line 329 
329                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])                      [CL.mkReturn(SOME(CL.E_Var "wrld"))])
330                val initFn = CL.D_Func([], worldTy, N.initially, [], body)                val initFn = CL.D_Func([], worldTy, N.initially, [], body)
331                in                in
332                    numDims := nDims;
333                  initially := initFn                  initially := initFn
334                end                end
335    
# Line 376  Line 383 
383    
384        (* generates the opencl buffers for the image data *)        (* generates the opencl buffers for the image data *)
385          fun getGlobalDataBuffers (globals,contextVar,errVar) = let          fun getGlobalDataBuffers (globals,contextVar,errVar) = let
386                  val globalBuffErr = "error creating OpenCL global buffer"
387                  fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),
388                        CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),
389                        CL.mkCall("exit",[CL.mkInt 1])]))
390                val globalBufferDecl =  CL.mkDecl(clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)                val globalBufferDecl =  CL.mkDecl(clMemoryTy,concat[RN.globalsVarName,"_cl"],NONE)
391                val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]),                val globalBuffer = CL.mkAssign(CL.mkVar(concat[RN.globalsVarName,"_cl"]),
392                      CL.mkApply("clCreateBuffer", [                      CL.mkApply("clCreateBuffer", [
393                          CL.mkVar contextVar,                          CL.mkVar contextVar,
394                          CL.mkVar "CL_MEM_COPY_HOST_PTR",                          CL.mkVar "CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR",
395                          CL.mkApply("sizeof",[CL.mkVar RN.globalsTy]),                          CL.mkApply("sizeof",[CL.mkVar RN.globalsTy]),
396                          CL.mkVar RN.globalsVarName,                          CL.mkVar RN.globalsVarName,
397                          CL.mkUnOp(CL.%&,CL.mkVar errVar)                          CL.mkUnOp(CL.%&,CL.mkVar errVar)
398                        ]))                        ]))
399                fun genDataBuffers ([],_,_) = []                fun genDataBuffers ([],_,_,_) = []
400                  | genDataBuffers ((var,nDims)::globals, contextVar, errVar) = let                  | genDataBuffers ((var,nDims)::globals, contextVar, errVar,errFn) = let
401                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)                      val hostVar = CL.mkIndirect(CL.mkVar RN.globalsVarName, var)
402  (* FIXME: use CL constructors to build expressions (not strings) *)  (* FIXME: use CL constructors to build expressions (not strings) *)
403                      fun sizeExp i = CL.mkSubscript(CL.mkIndirect(hostVar, "size"), CL.mkInt i)                      fun sizeExp i = CL.mkSubscript(CL.mkIndirect(hostVar, "size"), CL.mkInt i)
# Line 408  Line 419 
419                              hostVar,                              hostVar,
420                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
421                            ])) ::                            ])) ::
422                          errFn(concat["error in creating ",RN.addBufferSuffix var, " global buffer"]) ::
423                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),                        CL.mkAssign(CL.mkVar(RN.addBufferSuffixData var),
424                          CL.mkApply("clCreateBuffer", [                          CL.mkApply("clCreateBuffer", [
425                              CL.mkVar contextVar,                              CL.mkVar contextVar,
# Line 415  Line 427 
427                              size,                              size,
428                              CL.mkIndirect(hostVar, "data"),                              CL.mkIndirect(hostVar, "data"),
429                              CL.mkUnOp(CL.%&,CL.mkVar errVar)                              CL.mkUnOp(CL.%&,CL.mkVar errVar)
430                            ])) :: genDataBuffers(globals,contextVar,errVar)                            ])) ::
431                            errFn(concat["error in creating ",RN.addBufferSuffixData var, " global buffer"]) ::
432                            genDataBuffers(globals,contextVar,errVar,errFn)
433                      end                      end
434                in                in
435                  globalBufferDecl :: globalBuffer :: genDataBuffers(globals,contextVar,errVar)                  globalBufferDecl
436                    :: globalBuffer
437                    :: errorFn(globalBuffErr)
438                    :: genDataBuffers(globals,contextVar,errVar,errorFn)
439                end                end
440    
441        (* generates the kernel arguments for the image data *)        (* generates the kernel arguments for the image data *)
442          fun genGlobalArguments (globals, count, kernelVar, errVar) = let          fun genGlobalArguments (globals, count, kernelVar, errVar) = let
443                  val globalArgErr = "error creating OpenCL global argument"
444                  fun errorFn msg = CL.mkIfThen(CL.mkBinOp(CL.E_Var errVar, CL.#!=, CL.E_Var "CL_SUCCESS"),
445                        CL.mkBlock([CL.mkCall("fprintf",[CL.E_Var "stderr", CL.E_Str msg]),
446                        CL.mkCall("exit",[CL.mkInt 1])]))
447                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,                val globalArgument = CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,
448                      CL.mkApply("clSetKernelArg",                      CL.mkApply("clSetKernelArg",
449                        [CL.mkVar kernelVar,                        [CL.mkVar kernelVar,
450                         CL.mkPostOp(CL.E_Var count, CL.^++),                         CL.mkPostOp(CL.E_Var count, CL.^++),
451                         CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                         CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
452                         CL.mkUnOp(CL.%&,CL.mkVar(concat[RN.globalsVarName,"_cl"]))])))                         CL.mkUnOp(CL.%&,CL.mkVar(concat[RN.globalsVarName,"_cl"]))])))
453                fun genDataArguments ([],_,_,_) = []                fun genDataArguments ([],_,_,_,_) = []
454                  | genDataArguments ((var,nDims)::globals,count,kernelVar,errVar) =                  | genDataArguments ((var,nDims)::globals,count,kernelVar,errVar,errFn) =
455                      CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,                      CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.$=,
456                        CL.mkApply("clSetKernelArg",                        CL.mkApply("clSetKernelArg",
457                          [CL.mkVar kernelVar,                          [CL.mkVar kernelVar,
458                           CL.mkPostOp(CL.E_Var count, CL.^++),                           CL.mkPostOp(CL.E_Var count, CL.^++),
459                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
460                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffix var))]))) ::                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffix var))]))) ::
461                      CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.|=,                           errFn(concat["error in creating ",RN.addBufferSuffix var, " argument"]) ::
462                        CL.mkExpStm(CL.mkAssignOp(CL.mkVar errVar,CL.$=,
463                        CL.mkApply("clSetKernelArg",                        CL.mkApply("clSetKernelArg",
464                          [CL.mkVar kernelVar,                          [CL.mkVar kernelVar,
465                           CL.mkPostOp(CL.E_Var count, CL.^++),                           CL.mkPostOp(CL.E_Var count, CL.^++),
466                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),                           CL.mkApply("sizeof",[CL.mkVar "cl_mem"]),
467                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::                           CL.mkUnOp(CL.%&,CL.mkVar(RN.addBufferSuffixData var))]))) ::
468                      genDataArguments (globals,count,kernelVar,errVar)                           errFn(concat["error in creating ",RN.addBufferSuffixData var, " argument"]) ::
469                        genDataArguments (globals,count,kernelVar,errVar,errFn)
470                in                in
471                  globalArgument :: genDataArguments(globals, count, kernelVar, errVar)                 [globalArgument,errorFn(globalArgErr)] @ genDataArguments(globals, count, kernelVar, errVar,errorFn)
472                end                end
473    
474        (* generates the globals buffers and arguments function *)        (* generates the globals buffers and arguments function *)
# Line 456  Line 479 
479                val params = [                val params = [
480                        CL.PARAM([],CL.T_Named("cl_context"), "context"),                        CL.PARAM([],CL.T_Named("cl_context"), "context"),
481                        CL.PARAM([],CL.T_Named("cl_kernel"), "kernel"),                        CL.PARAM([],CL.T_Named("cl_kernel"), "kernel"),
482                          CL.PARAM([],CL.T_Named("cl_command_queue"), "cmdQ"),
483                        CL.PARAM([],CL.T_Named("int"), "argStart")                        CL.PARAM([],CL.T_Named("int"), "argStart")
484                      ]                      ]
485                val clGlobalBuffers = getGlobalDataBuffers(!imgGlobals, "context", errVar)                val clGlobalBuffers = getGlobalDataBuffers(!imgGlobals, "context", errVar)
# Line 469  Line 493 
493    
494        (* generate the data and global parameters *)        (* generate the data and global parameters *)
495          fun genKeneralGlobalParams ((name,tyname)::rest) =          fun genKeneralGlobalParams ((name,tyname)::rest) =
496                CL.PARAM([], CL.T_Ptr(CL.T_Named RN.globalsTy), concat[RN.globalsVarName]) ::                globalParam (CL.T_Ptr(CL.T_Named (RN.imageTy tyname)), RN.addBufferSuffix name) ::
497                CL.PARAM([], CL.T_Ptr(CL.T_Named (RN.imageTy tyname)),RN.addBufferSuffix name) ::                globalParam (CL.T_Ptr(CL.voidTy), RN.addBufferSuffixData name) ::
               CL.PARAM([], CL.T_Ptr(CL.voidTy),RN.addBufferSuffixData name) ::  
498                genKeneralGlobalParams rest                genKeneralGlobalParams rest
499            | genKeneralGlobalParams [] = []            | genKeneralGlobalParams [] = []
500    
# Line 489  Line 512 
512                val fName = RN.kernelFuncName;                val fName = RN.kernelFuncName;
513                val inState = "strand_in"                val inState = "strand_in"
514                val outState = "strand_out"                val outState = "strand_out"
515                                      val tempVar = "tmp"
516                val params = [                val params = [
517                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),
518                        CL.PARAM(["__global"], CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),
519                        CL.PARAM(["__global"], CL.intTy, "width")                        globalParam (CL.intTy, "width"),
520                          globalParam (CL.T_Ptr(CL.T_Named RN.globalsTy), RN.globalsVarName)
521                      ] @ genKeneralGlobalParams(!imgGlobals)                      ] @ genKeneralGlobalParams(!imgGlobals)
522                val thread_ids = if nDims = 1                val thread_ids = if nDims = 1
523                      then [                      then [
524                          CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.mkInt 0))),                            CL.mkDecl(CL.intTy, "x",
525                          CL.mkAssign(CL.mkVar "x",CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0]))                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0]))))
526                        ]                        ]
527                      else [                      else if nDims = 2
528                          CL.mkDecl(CL.intTy, "x", SOME(CL.I_Exp(CL.mkInt 0))),                        then [
529                          CL.mkDecl(CL.intTy, "y", SOME(CL.I_Exp(CL.mkInt 0))),                            CL.mkDecl(CL.intTy, "x",
530                          CL.mkAssign(CL.mkVar "x",  CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])),                              SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 0])))),
531                          CL.mkAssign(CL.mkVar "y",CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1]))                            CL.mkDecl(CL.intTy, "y",
532                                SOME(CL.I_Exp(CL.mkApply(RN.getGlobalThreadId,[CL.mkInt 1]))))
533                        ]                        ]
534                        else raise Fail "nDims > 2"
535                val strandDecl = [                val strandDecl = [
536                      CL.mkDecl(CL.T_Named tyName, inState, NONE),                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), inState, NONE),
537                      CL.mkDecl(CL.T_Named tyName, outState,NONE)]                        CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), outState, NONE),
538                          CL.mkDecl(CL.T_Ptr(CL.T_Named (concat["__global ",tyName])), tempVar, NONE)
539                        ]
540                  val swapStms = [
541                          CL.mkAssign(CL.E_Var tempVar, CL.E_Var inState),
542                          CL.mkAssign(CL.E_Var inState, CL.E_Var outState),
543                          CL.mkAssign(CL.E_Var outState, CL.E_Var tempVar)
544                        ]
545                val strandObjects = if nDims = 1                val strandObjects = if nDims = 1
546                      then [                      then [
547                          CL.mkAssign( CL.mkVar inState, CL.mkSubscript(CL.mkVar "selfIn", CL.mkStr "x")),                          CL.mkAssign( CL.mkVar inState,  CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfIn", CL.mkStr "x"))),
548                          CL.mkAssign(CL.mkVar outState,CL.mkSubscript(CL.mkVar "selfOut", CL.mkStr "x"))                          CL.mkAssign(CL.mkVar outState, CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfOut", CL.mkStr "x")))
549                        ]                        ]
550                      else let                      else let
551                        val index = CL.mkBinOp(CL.mkBinOp(CL.mkVar "x",CL.#*,CL.mkVar "width"),CL.#+,CL.mkVar "y")                        val index = CL.mkBinOp(
552                                CL.mkBinOp(CL.mkVar "x", CL.#*, CL.mkVar "width"), CL.#+, CL.mkVar "y")
553                        in [                        in [
554                          CL.mkAssign(CL.mkVar inState, CL.mkSubscript(CL.mkVar "selfIn",index)),                          CL.mkAssign(CL.mkVar inState,  CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfIn",index))),
555                          CL.mkAssign(CL.mkVar outState,CL.mkSubscript(CL.mkVar "selfOut",index))                          CL.mkAssign(CL.mkVar outState, CL.mkUnOp(CL.%&,CL.mkSubscript(CL.mkVar "selfOut",index)))
556                        ] end                        ] end
557                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkInt 0)))                val status = CL.mkDecl(CL.intTy, "status", SOME(CL.I_Exp(CL.mkInt 0)))
558                val strand_Init_Stm = CL.mkCall(RN.strandInit name, [CL.E_Var RN.globalsVarName,CL.mkUnOp(CL.%&,CL.E_Var inState), CL.E_Var "x", CL.E_Var "y"])                val strandInitStm = CL.mkCall(RN.strandInit name, [
559                val local_vars = thread_ids @ initGlobalImages(!imgGlobals)  @ strandDecl @ strandObjects @ [strand_Init_Stm,status]                        CL.E_Var RN.globalsVarName,
560                          CL.E_Var inState,
561                          CL.E_Var "x",
562    (* FIXME: if nDims = 1, then "y" is not defined! the arguments to this call should really come from
563     * the initially code!
564     *)
565                          CL.E_Var "y"])
566                  val local_vars = thread_ids
567                        @ initGlobalImages(!imgGlobals)
568                        @ strandDecl
569                        @ strandObjects
570                        @ [strandInitStm,status]
571                                    val while_exp = CL.mkBinOp(                                    val while_exp = CL.mkBinOp(
572                      CL.mkBinOp(CL.mkVar "status",CL.#!=, CL.mkVar RN.kStabilize),                      CL.mkBinOp(CL.mkVar "status",CL.#!=, CL.mkVar RN.kStabilize),
573                      CL.#||,                      CL.#&&,
574                      CL.mkBinOp(CL.mkVar "status", CL.#!=, CL.mkVar RN.kDie))                      CL.mkBinOp(CL.mkVar "status", CL.#!=, CL.mkVar RN.kDie))
575                val whileBody = CL.mkBlock [                val whileBody = CL.mkBlock (swapStms @ [
576    (* FIXME: need a barrier synchronization at beginning of loop *)
577                        CL.mkAssign(CL.mkVar "status",                        CL.mkAssign(CL.mkVar "status",
578                          CL.mkApply(RN.strandUpdate name,                          CL.mkApply(RN.strandUpdate name,
579                            [CL.mkUnOp(CL.%&,CL.mkVar inState), CL.mkUnOp(CL.%&,CL.mkVar outState),CL.E_Var RN.globalsVarName])),                            [CL.mkVar inState, CL.mkVar outState,CL.E_Var RN.globalsVarName]))] )
                       CL.mkCall(RN.strandStabilize name,  
                         [CL.mkUnOp(CL.%&,CL.mkVar inState), CL.mkUnOp(CL.%&,CL.mkVar outState),CL.E_Var RN.globalsVarName])  
                     ]  
580                val whileBlock = [CL.mkWhile(while_exp, whileBody)]                val whileBlock = [CL.mkWhile(while_exp, whileBody)]
581                val body = CL.mkBlock(local_vars  @ whileBlock)                val body = CL.mkBlock(local_vars  @ whileBlock)
582                in                in
# Line 544  Line 588 
588                in                in
589                  CL.D_StructDef(globs, RN.globalsTy)                  CL.D_StructDef(globs, RN.globalsTy)
590                end                end
591    
592          fun genGlobals (declFn, targetTy, globals) = let          fun genGlobals (declFn, targetTy, globals) = let
593                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))
594                in                in
# Line 695  Line 740 
740          fun init (Strand{name, tyName, code, init_code, ...}, params, init) = let          fun init (Strand{name, tyName, code, init_code, ...}, params, init) = let
741                val fName = RN.strandInit name                val fName = RN.strandInit name
742                val params =                val params =
743                      CL.PARAM([], globPtrTy, RN.globalsVarName) ::                      globalParam (globPtrTy, RN.globalsVarName) ::
744                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::                      globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
745                        List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params                        List.map (fn (ToCL.V(ty, x)) => CL.PARAM([], ty, x)) params
746                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)
747                in                in
# Line 707  Line 752 
752          fun method (Strand{name, tyName, code,...}, methName, body) = let          fun method (Strand{name, tyName, code,...}, methName, body) = let
753                val fName = concat[name, "_", methName]                val fName = concat[name, "_", methName]
754                val params = [                val params = [
755                        CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfIn"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfIn"),
756                        CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut"),                        globalParam (CL.T_Ptr(CL.T_Named tyName), "selfOut"),
757                                                           CL.PARAM([], CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName)                        globalParam (CL.T_Ptr(CL.T_Named (RN.globalsTy)), RN.globalsVarName)
758                      ]                      ]
759                val methFn = CL.D_Func([], CL.int32, fName, params, body)                val methFn = CL.D_Func([], CL.int32, fName, params, body)
760                in                in

Legend:
Removed from v.1321  
changed lines
  Added in v.1344

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