Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/vis12-cl/src/compiler/cl-target/cl-target.sml
ViewVC logotype

Diff of /branches/vis12-cl/src/compiler/cl-target/cl-target.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2742, Sat Sep 27 23:33:58 2014 UTC revision 2743, Sun Sep 28 02:54:54 2014 UTC
# Line 35  Line 35 
35          name : string,          name : string,
36          tyName : string,          tyName : string,
37          state : var list,          state : var list,
38          output : (Ty.ty * CL.var) list, (* the strand's output variables *)          outputs : (Ty.ty * CL.var) list, (* the strand's output variables *)
39          code : CL.decl list ref          code : CL.decl list ref
40        }        }
41    
# Line 81  Line 81 
81      fun inlineCons n = (n < 2)          (* vectors are inline, but not matrices *)      fun inlineCons n = (n < 2)          (* vectors are inline, but not matrices *)
82      val inlineMatrixExp = false         (* can matrix-valued expressions appear inline? *)      val inlineMatrixExp = false         (* can matrix-valued expressions appear inline? *)
83    
   (* helper functions for specifying parameters in various address spaces *)  
     local  
       fun param spc (ty, x) = CL.PARAM([spc], ty, x)  
     in  
     val globalParam = param "__global"  
     val constantParam = param "__constant"  
     val localParam = param "__local"  
     val privateParam = param "__private"  
     fun clParam (ty, x) = CL.PARAM([], ty, x)  
     end (* local *)  
   
84    (* OpenCL global pointer type *)    (* OpenCL global pointer type *)
85      fun globalPtr ty = CL.T_Qual("__global", CL.T_Ptr ty)      fun globalPtrTy props = CL.T_Ptr(CL.T_Named(CLN.globalsTy props))
86    
87        fun worldPtrTy props = CL.T_Ptr(CL.T_Named(RN.worldTy props))
88    
89    (* TreeIL to target translations *)    (* TreeIL to target translations *)
90      structure Tr =      structure Tr =
# Line 211  Line 202 
202                        name = name,                        name = name,
203                        tyName = CLN.strandTy name,                        tyName = CLN.strandTy name,
204                        state = state,                        state = state,
205                        output = outputVars,                        outputs = outputVars,
206                        code = ref []                        code = ref []
207                      }                      }
208                in                in
# Line 226  Line 217 
217         * parameters.         * parameters.
218         *)         *)
219          fun init (Strand{prog=Prog{props, ...}, name, tyName, code, ...}, params, init) = let          fun init (Strand{prog=Prog{props, ...}, name, tyName, code, ...}, params, init) = let
220                val globTy = CL.T_Ptr(CL.T_Named(CLN.globalsTy props))                val globTy = globalPtrTy props
221                val fName = CLN.strandInit name                val fName = CLN.strandInit name
222                val selfParam = if Properties.dualState props                val selfParam = if Properties.dualState props
223                      then "selfOut"                      then "selfOut"
224                      else "self"                      else "self"
225                val params =                val params =
226                      CL.PARAM([], globTy, "glob") ::                      CLU.globalParam(globTy, "glob") ::
227                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), selfParam) ::                      CLU.globalParam(CL.T_Ptr(CL.T_Named tyName), selfParam) ::
228                        List.map (fn (CL.V(ty, x)) => CL.PARAM([], ty, x)) params                        List.map (fn (CL.V(ty, x)) => CLU.clParam(ty, x)) params
229                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)
230                in                in
231                  code := initFn :: !code                  code := initFn :: !code
# Line 242  Line 233 
233    
234        (* register a strand method *)        (* register a strand method *)
235          fun method (Strand{prog=Prog{props, ...}, name, tyName, code, ...}, methName, body) = let          fun method (Strand{prog=Prog{props, ...}, name, tyName, code, ...}, methName, body) = let
236                val globTy = CL.T_Ptr(CL.T_Named(CLN.globalsTy props))                val globTy = globalPtrTy props
237                val fName = concat[name, "_", StrandUtil.nameToString methName]                val fName = concat[name, "_", StrandUtil.nameToString methName]
238                val stateParams = if Properties.dualState props                val stateParams = if Properties.dualState props
239                      then [                      then [
# Line 251  Line 242 
242                        ]                        ]
243                      else [CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")]                      else [CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "self")]
244                val params =                val params =
245                      globalParam (globTy, "glob") ::                      CLU.globalParam (globTy, "glob") ::
246                      stateParams                      stateParams
247                val resTy = (case methName                val resTy = (case methName
248                       of StrandUtil.Update => CL.T_Named "StrandStatus_t"                       of StrandUtil.Update => CL.T_Named "StrandStatus_t"
# Line 293  Line 284 
284          fun inputs (Prog{inputs, ...}, env, blk) = inputs := GenInputs.gatherInputs blk          fun inputs (Prog{inputs, ...}, env, blk) = inputs := GenInputs.gatherInputs blk
285        (* register the global initialization part of a program *)        (* register the global initialization part of a program *)
286          fun init (Prog{props, globals, topOCLDecls, ...}, init) = let          fun init (Prog{props, globals, topOCLDecls, ...}, init) = let
287                val globTy = CL.T_Ptr(CL.T_Named(CLN.globalsTy props))                val globTy = globalPtrTy props
288                val initKern = CLU.mkTaskKernel (CLN.initGlobalsKern,                val initKern = CLU.mkTaskKernel (CLN.initGlobalsKern,
289                      [CLU.globalParam(globTy, "glob")],                      [CLU.globalParam(globTy, "glob")],
290                      init)                      init)
# Line 302  Line 293 
293                end                end
294        (* register the global destruction part of a program *)        (* register the global destruction part of a program *)
295          fun free (Prog{props, topCDecls, ...}, env, globals) = let          fun free (Prog{props, topCDecls, ...}, env, globals) = let
296                val worldTy = CL.T_Ptr(CL.T_Named(RN.worldTy props))                val worldTy = worldPtrTy props
297                fun freeGlob (x, stms) = stms (* FIXME *)                fun freeGlob (x, stms) = stms (* FIXME *)
298                val body = CL.mkBlock(List.foldr freeGlob [CL.mkReturn(SOME(CL.mkVar "false"))] globals)                val body = CL.mkBlock(List.foldr freeGlob [CL.mkReturn(SOME(CL.mkVar "false"))] globals)
299                val freeFn = CL.D_Func(                val freeFn = CL.D_Func(
# Line 324  Line 315 
315              } = let              } = let
316                val name = Atom.toString strand                val name = Atom.toString strand
317                val nDims = List.length iters                val nDims = List.length iters
318                val globTy = CL.T_Ptr(CL.T_Named(CLN.globalsTy props))                val globTy = globalPtrTy props
319              (* create the code to set the initially dimensions in the globals structure; this code              (* create the code to set the initially dimensions in the globals structure; this code
320               * will be included in the InitGlobals kernel.               * will be included in the InitGlobals kernel.
321               *)               *)
# Line 340  Line 331 
331              (* create the loop nest for the initially iterations *)              (* create the loop nest for the initially iterations *)
332                val indexVar = "ix"                val indexVar = "ix"
333                val strandTy = CL.T_Ptr(CL.T_Named(CLN.strandTy name))                val strandTy = CL.T_Ptr(CL.T_Named(CLN.strandTy name))
334                fun statePtr inout = CL.mkSubscript(CL.mkIndirect(CL.mkVar "wrld", inout), CL.mkVar indexVar)                fun statePtr inout = CL.mkAddrOf(CL.mkSubscript(CL.mkVar inout, CL.mkVar indexVar))
335                fun mkLoopNest [] = CL.mkBlock(createPrefix @ [                fun mkLoopNest [] = if Properties.dualState props
336                        then CL.mkBlock(createPrefix @ [
337                        CL.mkCall(CLN.strandInit name, CL.mkVar "glob" :: statePtr "inState" :: args),                        CL.mkCall(CLN.strandInit name, CL.mkVar "glob" :: statePtr "inState" :: args),
338                        CL.mkCall("memcpy", [                        CL.mkCall("memcpy", [
339                            statePtr "outState", statePtr "inState",                            statePtr "outState", statePtr "inState",
# Line 349  Line 341 
341                          ]),                          ]),
342                        CL.S_Exp(CL.mkPostOp(CL.mkVar indexVar, CL.^++))                        CL.S_Exp(CL.mkPostOp(CL.mkVar indexVar, CL.^++))
343                      ])                      ])
344                        else CL.mkBlock(createPrefix @ [
345                            CL.mkCall(CLN.strandInit name, CL.mkVar "glob" :: statePtr "state" :: args),
346                            CL.S_Exp(CL.mkPostOp(CL.mkVar indexVar, CL.^++))
347                          ])
348                  | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let                  | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let
349                      val body = mkLoopNest iters                      val body = mkLoopNest iters
350                      in                      in
# Line 421  Line 417 
417                  end                  end
418                else [Properties.runtimeName props]                else [Properties.runtimeName props]
419    
420          fun genStrand (Strand{prog=Prog{props, ...}, name, tyName, state, output, code}) = let          fun genStrandStruct (Strand{prog=Prog{props, ...}, name, tyName, state, ...}) = let
421              (* the type declaration for the strand's state struct *)              (* the type declaration for the strand's state struct *)
422                val selfTyDef = CL.D_StructDef(                val selfTyDef = CL.D_StructDef(
423                        SOME(concat[#namespace props, "struct_", name]),                        NONE,
424                        List.rev (List.map (fn CL.V(ty, x) => (ty, x)) state),                        List.rev (List.map (fn CL.V(ty, x) => (ty, x)) state),
425                        NONE)                        SOME(CLN.strandTy name))
426                in                in
427                  selfTyDef :: List.rev (!code)                  selfTyDef
428                end                end
429    
430        (* generate an OpenCL struct definition for the globals.  In addition to the user-defined        (* generate an OpenCL struct definition for the globals.  In addition to the user-defined
# Line 445  Line 441 
441                  CL.D_StructDef(NONE, fields, SOME(CLN.globalsTy props))                  CL.D_StructDef(NONE, fields, SOME(CLN.globalsTy props))
442                end                end
443    
444            fun genBindKernels (props, kernels) = let
445                  val worldTy = worldPtrTy props
446                  fun bindKern (k, stms) =
447                        CL.mkAssign(
448                          CL.mkIndirect(CL.mkVar "wrld", k),
449                          CL.mkApply("clCreateKernel", [
450                              CL.mkIndirect(CL.mkVar "wrld", "prog"), CL.mkStr k, CL.mkAddrOf(CL.mkVar "sts")
451                            ])) ::
452                        CL.mkIfThen(CL.mkBinOp(CL.mkVar "sts", CL.#!=, CL.mkVar "CL_SUCCESS"),
453                          CL.mkReturn(SOME(CL.mkVar "true"))) ::
454                        stms
455                  val stms = List.foldr bindKern [CL.mkReturn(SOME(CL.mkVar "false"))] kernels
456                  val stms = CL.mkDecl(CL.T_Named "cl_int", "sts", NONE) :: stms
457                  val body = CL.mkBlock stms
458                  in
459                    CL.D_Func(["static"], CL.boolTy, "BindKernels", [CL.PARAM([], worldTy, "wrld")], body)
460                  end
461    
462        (* generate the C struct declaration for the world representation *)        (* generate the C struct declaration for the world representation *)
463          fun genWorldStruct (Prog{props, globals, kernels, ...}) = let          fun genWorldStruct (Prog{props, globals, kernels, ...}) = let
464  (*  (*
# Line 473  Line 487 
487                val extras =                val extras =
488                      (CL.T_Ptr(CL.T_Named "Diderot_DeviceInfo_t"), "device") ::                      (CL.T_Ptr(CL.T_Named "Diderot_DeviceInfo_t"), "device") ::
489                      (CL.T_Named "cl_context", "context") ::                      (CL.T_Named "cl_context", "context") ::
490                      (CL.T_Named "cl_command_queue", "cmdQ") :: extras                      (CL.T_Named "cl_command_queue", "cmdQ") ::
491                        (CL.T_Named "cl_program", "prog") :: extras
492              (* add fields for GPU memory objects *)              (* add fields for GPU memory objects *)
493                val extras =                val extras =
494                      (CL.T_Named "cl_mem", "globalsBuf") ::                      (CL.T_Named "cl_mem", "globalsBuf") ::
# Line 521  Line 536 
536        (* generate the OpenCL source code. *)        (* generate the OpenCL source code. *)
537          fun outputCLSrc (out : output, prog, strand, substitutions) = let          fun outputCLSrc (out : output, prog, strand, substitutions) = let
538                val Prog{props, nAxes, initDim, globals, topOCLDecls, ...} = prog                val Prog{props, nAxes, initDim, globals, topOCLDecls, ...} = prog
539                val Strand{output, ...} = strand                val Strand{outputs, code=strandCode, ...} = strand
540                val outputs = GenOutput.genKernels (props, !nAxes) output                val outputs = GenOutput.genKernels (props, !nAxes) outputs
541                fun ppDecl dcl = PrintAsCL.output(#ppStrm out, dcl)                fun ppDecl dcl = PrintAsCL.output(#ppStrm out, dcl)
542                in                in
543                (* Retrieve the header information *)                (* Retrieve the header information *)
# Line 533  Line 548 
548                    else ();                    else ();
549                (* type definitions *)                (* type definitions *)
550                  ppDecl (genGlobalStruct (props, !initDim, !globals));                  ppDecl (genGlobalStruct (props, !initDim, !globals));
551                    ppDecl (genStrandStruct strand);
552                (* kernel for computing sizes of runtime data structures *)                (* kernel for computing sizes of runtime data structures *)
553                  ppDecl (CL.verbatimDcl [CLSizesFrag.text] substitutions);                  ppDecl (CL.verbatimDcl [CLSizesFrag.text] substitutions);
               (* Specialize the scheduler kernels and functions *)  
                 ppDecl (CL.D_Verbatim[CLSchedFrag.text]);  
554  (* FIXME: should only include eigen code fragments if they are being used! *)  (* FIXME: should only include eigen code fragments if they are being used! *)
555                  ppDecl (CL.D_Verbatim[CLEigen2x2Frag.text]);                  ppDecl (CL.D_Verbatim[CLEigen2x2Frag.text]);
556  (* FIXME: should only include eigen code fragments if they are being used! *)  (* FIXME: should only include eigen code fragments if they are being used! *)
557                  ppDecl (CL.D_Verbatim[CLEigen3x3Frag.text]);                  ppDecl (CL.D_Verbatim[CLEigen3x3Frag.text]);
558  (* FIXME: generate the functions to initialize the globals *)  (* FIXME: generate the functions to initialize the globals *)
                 List.app ppDecl (genStrand strand);  
559                  List.app ppDecl outputs;                  List.app ppDecl outputs;
560                  List.app ppDecl (!topOCLDecls)                  List.app ppDecl (!strandCode);
561                    List.app ppDecl (!topOCLDecls);
562                  (* Specialize the scheduler kernels and functions *)
563                    ppDecl (CL.D_Verbatim[CLSchedCommonFrag.text]);
564                    if Properties.noBSP props
565                      then ppDecl (CL.D_Verbatim[CLSchedNoBSPFrag.text, CLUpdateNoBSPFrag.text])
566                    else if Properties.noComm props
567                      then ppDecl (CL.D_Verbatim[CLSchedFrag.text, CLUpdateNoComFrag.text])
568                      else ppDecl (CL.D_Verbatim[CLSchedFrag.text, CLUpdateFrag.text])
569                end                end
570    
571        (* output common C source that is common to both the library and standalone targets *)        (* output common C source that is common to both the library and standalone targets *)
572          fun outputCSrc (out : output, prog, strand, substitutions) = let          fun outputCSrc (out : output, prog, strand, substitutions) = let
573                val Prog{props, nAxes, inputs, ...} = prog                val Prog{props, nAxes, inputs, kernels, ...} = prog
574                fun ppDecl dcl = PrintAsC.output(#ppStrm out, dcl)                fun ppDecl dcl = PrintAsC.output(#ppStrm out, dcl)
575                in                in
576                  if Properties.dualState props                  if Properties.dualState props
# Line 564  Line 585 
585                (* support code for OpenCL *)                (* support code for OpenCL *)
586                  ppDecl (CL.verbatimDcl [                  ppDecl (CL.verbatimDcl [
587                      CCheckCLStatusFrag.text                      CCheckCLStatusFrag.text
588                    ] substitutions)                    ] substitutions);
589                  (* kernel binding *)
590                    ppDecl (genBindKernels (props, !kernels))
591                end                end
592    
593          fun outputLibSrc (out : output, prog, strand, substitutions) = let          fun outputLibSrc (out : output, prog, strand, substitutions) = let
594                val Prog{props, inputs, topCDecls, nAxes, ...} = prog                val Prog{props, inputs, topCDecls, nAxes, ...} = prog
595                val Strand{output, ...} = strand                val Strand{outputs, ...} = strand
596                val outputs = GenOutput.gen (props, !nAxes) output                val outputs = GenOutput.gen (props, !nAxes) outputs
597                fun ppDecl dcl = PrintAsC.output(#ppStrm out, dcl)                fun ppDecl dcl = PrintAsC.output(#ppStrm out, dcl)
598                in                in
599                  ppDecl (CL.verbatimDcl [LibHdrFrag.text] substitutions);                  ppDecl (CL.verbatimDcl [LibHdrFrag.text] substitutions);
# Line 589  Line 612 
612                val {outDir, outBase, exec, double, parallel, debug, ...} = props                val {outDir, outBase, exec, double, parallel, debug, ...} = props
613                val [strand] = AtomTable.listItems strands                val [strand] = AtomTable.listItems strands
614                val basename = OS.Path.joinDirFile{dir=outDir, file=outBase}                val basename = OS.Path.joinDirFile{dir=outDir, file=outBase}
615                val [Strand{state, output, ...}] = AtomTable.listItems strands                val [Strand{state, outputs, ...}] = AtomTable.listItems strands
616                val {cOut, oclOut} = openOut basename                val {cOut, oclOut} = openOut basename
617                val substitutions = mkSubs(props, strand)                val substitutions = mkSubs(props, strand)
618                in                in
# Line 598  Line 621 
621                      props = props,                      props = props,
622                      rt = SOME CLibInterfaceCLFrag.text,                      rt = SOME CLibInterfaceCLFrag.text,
623                      inputs = !inputs,                      inputs = !inputs,
624                      outputs = output                      outputs = outputs
625                    };                    };
626                (* generate source code *)                (* generate source code *)
627                  outputLibSrc (cOut, prog, strand, substitutions);                  outputLibSrc (cOut, prog, strand, substitutions);
# Line 613  Line 636 
636    
637          fun outputExecSrc (out : output, prog, strand, substitutions) = let          fun outputExecSrc (out : output, prog, strand, substitutions) = let
638                val Prog{props, inputs, topCDecls, strands, nAxes, ...} = prog                val Prog{props, inputs, topCDecls, strands, nAxes, ...} = prog
639                val Strand{output, ...} = strand                val Strand{outputs, ...} = strand
640                val outputs = GenOutput.gen (props, !nAxes) output                val outputs = GenOutput.gen (props, !nAxes) outputs
641                fun ppDecl dcl = PrintAsC.output(#ppStrm out, dcl)                fun ppDecl dcl = PrintAsC.output(#ppStrm out, dcl)
642                in                in
643                  ppDecl (CL.verbatimDcl [ExecHdrFrag.text] substitutions);                  ppDecl (CL.verbatimDcl [ExecHdrFrag.text] substitutions);

Legend:
Removed from v.2742  
changed lines
  Added in v.2743

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